Skip to content

hany202507/finance-ai-skills / skills/분개테스트

분개테스트

Verified

회사 분개장 엑셀 전부를 엔진이 판독해 감사 분개 테스트(JET, 한공회 3600-JET) 조서를 엑셀로 만든다. 완전성(받은 파일별 줄 수 · 기간 · 잘림 · 빠진 달, 차대 일치 · 손익계정 분개장 순액 = 시산표), 시험 스물여섯 가지의 건수 · 금액 · 결과 목록, 먼저 볼 전표(고위험 전부 · 점수 상위), 회계사 검토 칸을 낸다. 시험은 주말 · 공휴일, 기말 후 취소 · 역분개, 결산일 근처 큰 금액, 드문 계정 조합, 끝자리 0 반복, 적요 없음, 수기 조정, 전표 형식 이상, 전표번호 중복 · 순서 역전, 한 번만 나온 거래처의 큰 금액, 결산일 근처 이익을 늘린 전표, 중복 의심, 대표 · 주주 · 임원 관련 계정, 자본 계정, 적요 주의 낱말, 계정별로 평소보다 큰 금액, 결산일 근처 가계정 정리, 추정 계정의 기말 조정 · 환입, 현금 · 채권 · 채무 없이 이익을 늘린 전표, 드물게 쓰는 계정, 결산일 근처 매출의 기말 후 회수 없음, 승인 한도 바로 아래 금액(한도를 넣었을 때), 그리고 작성자 · 승인자 · 입력일시 열이 있을 때 자기 승인, 드물게 분개한 작성자, 결산 후 입력, 업무 시간이 아닌 입력이다. 첫 자리 분포(벤포드) · 월별 매출 · 전표번호 연속성 분석 시트와 여러 시험에 걸린 전표 시트도 낸다. 더존 · 위하고 등 여러 꼴의 분개장(한 줄에 계정 하나인 꼴, 한 행에 차변 계정 · 대변 계정이 함께 있는 꼴)을 읽는다. "JET", "분개 테스트", "분개장 전수", "3600-JET", "기말 후 취소 전표", "역분개", "주말 전표", "수기 전표", "이상 분개", "경영진 무시 위험", "저널 엔트리 테스트", "자기 승인 전표", "결산 후 입력", "전표번호 누락", "중복 전표", "벤포드", "가지급금 전표"가 언급되면 트리거.

FileKindSize
README.mdmarkdown3.4 KB
SKILL.mdskill md13.9 KB
examples/모의자료/분개장_2025.xlsxbinary109.0 KB
examples/모의자료/분개장_2026_기말후.xlsxbinary23.5 KB
examples/모의자료/재무제표_시산표.xlsxbinary5.9 KB
references/시험해보기.mdmarkdown1.6 KB
requirements.txtmanifest89 B
scripts/audit/__init__.pyscript273 B
scripts/audit/analysis/__init__.pyscript159 B
scripts/audit/analysis/defs.pyscript7.4 KB
scripts/audit/analysis/pdfread.pyscript18.7 KB
scripts/audit/assign.pyscript12.6 KB
scripts/audit/checklists.pyscript35.4 KB
scripts/audit/dart.pyscript22.3 KB
scripts/audit/director.pyscript62.0 KB
scripts/audit/errors.pyscript503 B
scripts/audit/figures.pyscript35.4 KB
scripts/audit/folder.pyscript27.1 KB
scripts/audit/index.pyscript28.9 KB
scripts/audit/ocr.pyscript13.2 KB
scripts/audit/params.pyscript15.3 KB
scripts/audit/prior.pyscript29.8 KB
scripts/audit/priorwp.pyscript33.6 KB
scripts/audit/reader.pyscript94.6 KB
scripts/audit/records.pyscript21.9 KB
scripts/audit/shareholders.pyscript19.9 KB
scripts/audit/start.pyscript81.8 KB
scripts/audit/style.pyscript7.8 KB
scripts/audit/workpapers/__init__.pyscript159 B
scripts/audit/workpapers/common.pyscript32.9 KB
scripts/audit/workpapers/jet.pyscript98.3 KB
scripts/audit/wp.pyscript34.5 KB
scripts/definitions/accounts.yamlconfig19.4 KB
scripts/definitions/folder_standard.yamlconfig15.1 KB
scripts/definitions/index_schema.jsonconfig19.1 KB
scripts/definitions/index_schema_analysis.jsonconfig15.2 KB
scripts/definitions/index_schema_apply.jsonconfig4.2 KB
scripts/definitions/index_schema_assign.jsonconfig977 B
scripts/definitions/index_schema_close.jsonconfig2.7 KB
scripts/definitions/index_schema_prior.jsonconfig5.1 KB
scripts/definitions/index_schema_report.jsonconfig4.1 KB
scripts/definitions/index_schema_start.jsonconfig8.8 KB
scripts/definitions/index_schema_workpapers.jsonconfig6.1 KB
scripts/definitions/jet.yamlconfig24.3 KB
scripts/definitions/received_links.yamlconfig2.0 KB
scripts/definitions/workpapers.yamlconfig20.4 KB
scripts/run.pyscript5.8 KB
tests/make_entry_columns.pyscript5.1 KB
tests/test_jet.pyscript17.3 KB

scripts/audit/workpapers/jet.py

View on GitHub
"""3600-JET 분개 테스트(R4, 2026-10-05).

분개장 받은자료 전부를 엔진이 판독해 전표 단위로 시험한다. 시험 정의는 definitions/jet.yaml.
완전성: 당기 분개장의 손익계정 순액을 시산표와 맞춘다(재무상태표 계정은 기초 잔액이 분개장에 없어 전기 시산표가 있어야 한다).
결과 목록의 전표마다 검토 결과 기입란을 둔다. 판단(정상 거래인지)은 회계사가 적는다.
2026-10-21 시험 열세 가지(형식 이상 · 전표번호 · 한 번만 나온 거래처 · 이익을 늘린 결산 전표 · 중복 · 특수관계 · 자본 · 적요 낱말 ·
계정별로 평소보다 큰 금액, 작성자 · 승인자 · 입력일시 열이 있을 때 자기 승인 · 드문 작성자 · 결산 후 입력 · 업무 시간 외 입력)와
전표번호 연속성 · 분포 분석(첫 자리 · 월별) 시트를 더했다. 기존 일곱 시험의 판정은 그대로다.

  run(d, mat) -> {"tests": [{id, title, condition, review, hits: [{voucher, why}], note}], "completeness": [...], "seq": {...},
                  "analyses": {...}, "entry_cols": {...}, ...}
"""
from __future__ import annotations

import math
import re
import statistics
from bisect import bisect_right
from collections import Counter, defaultdict
from datetime import date, datetime, timedelta
from datetime import time as dtime
from pathlib import Path

from .. import wp
from . import common
from .common import ask, won


_MEMO: dict = {}


def _memo(fn, x: common.Line, group: dict) -> bool:
    """계정 묶음 판정은 줄의 (코드, 이름) 과 묶음만으로 정해진다. 같은 짝은 한 번만 계산한다(2026-11-09: 37만 줄 분개장에서
    _in · _hit 이 실행 시간의 3분의 1). 묶음은 id 로 찾고 객체가 같은지 다시 본다(다른 run 에서 id 가 다시 쓰여도 틀리지 않게)."""
    k = (fn, id(group), x.code, x.name)
    e = _MEMO.get(k)
    if e is not None and e[0] is group:
        return e[1]
    r = fn(x, group)
    if len(_MEMO) > 200_000:
        _MEMO.clear()
    _MEMO[k] = (group, r)
    return r


def _in(x: common.Line, group: dict) -> bool:
    return _memo(_in_raw, x, group)


def _in_raw(x: common.Line, group: dict) -> bool:
    """줄 하나가 계정 묶음에 드는지(2026-10-21). 코드가 있으면 코드 범위로, 코드가 없으면 계정명 낱말로 본다.
    except 낱말이 든 계정명은 낱말 판정에서 뺀다(「매출」 묶음에서 외상매출금 · 매출원가를 뺀다). 다만 unless 낱말이 들면 except 를 넘어 넣는다
    (손익 묶음의 「대손충당금환입」 · 「충당부채전입액」).
    any: true 인 묶음은 코드가 있어도 계정명 낱말로도 찾는다(더존 코드 체계가 아닌 회사)."""
    name = common.reader._norm(x.name or "")
    by_name = any(k in name for k in group.get("names", [])) and (
        not any(e in name for e in group.get("except", [])) or any(u in name for u in group.get("unless", [])))
    if x.code is not None:
        return common.in_ranges(x.code, group.get("ranges", [])) or (bool(group.get("any")) and by_name)
    return by_name


def _grp(v: common.Voucher, side: str, group: dict) -> list:
    return [x for x in v.lines if (x.dr if side == "dr" else x.cr) and _in(x, group)]


def _keys(v: common.Voucher, side: str) -> list[str]:
    """한쪽(차변 · 대변) 계정 목록. 코드가 없는 분개장은 계정명으로 센다(2026-10-21, 코드 없는 분개장에서 드문 조합이 늘 0 이던 것)."""
    return sorted({x.code or common.reader._norm(x.name) for x in v.lines if (x.dr if side == "dr" else x.cr) and (x.code or x.name)})


def _is_pl(x: common.Line, acc: dict, pl_names: dict | None = None) -> bool:
    """줄이 손익계정인지. 코드가 있으면 코드 범위, 없으면 시산표의 같은 이름 계정(코드가 있는 행)의 손익 구분, 그것도 없으면 계정명 낱말."""
    if x.code is None and pl_names:
        n = common.reader._norm(x.name or "")
        if n in pl_names:
            return pl_names[n]
    return _in(x, acc["pnl"])


def _pnl(v: common.Voucher, acc: dict, pl_names: dict | None = None) -> float:
    """전표의 손익 효과. 수익 · 비용 계정의 대변 − 차변이라 + 면 이익이 늘었다."""
    return sum(x.cr - x.dr for x in v.lines if _is_pl(x, acc, pl_names))


def _net(v: common.Voucher) -> dict:
    """(계정, 거래처)별 차변 − 대변. 코드가 없는 분개장은 계정명으로 묶는다(Voucher.net 은 코드로만 묶어 코드 없는 분개장에서 늘 비었다)."""
    out: dict[tuple, float] = {}
    for x in v.lines:
        k = (x.code or common.reader._norm(x.name or ""), x.party)
        out[k] = out.get(k, 0.0) + x.dr - x.cr
    return {k: val for k, val in out.items() if abs(val) > 0.5}


def _debit_not_others(v: common.Voucher, acc: dict, groups: list) -> list:
    """차변 줄 가운데 groups 어느 묶음에도 들지 않는 줄. 줄마다 묶음 판정을 한 번만 한다(2026-11-09: 차변 줄마다 전표 전체를
    다시 걸러 `in` 으로 찾아 전표 줄 수의 제곱으로 늘던 것. 37만 줄 분개장에서 실행 시간의 97%)."""
    return [x for x in v.lines if x.dr and not any(_in(x, acc[g]) for g in groups)]


def _any(v: common.Voucher, group: dict) -> bool:
    return bool(_grp(v, "dr", group) or _grp(v, "cr", group))


JOURNAL_CHART = "분개장 계정과목 칸"


def tb_codes_from_journal(tb: list[dict], lines: list) -> tuple[list[dict], dict]:
    """코드 없는 더존 합계잔액시산표에 계정과목표가 없으면 엔진은 계정 사전 · 재무제표 위치로 코드를 붙인다(reader.assign_codes).
    분개장 계정과목 칸에 '[41501]국내매출' 처럼 회사 코드가 있으면 그 짝으로 다시 붙인다. 안 그러면 손익계정 대사가 계정마다
    「시산표에 없음」 으로 갈라진다(2026-10-21 실제 회사 분개장: 순합은 0 인데 손익계정 대부분이 어긋났다).
    같은 이름이 여럿이면 assign_codes 처럼 지금 코드의 재무제표 묶음 범위 안에서 고른다. 분개장에 같은 이름이 없는 계정(더존 상위 계정
    「제예금」 등)은 그대로 둔다. 반환: (시산표 행, {"journal": 바꾼 계정 수, "guessed": 그대로 둔 추정 코드 계정 수})."""
    guess = lambda r: bool(r.get("code_basis")) and not str(r["code_basis"]).startswith("계정과목표")  # noqa: E731
    stat = {"journal": 0, "guessed": sum(1 for r in tb if guess(r))}
    chart: dict[str, str] = {}
    for x in lines:
        if x.code is not None and x.name:
            chart.setdefault(str(x.code), x.name)
    if not stat["guessed"] or not chart:
        return tb, stat
    coa = {"rows": [{"code": c, "name": n, "group": "", "full": re.sub(r"\s+", "", n)} for c, n in chart.items()]}
    rows = []
    for r in tb:
        k = common.code3(r["code"]) if guess(r) else None
        grp = next((g for g, (lo, hi) in common.reader.FS_RANGES.items() if k is not None and lo <= k <= hi), None)
        rows.append({"code": None if guess(r) else r["code"], "name": r["name"], "raw_name": re.sub(r"\s+", "", r["name"]),
                     "fs_group": grp, "subgroup": r.get("subgroup")})
    common.reader.assign_codes(rows, coa)
    out = []
    for r, x in zip(tb, rows):
        if guess(r) and x.get("code_basis") == "계정과목표":
            c = str(x["code"])
            s = common.sign(c)
            r = {**r, "code": c, "code_basis": f"계정과목표 {JOURNAL_CHART}", "sign": s, "disp": s * r["amount"], "pl": common.is_pl(c)}
            stat["journal"] += 1
            stat["guessed"] -= 1
        out.append(r)
    return out, stat


WEEKDAYS = "월화수목금토일"


def _hit(x: common.Line, group: dict) -> bool:
    return _memo(_hit_raw, x, group)


def _hit_raw(x: common.Line, group: dict) -> bool:
    """줄 하나가 계정 묶음에 드는지: 코드 범위 · 이름 낱말 · 이름 전체 가운데 하나라도 맞으면 든다(R9 결산조정 유형)."""
    if x.code is not None and common.in_ranges(x.code, group.get("ranges", [])):
        return True
    name = common.reader._norm(x.name or "")
    if any(k in name for k in group.get("names", [])):
        return True
    return name in set(group.get("exact", []))


def closing_types(cur: list, spec: dict, end: date) -> dict:
    """당기 전표를 결산조정 유형으로 나눈다(R9 B3). {"types": [{id, title, count, amount, ye_count, ye_amount}], "rows": [(유형, 전표)]}.
    결산월은 결산일이 든 달이다. 분류표이지 시험(걸림)이 아니다."""
    acc = spec.get("closing_accounts") or {}
    types = spec.get("closing_types") or []
    rows = []
    for v in cur:
        for t in types:
            ok = False
            for a, b in t.get("pairs", []):
                dr = [x for x in v.lines if x.dr]
                cr = [x for x in v.lines if x.cr]
                fwd = any(_hit(x, acc[a]) for x in dr) and any(_hit(x, acc[b]) for x in cr)
                rev = t.get("either") and any(_hit(x, acc[b]) for x in dr) and any(_hit(x, acc[a]) for x in cr)
                if fwd or rev:
                    ok = True
                    break
            if not ok and t.get("lines"):
                ok = any(_hit(x, acc[g]) for g in t["lines"] for x in v.lines)
            if ok:
                rows.append((t, v))
                break
    out = []
    for t in types:
        vs = [v for tt, v in rows if tt is t]
        ye = [v for v in vs if (v.date.year, v.date.month) == (end.year, end.month)]
        out.append({"id": t["id"], "title": t["title"], "count": len(vs), "amount": sum(v.amount for v in vs),
                    "ye_count": len(ye), "ye_amount": sum(v.amount for v in ye)})
    return {"types": out, "rows": [(t["title"], v) for t, v in rows]}


def bs_completeness(d: Path, tb: list[dict], lines: list) -> dict:
    """재무상태표 계정: 기말(시산표) − 기초(전기 잔액 원천 1~3) = 차변 발생 − 대변 발생(당기 분개장)(R9 B3).
    전기 잔액은 감사받은 숫자 · 회사제시 전기 시산표(audit.prior 원천 1~3)만 쓴다. 장부 값(시산표 − 분개장)은 이 대사를
    늘 0 으로 만들므로 쓰지 않는다. 원천이 없는 계정은 기초를 비우고 까닭을 적는다."""
    from .. import prior
    from ..analysis import defs as adefs

    accs = prior.current_accounts(d)
    keys = {a["code"] for a in accs}
    ap = prior.account_prior(d, accs, book_values={})
    dr: dict[str, float] = {}
    cr: dict[str, float] = {}
    for x in lines:
        if x.code is None:
            continue
        k = adefs.align_code(adefs.code_key(x.code) or str(x.code), keys)
        dr[k] = dr.get(k, 0.0) + x.dr
        cr[k] = cr.get(k, 0.0) + x.cr
    rows = []
    for a in accs:
        if a["section"] not in prior.BS_SECTIONS:
            continue
        p = ap["accounts"].get(a["code"]) or {}
        rows.append({"code": a["code"], "name": a["name"], "open": p.get("prior"), "basis": p.get("basis"),
                     "dr": common.reader._int(dr.get(a["code"], 0.0)), "cr": common.reader._int(cr.get(a["code"], 0.0)), "close": a["cur"]})
    src = [s["basis"] for s in ap["sources"]]
    return {"rows": rows, "sources": src}


def voucher_sources(cur: list, extra_cols: list, spec: dict) -> dict | None:
    """전표 출처(입력구분 · 전표구분 열) 값마다 전표 수 · 금액과 수기 · 자동 구분(R9 B3). 열이 없으면 None."""
    cols = [c for c in spec.get("source_columns", []) if c in extra_cols]
    if not cols:
        return None
    manual = spec.get("manual_values", [])
    by: dict[str, dict] = {}
    for v in cur:
        val = next((str(x.extra.get(c)).strip() for x in v.lines for c in cols if x.extra.get(c) not in (None, "")), "(빈 칸)")
        e = by.setdefault(val, {"value": val, "count": 0, "amount": 0.0, "kind": "수기" if any(w in val for w in manual) else "자동"})
        e["count"] += 1
        e["amount"] += v.amount
    return {"columns": cols, "rows": sorted(by.values(), key=lambda e: -e["count"])}


# ---------------------------------------------------------------- 2026-10-21 추가 시험의 도구
_NUM = re.compile(r"^(.*?)(\d+)$")


def _lnds(dates: list[int]) -> set[int]:
    """날짜(서수) 목록에서 줄지 않는 가장 긴 부분열에 드는 자리. 그 밖의 자리가 번호 순서와 일자 순서가 어긋난 전표다.
    끼워 넣은 전표 하나는 그 전표만 빠지고, 날짜를 잘못 친 전표 하나도 그 전표만 빠진다(바로 뒤 전표들이 덩달아 걸리지 않는다)."""
    tails: list[int] = []          # 길이 k+1 인 부분열의 마지막 날짜
    tail_at: list[int] = []        # 그 자리
    parent = [-1] * len(dates)
    for i, x in enumerate(dates):
        k = bisect_right(tails, x)
        if k == len(tails):
            tails.append(x)
            tail_at.append(i)
        else:
            tails[k] = x
            tail_at[k] = i
        parent[i] = tail_at[k - 1] if k else -1
    keep, i = set(), tail_at[-1] if tail_at else -1
    while i >= 0:
        keep.add(i)
        i = parent[i]
    return keep


# 번호를 새로 붙이는 단위. 넓은 것부터 보고, 같은 번호가 다른 날짜에 나오는 전표 비중이 dup_ratio 이하인 첫 단위를 고른다.
# 일자 단위는 그 비중이 늘 0 이라 마지막에 반드시 고른다(2026-10-21 검토: 번호 개수가 아니라 전표 수로 세야 하루 전표가 많은 날에 끌려가지 않는다)
_UNITS = (("앞부분", lambda v: ""), ("달", lambda v: f"{v.date.year}-{v.date.month:02d}"), ("일자", lambda v: v.date.isoformat()))
_UNIT_TEXT = {"앞부분": "앞부분마다 이어 붙이는 번호", "달": "달마다 새로 붙이는 번호", "일자": "일자마다 새로 붙이는 번호"}


def _runs(ns: list[int], band_gap: int) -> list[list[int]]:
    """정렬한 번호를 band_gap 보다 크게 떨어진 곳에서 나눈다(일반전표 00001~ 와 매입매출전표 50001~ 처럼 번호대가 둘인 회사)."""
    out = [[ns[0]]]
    for a, b in zip(ns, ns[1:]):
        if b - a > band_gap:
            out.append([b])
        else:
            out[-1].append(b)
    return out


def _missing(run: list[int], lo: int, limit: int = 20) -> tuple[int, list[int]]:
    """lo ~ run[-1] 사이 빠진 번호 수와 앞 limit 개. 범위를 펼치지 않는다(번호가 10억 단위여도 메모리를 쓰지 않는다)."""
    count = (run[-1] - lo + 1) - len(run)
    sample, want, it = [], lo, iter(run)
    for n in it:
        while want < n and len(sample) < limit:
            sample.append(want)
            want += 1
        if len(sample) >= limit:
            break
        want = n + 1
    return count, sample


def voucher_seq(cur: list, t: dict) -> dict:
    """전표번호 연속성(2026-10-21). 번호 끝 숫자와 앞부분(예: 202512-)으로 나누고, 번호를 새로 붙이는 단위(앞부분 · 달 · 일자)를 고른다.
    고른 단위 안에서 같은 번호가 다른 날짜에 있으면 중복, 번호 순서와 일자 순서가 어긋나면 순서 역전, 번호 사이 빈 곳은 빠진 번호.
    {"scheme", "rows": [{key, first, last, count, missing, sample}], "hits": [(전표, 까닭)], "note", "gaps"}"""
    real = [v for v in cur if v.no != v.date.isoformat()]
    if not real:
        return {"scheme": None, "rows": [], "hits": [], "gaps": 0, "note": "분개장에 전표번호 열이 없어 시험하지 못했습니다"}
    parsed, odd = [], 0
    for v in real:
        m = _NUM.match(str(v.no).strip())
        if m:
            parsed.append((m.group(1), int(m.group(2)), v))
        else:
            odd += 1
    if not parsed:
        return {"scheme": None, "rows": [], "hits": [], "gaps": 0, "note": "전표번호가 숫자로 끝나지 않아 연속성을 보지 못했습니다"}
    for unit, keyf in _UNITS:
        dates_of: dict[tuple, set] = defaultdict(set)
        for p, n, v in parsed:
            dates_of[(keyf(v), p, n)].add(v.date)
        share = sum(1 for p, n, v in parsed if len(dates_of[(keyf(v), p, n)]) > 1) / len(parsed)
        if share <= t.get("dup_ratio", 0.05):
            break
    groups: dict[tuple, list] = defaultdict(list)
    for p, n, v in parsed:
        groups[(keyf(v), p)].append((n, v))
    band = t.get("band_gap", 1000)
    rows, hits, gaps = [], [], 0
    for key in sorted(groups):
        g = groups[key]
        ns = sorted({n for n, _ in g})
        runs = _runs(ns, band)
        missing, sample = 0, []
        for i, run in enumerate(runs):
            lo = 1 if (i == 0 and unit != "앞부분" and run[0] <= band) else run[0]
            c, s = _missing(run, lo, 20 - len(sample))
            missing += c
            sample += s
        gaps += missing
        if unit != "일자" or missing:
            label = " ".join(x for x in key if x) or "(앞부분 없음)"
            rows.append({"key": label, "first": ns[0], "last": ns[-1], "count": len(g), "missing": missing, "sample": sample,
                         "runs": len(runs)})
    widespread = lambda k: k > max(t.get("widespread_min", 5), t.get("widespread", 0.05) * len(cur))  # noqa: E731
    notes = [f"번호 단위: {_UNIT_TEXT[unit]}", f"빠진 번호 {gaps:,}개(전표번호 연속성 시트)"]
    dup = [(v, f"같은 전표번호가 {len(dates_of[(keyf(v), p, n)])}개 날짜(" +
            ", ".join(sorted(x.isoformat() for x in dates_of[(keyf(v), p, n)])[:3]) + ")에 있음")
           for p, n, v in parsed if len(dates_of[(keyf(v), p, n)]) > 1]
    if dup:
        notes.append(f"중복 번호 {len(dup)}건")
        hits += dup
    if unit != "일자":
        out_of_order = []
        min_days = t.get("min_days", 7)
        for g in groups.values():
            g = sorted(g, key=lambda e: (e[0], e[1].date))
            keep = sorted(_lnds([v.date.toordinal() for _, v in g]))
            kept = set(keep)
            for i, (n, v) in enumerate(g):
                if i in kept:
                    continue
                j = bisect_right(keep, i)
                prev = g[keep[j - 1]][1] if j > 0 else None
                nxt = g[keep[j]][1] if j < len(keep) else None
                if prev is not None and v.date < prev.date:
                    gap, ref, word = (prev.date - v.date).days, prev, "앞 번호"
                elif nxt is not None and v.date > nxt.date:
                    gap, ref, word = (v.date - nxt.date).days, nxt, "뒤 번호"
                else:
                    continue
                if gap >= min_days:
                    out_of_order.append((v, f"{word} {ref.no}({ref.date.isoformat()})보다 일자가 {gap}일 " + ("앞섬" if word == "앞 번호" else "늦음")))
        if widespread(len(out_of_order)):
            notes.append(f"순서 역전 {len(out_of_order)}건은 당기 전표의 {t.get('widespread', 0.05):.0%} 를 넘어 번호를 입력 순서로 붙이는 회사로 보고 "
                         "목록에 올리지 않았습니다. 회사 전산의 번호 체계를 확인해 주십시오")
        else:
            hits += out_of_order
            notes.append(f"순서 역전 {len(out_of_order)}건")
    if odd:
        notes.append(f"숫자로 끝나지 않는 번호 {odd}건은 연속성에서 뺐습니다")
    merged: dict[int, list] = {}
    for v, why in hits:
        merged.setdefault(id(v), [v, []])[1].append(why)
    hits = sorted(((v, " · ".join(ws)) for v, ws in merged.values()), key=lambda e: (e[0].date, e[0].no))
    return {"scheme": _UNIT_TEXT[unit], "rows": rows, "hits": hits, "note": " · ".join(notes), "gaps": gaps}


def entry_cols(extra_cols: list, spec: dict) -> dict:
    """작성자 · 승인자 · 입력일시 열 이름. 분개장에 없으면 None."""
    return {k: next((c for c in names if c in extra_cols), None) for k, names in (spec.get("entry_columns") or {}).items()}


_DATE_TIME = re.compile(r"(\d{4})\s*[-./년]\s*(\d{1,2})\s*[-./월]\s*(\d{1,2})\s*일?"
                        r"(?:[ T]+(오전|오후|AM|PM|am|pm)?\s*(\d{1,2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?\s*(AM|PM|am|pm)?)?")
_COMPACT = re.compile(r"(\d{4})(\d{2})(\d{2})(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2}))?)?")
_TIME = re.compile(r"(오전|오후|AM|PM|am|pm)?\s*(\d{1,2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?\s*(AM|PM|am|pm)?")


def _hm(h: int, mi: int, sec: int = 0, ampm: str | None = None) -> tuple[int | None, int | None]:
    """시 · 분. 오후 · PM 이면 12 를 더한다. 0시 0분 0초는 날짜만 적은 칸으로 보고 시각 없음(None)으로 둔다(모든 꼴에 같게)."""
    a = (ampm or "").upper()
    if a in ("오후", "PM") and h < 12:
        h += 12
    elif a in ("오전", "AM") and h == 12:
        h = 0
    return (None, None) if (h, mi, sec) == (0, 0, 0) else (h, mi)


def _when(v) -> tuple[date | None, int | None, int | None]:
    """입력일시 칸 → (입력일, 시, 분). 시각만 적은 칸은 (None, 시, 분). 시각이 없거나 0시 0분 0초면 시 · 분은 None.
    읽는 꼴: datetime · date · time · 엑셀 일련번호(소수는 시각) · 「2026-01-20 23:10」 · 「2026-01-20T23:10:05.123Z」 ·
    「2026-01-20 오후 11:10:05」 · 「2026년 1월 20일 23:10」 · 「20260120 2310」 · 「20260120231000」 · 「23:10」 · 「오후 11:10」."""
    if v in (None, ""):
        return None, None, None
    if isinstance(v, datetime):
        return (v.date(), *_hm(v.hour, v.minute, v.second))
    if isinstance(v, date):
        return v, None, None
    if isinstance(v, dtime):
        return (None, *_hm(v.hour, v.minute, v.second))
    if isinstance(v, (int, float)) and not isinstance(v, bool):
        whole, frac = int(v), float(v) - int(v)
        mins = round(frac * 24 * 60)
        if 20000 <= v <= 80000:
            d = date(1899, 12, 30) + timedelta(days=whole + mins // 1440)
            return (d, *_hm((mins % 1440) // 60, mins % 60))
        if 0 <= v < 1:                                # 시각만 적은 일련번호
            return (None, *_hm((mins % 1440) // 60, mins % 60))
    s = re.sub(r"(Z|[+-]\d{2}:?\d{2})$", "", str(v).strip())
    try:
        if m := _DATE_TIME.fullmatch(s):
            d = date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
            if m.group(5) is None:
                return d, None, None
            return (d, *_hm(int(m.group(5)), int(m.group(6)), int(m.group(7) or 0), m.group(4) or m.group(8)))
        if m := _COMPACT.fullmatch(s):
            d = date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
            if m.group(4) is None:
                return d, None, None
            return (d, *_hm(int(m.group(4)), int(m.group(5)), int(m.group(6) or 0)))
        if m := _TIME.fullmatch(s):
            return (None, *_hm(int(m.group(2)), int(m.group(3)), int(m.group(4) or 0), m.group(1) or m.group(5)))
    except ValueError:
        return None, None, None
    return common.reader._date(s), None, None


def entry_of(v: common.Voucher, cols: dict) -> dict:
    """전표의 작성자 · 승인자 · 입력일시(첫 줄부터 처음 값이 있는 줄). 입력일자와 입력시각이 다른 열이면 합친다."""
    def first(c):
        if not c:
            return None
        return next((x.extra.get(c) for x in v.lines if x.extra.get(c) not in (None, "")), None)

    u, a = first(cols.get("user")), first(cols.get("approver"))
    d, h, mi = _when(first(cols.get("entered")))
    if h is None and cols.get("entered_time"):
        d2, h, mi = _when(first(cols["entered_time"]))
        d = d or d2
    return {"user": None if u is None else str(u).strip(), "approver": None if a is None else str(a).strip(),
            "entered": d, "hour": h, "minute": mi}


def _entry_text(e: dict) -> str:
    parts = []
    if e.get("user"):
        parts.append(f"작성 {e['user']}")
    if e.get("approver"):
        parts.append(f"승인 {e['approver']}")
    if e.get("entered"):
        parts.append("입력 " + e["entered"].isoformat() + (f" {e['hour']:02d}:{e['minute']:02d}" if e.get("hour") is not None else ""))
    return " · ".join(parts)


def benford(lines: list, spec: dict) -> dict:
    """줄 금액 첫 자리 분포(2026-10-21). {"counts": {1..9: n}, "n", "mad", "verdict"}. MAD 는 실제 비율과 기대 비율 차이 절대값의 평균이다."""
    low = max(spec.get("min_amount", 10), 1)          # 1 미만은 첫 자리를 정수로 읽지 못한다
    counts = {d: 0 for d in range(1, 10)}
    for x in lines:
        a = abs(x.dr) if x.dr else abs(x.cr)
        if a >= low:
            counts[int(str(int(a))[0])] += 1
    n = sum(counts.values())
    mad = sum(abs(counts[d] / n - math.log10(1 + 1 / d)) for d in counts) / 9 if n else None
    if not n or n < spec.get("min_lines", 300):
        verdict = f"줄이 {n:,}개라 판정하지 않음(기준 {spec.get('min_lines', 300):,}개)"
    else:
        verdict = next((w for lim, w in spec.get("mad", []) if mad <= lim), spec.get("over", "부적합"))
    return {"counts": counts, "n": n, "mad": mad, "verdict": verdict}


def monthly(cur: list, start: date, end: date, acc: dict, spec: dict) -> dict:
    """사업연도 달마다 전표 수 · 금액 · 매출 순액(매출 계정 대변 − 차변). 결산월 매출이 사업연도 월평균의 ratio 배 이상이면 표시."""
    months, y, m = [], start.year, start.month
    while (y, m) <= (end.year, end.month):
        months.append((y, m))
        y, m = (y + 1, 1) if m == 12 else (y, m + 1)
    rows = {k: {"ym": f"{k[0]}-{k[1]:02d}", "count": 0, "amount": 0.0, "revenue": 0.0} for k in months}
    for v in cur:
        r = rows.get((v.date.year, v.date.month))
        if r is None:
            continue
        r["count"] += 1
        r["amount"] += v.amount
        r["revenue"] += sum(x.cr - x.dr for x in v.lines if _in(x, acc["revenue"]))
    out = list(rows.values())
    ye = rows.get((end.year, end.month))
    avg = sum(r["revenue"] for r in out) / len(out) if out else 0.0
    ratio = (ye["revenue"] / avg) if ye and avg else None
    flag = ratio is not None and ratio >= spec.get("ratio", 1.5)
    return {"rows": out, "ye_ratio": ratio, "flag": flag}


def _pkey(name: str | None) -> str:
    from ..analysis.balances import party_name
    return party_name(name or "") or common.reader._norm(name or "")


def recurring(cur: list, spec: dict) -> dict:
    """반복 전표 묶기(2026-11-09 3단계, 검토 문서 4.2). 차변 계정 · 대변 계정 · 거래처 · 금액 크기대가 같은 전표가 min_months 개 달 이상,
    min_count 건 이상 나오면 한 묶음이다(카드 대금 · 급여 · 감가상각). {"of": {id(전표): 묶음번호}, "groups": [..], "vouchers"}.
    묶음 번호는 전표가 많은 순으로 R1, R2, …"""
    cfg = spec.get("recurring") or {}
    mm, mc = cfg.get("min_months", 3), cfg.get("min_count", 3)
    steps = cfg.get("amount_steps", 4)     # 금액 크기대: 10배를 이만큼으로 나눈 구간(4 면 약 1.8배 폭). 0 이면 금액을 보지 않는다
    by: dict[tuple, dict] = {}
    for v in cur:
        band = int(math.log10(max(abs(v.amount), 1.0)) * steps) if steps else 0
        k = ("+".join(_keys(v, "dr")), "+".join(_keys(v, "cr")), "+".join(v.parties), band)
        e = by.setdefault(k, {"vs": [], "months": set()})
        e["vs"].append(v)
        e["months"].add((v.date.year, v.date.month))
    groups, of = [], {}
    for e in sorted(by.values(), key=lambda e: (-len(e["vs"]), e["vs"][0].date)):
        if len(e["months"]) < mm or len(e["vs"]) < mc:
            continue
        gid = f"R{len(groups) + 1}"
        v0 = e["vs"][0]
        groups.append({"id": gid, "dr": v0.label("dr"), "cr": v0.label("cr"), "parties": ", ".join(v0.parties),
                       "months": len(e["months"]), "count": len(e["vs"]), "amount": sum(v.amount for v in e["vs"])})
        for v in e["vs"]:
            of[id(v)] = gid
    return {"of": of, "groups": groups, "vouchers": len(cur), "min_months": mm, "min_count": mc}


SIZE_BANDS = ((1, 2), (3, 5), (6, 10), (11, 50), (51, None))


def overview(cur: list, meta: dict, cols: dict, hol: set, rec: dict) -> dict:
    """모집단 개요(2026-11-09 3단계, 검토 문서 4.2). 시험 전에 분개장 모양을 본다: 월별 전표 · 줄 · 금액 · 주말 전표,
    전표 크기(줄 수) 분포, 작성자별(열이 있을 때), 계정별 상위, 반복 전표 비율."""
    months: dict[str, dict] = {}
    sizes = {b: 0 for b in SIZE_BANDS}
    users: dict[str, dict] = {}
    accts: dict[str, dict] = {}
    for v in cur:
        k = f"{v.date.year:04d}-{v.date.month:02d}"
        m = months.setdefault(k, {"vouchers": 0, "lines": 0, "amount": 0.0, "weekend": 0})
        m["vouchers"] += 1
        m["lines"] += len(v.lines)
        m["amount"] += v.amount
        m["weekend"] += v.date.weekday() >= 5 or v.date in hol
        n = len(v.lines)
        sizes[next(b for b in SIZE_BANDS if b[1] is None or n <= b[1])] += 1
        if cols.get("user"):
            u = (meta.get(id(v)) or {}).get("user") or "(빈 칸)"
            e = users.setdefault(u, {"vouchers": 0, "amount": 0.0})
            e["vouchers"] += 1
            e["amount"] += v.amount
        for x in v.lines:
            a = x.code or common.reader._norm(x.name or "") or "(계정 없음)"
            e = accts.setdefault(a, {"name": x.name or "", "lines": 0, "dr": 0.0, "cr": 0.0, "months": set()})
            e["lines"] += 1
            e["dr"] += x.dr
            e["cr"] += x.cr
            e["months"].add(k)
    top = sorted(accts.items(), key=lambda kv: (-kv[1]["lines"], kv[0]))[:20]
    in_rec = sum(1 for v in cur if id(v) in rec["of"])
    return {"months": [{"month": k, **months[k]} for k in sorted(months)],
            "sizes": [{"band": b, "vouchers": sizes[b]} for b in SIZE_BANDS],
            "users": sorted(({"user": u, **e} for u, e in users.items()), key=lambda e: -e["vouchers"]),
            "accounts": [{"code": a, "name": e["name"], "lines": e["lines"], "dr": e["dr"], "cr": e["cr"], "months": len(e["months"])}
                         for a, e in top],
            "accounts_n": len(accts), "vouchers": len(cur), "lines": sum(len(v.lines) for v in cur),
            "recurring_vouchers": in_rec}


def opposite_cause(d: Path, cur: list, t: dict, hit) -> None:
    """분석의 거래처별 기말 반대 잔액마다 그 잔액을 반대쪽으로 민 전표(2026-10-24).

    기말 잔액(정상 쪽 부호, 반대면 음수)에서 전표를 늦은 것부터 거꾸로 빼 가며, 잔액이 정상 쪽(0 이상)이던 때 뒤에
    잔액을 반대쪽으로 민 전표를 적는다. 거래처 기초 잔액이 없어도 기말 잔액과 분개장만으로 된다.
    분석(_색인/분석.json party_balances.opposite)이 없으면 돌지 않고 까닭을 적는다."""
    from .. import folder as _folder
    a = _folder._read(Path(d) / "_색인" / "분석.json", None)
    rows =[(o["sheet"], o["side"], p) for o in ((a or {}).get("party_balances") or {}).get("opposite", []) for p in o.get("top", [])]
    if a is None:
        t["note"] = "분석(analyze) 전이라 돌지 않았습니다"
        return
    if not rows:
        t["note"] = "분석이 찾은 기말 반대 잔액이 없습니다"
        return
    cap = int(t.get("max_vouchers", 12))
    notes = []
    for sheet, side, p in rows:
        acct, bal = common.reader._norm(sheet), float(p["bal"])
        asset = side == "대변"            # 자산 계정의 대변 잔액이 반대다

        def collect(key, same):
            out = []
            for v in cur:
                m = sum((x.dr - x.cr) if asset else (x.cr - x.dr) for x in v.lines
                        if common.reader._norm(x.name) == acct and same(x.party, key))
                if m:
                    out.append((v, m))
            return out
        # 이름이 정확히 같은 거래처를 먼저 본다. 「울림홀딩스」 와 「울림홀딩스(본점)」 은 명세서에서 다른 거래처다
        moves = collect(common.reader._norm(p["party"]), lambda a, k: common.reader._norm(a or "") == k)
        if not moves:
            moves = collect(_pkey(p["party"]), lambda a, k: _pkey(a) == k)
        moves.sort(key=lambda e: (e[0].date, e[0].no), reverse=True)
        after, found = bal, []
        for v, m in moves:
            before = after - m
            if m < 0 and after < 0:
                found.append((v, before, after))
            after = before
            if after >= 0:
                break
        found.sort(key=lambda e: -abs(e[2] - e[1]))
        for v, before, after_v in found[:cap]:
            hit("opposite_cause", v, f"{sheet} {p['party']} 기말 {won(bal)}(반대쪽). 이 전표로 {won(before)} → {won(after_v)}")
        if len(found) > cap:
            notes.append(f"{sheet} {p['party']} {len(found) - cap}건 더")
        if not found:
            notes.append(f"{sheet} {p['party']}: 분개장에서 원인 전표를 찾지 못함(거래처 이름이 다를 수 있음)")
    t["note"] = f"반대 잔액 거래처 {len(rows)}곳" + (". " + " · ".join(notes) if notes else "")


def run(d: Path, mat: dict | None = None) -> dict:
    d = Path(d)
    spec = common.load_def("jet.yaml")
    acc = spec["accounts"]
    mat = mat or common.materiality(d)
    pm = mat["performance"]
    end = common.fy_end(d)
    j = common.journals(d)
    cur = common.vouchers(j["cur"])
    post = common.vouchers(j["post"])
    hol = {date.fromisoformat(str(x)) for x in spec.get("holidays", [])}
    tests = {t["id"]: {**t, "hits": [], "note": ""} for t in spec["tests"]}
    tb, tb_coded = tb_codes_from_journal(common.tb_rows(d), j["cur"] + j["post"])
    # 코드 없는 분개장의 손익 판정에 쓴다: 시산표에서 코드가 있는 행의 계정명 → 손익 여부
    pl_names = {common.reader._norm(r["name"]): bool(r["pl"]) for r in tb if r.get("code") is not None and r.get("name")}

    def hit(tid: str, v: common.Voucher, why: str):
        tests[tid]["hits"].append({"voucher": v, "why": why})

    # 주말 · 공휴일. 공휴일 표에 없는 해의 전표는 주말만 본 것이라 시험 메모에 적는다(2026-11-02 스킬 리뷰)
    no_hol = sorted({v.date.year for v in cur + post} - {x.year for x in hol})
    if no_hol:
        tests["weekend"]["note"] = "; ".join(x for x in [tests["weekend"].get("note"), f"{' · '.join(map(str, no_hol))}년은 jet.yaml 공휴일 표에 없어 주말만 봄"] if x)
    for v in cur + post:
        # 월말 일자 결산 전표(감가상각 · 원가 대체 · 이자 계상)는 날짜를 월말로 다는 것이 정상이라 주말이어도 보지 않는다
        if (v.date + timedelta(days=1)).month != v.date.month:
            continue
        if v.date.weekday() >= 5:
            hit("weekend", v, "토요일" if v.date.weekday() == 5 else "일요일")
        elif v.date in hol:
            hit("weekend", v, "공휴일")

    # 기말 후 취소 · 역분개
    t = tests["post_ye_reversal"]
    lo = end - timedelta(days=t.get("window_before", 45))
    hi = end + timedelta(days=t.get("window_after", 60))
    near = [v for v in cur if v.date >= lo]
    used: set[int] = set()
    for pv in [v for v in post if v.date <= hi]:
        net = _net(pv)
        if not net:
            continue
        rev = {k: -x for k, x in net.items()}
        match = next((ov for ov in near if id(ov) not in used and _net(ov) == rev), None)
        if match is not None:
            used.add(id(match))
            hit("post_ye_reversal", match, f"기말 후 {pv.date.isoformat()} {pv.no} 로 반대 분개됨")
            hit("post_ye_reversal", pv, f"결산일 전 {match.date.isoformat()} {match.no} 의 반대 분개")
        elif _grp(pv, "dr", acc["revenue"]):
            hit("post_ye_reversal", pv, "기말 후 매출 차변(짝인 결산일 전 전표를 찾지 못함)")
    if not post:
        t["note"] = "결산일 후 분개장이 없어 시험하지 못했습니다. 기말 후 2개월 분개장을 받아 주십시오"

    # 결산일 근처 큰 금액
    t = tests["near_ye_large"]
    if pm:
        cut = pm * t.get("ratio", 0.5)
        start = end - timedelta(days=t.get("days", 15))
        for v in cur:
            if v.date > start and v.amount >= cut:
                hit("near_ye_large", v, f"결산일 전 {(end - v.date).days}일, 금액 {won(v.amount)} ≥ 수행중요성 × {t.get('ratio', 0.5)}")
        t["note"] = f"기준 {won(cut)} ({mat['basis']})"
    else:
        t["note"] = "수행중요성이 없어 시험하지 못했습니다"

    # 드문 계정 조합
    t = tests["rare_pair"]
    sig = {}
    for v in cur:
        k = ("+".join(_keys(v, "dr")), "+".join(_keys(v, "cr")))
        sig[k] = sig.get(k, 0) + 1
    found = []
    by_rule: dict[str, list] = defaultdict(list)
    for v in cur:
        why = []
        k = ("+".join(_keys(v, "dr")), "+".join(_keys(v, "cr")))
        if sig[k] <= t.get("max_count", 1):
            why.append(f"차변 {v.label('dr')} / 대변 {v.label('cr')} 조합이 당기 {sig[k]}번")
        rules = []
        for rule in t.get("rules", []):
            ok = True
            if "credit" in rule and not _grp(v, "cr", acc[rule["credit"]]):
                ok = False
            if ok and "debit" in rule and not _grp(v, "dr", acc[rule["debit"]]):
                ok = False
            if ok and "debit_not" in rule:
                ok = bool(_debit_not_others(v, acc, rule["debit_not"]))
            if ok and "without" in rule and _any(v, acc[rule["without"]]):
                ok = False
            if ok and "credit_except" in rule:
                # 대변 계정이 모두 이 낱말이 든 계정이면 뺀다(해외 · 수출 매출은 영세율이라 부가세예수금이 없는 것이 정상, 2026-10-21)
                ok = any(not any(w in common.reader._norm(x.name or "") for w in rule["credit_except"])
                         for x in _grp(v, "cr", acc[rule["credit"]]))
            if ok and "any_of" in rule:
                ok = any(_any(v, acc[g]) for g in rule["any_of"]) and any(_any(v, acc[g]) for g in rule.get("with", []))
            if ok and ("credit" in rule or "debit" in rule or "any_of" in rule):
                rules.append(rule)
                by_rule[rule["title"]].append(v)
        found.append((v, why, rules))
    # 규칙 하나에 당기 전표의 widespread 비율과 widespread_min 건 가운데 큰 쪽보다 많이 걸리면 회사가 늘 그렇게 분개하는 것으로 보고
    # 목록 대신 메모로 남긴다(2026-10-21 실제 회사 분개장: 자동 매출 전표가 부가세예수금 없는 외상 매출에 모두 걸려 결과 목록이 매출 전표 전부가 됐다)
    lim = max(t.get("widespread_min", 5), t.get("widespread", 1.0) * max(len(cur), 1))
    wide = {title for title, vs in by_rule.items() if len(vs) > lim}
    notes = []
    for rule in t.get("rules", []):
        if rule["title"] not in wide:
            continue
        vs = by_rule[rule["title"]]
        side, g = ("cr", rule["credit"]) if "credit" in rule else ("dr", rule["debit"]) if "debit" in rule else (None, None)
        top = Counter(", ".join(sorted({x.name for x in _grp(v, side, acc[g])})) for v in vs).most_common(4) if side else []
        msg = (f"{rule['title']} {len(vs):,}건(당기 전표의 {len(vs) / max(len(cur), 1):.0%}" + "".join(f" · {n} {c:,}" for n, c in top)
               + f")은 {t.get('widespread', 1.0):.0%} 를 넘어 회사가 늘 그렇게 분개하는 것으로 보고 목록에 올리지 않았습니다")
        notes.append(msg + (f". {rule['widespread_note']}" if rule.get("widespread_note") else ""))
    for v, why, rules in found:
        why = why + [r["title"] for r in rules if r["title"] not in wide]
        if why:
            hit("rare_pair", v, " · ".join(why))
    if notes:
        t["note"] = ". ".join(notes)

    # 끝자리 0 반복
    t = tests["round"]
    unit, low = t.get("unit", 10_000_000), t.get("min_amount", 100_000_000)
    for v in cur:
        a = v.amount
        if a >= low and abs(a - round(a)) < 1e-6 and int(round(a)) % unit == 0:
            hit("round", v, f"{won(unit)} 원 단위로 떨어지는 {won(a)}")

    # 적요 없음. 적요 열이 없거나 모두 비면 전표 전부가 걸리므로 시험하지 않는다(2026-11-09)
    if any(x.memo for v in cur + post for x in v.lines):
        for v in cur + post:
            n = sum(1 for x in v.lines if not x.memo)
            if n:
                hit("no_memo", v, f"적요 빈 행 {n}개")
    elif cur or post:
        tests["no_memo"]["note"] = "분개장에 적요 열이 없거나 모두 비어 시험하지 못했습니다. 회사 전산에서 적요가 든 분개장을 받아 주십시오"

    # 수기 조정 전표
    t = tests["manual_adjust"]
    cols = [c for c in t.get("columns", []) if c in j["extra_cols"]]
    if cols:
        vals = t.get("values", [])
        for v in cur + post:
            for x in v.lines:
                tag = next((str(x.extra.get(c)) for c in cols if x.extra.get(c) and any(w in str(x.extra.get(c)) for w in vals)), None)
                if tag:
                    hit("manual_adjust", v, f"입력구분 '{tag}'")
                    break
        t["note"] = f"분개장 '{', '.join(cols)}' 열로 판정"
    else:
        start = end - timedelta(days=t.get("days", 15))
        keys = t.get("keywords", [])
        for v in cur:
            if v.date > start:
                k = next((w for w in keys if w in v.memo), None)
                if k:
                    hit("manual_adjust", v, f"적요 낱말 '{k}'")
        t["note"] = "분개장에 입력구분 열이 없어 결산일 근처 적요 낱말로 대신했습니다. 회사 전산에서 수기 전표 목록을 받아 대조해 주십시오"

    # ---- 2026-10-21 추가 시험
    # 많이 걸리면 목록 대신 메모로 남기는 기준(번호 순서 역전 · 음수 금액 · 중복 의심 · 승인 없음): 당기 전표의 widespread 비율과 widespread_min 건 가운데 큰 쪽
    def widespread(t: dict, k: int) -> bool:
        return k > max(t.get("widespread_min", 5), t.get("widespread", 0.05) * max(len(cur), 1))

    # 전표 형식 이상: 전표별 차대 · 계정이 빈 줄 · 음수 금액
    t = tests["integrity"]
    neg = []
    for v in cur + post:
        why = []
        dr, cr = sum(x.dr for x in v.lines), sum(x.cr for x in v.lines)
        if abs(dr - cr) > 0.5:
            why.append(f"차변 {won(dr)} · 대변 {won(cr)} · 차이 {won(dr - cr)}")
        n = sum(1 for x in v.lines if x.code is None and not (x.name or "").strip())
        if n:
            why.append(f"계정이 빈 줄 {n}개")
        if why:
            hit("integrity", v, " · ".join(why))
        n = sum(1 for x in v.lines if x.dr < 0 or x.cr < 0)
        if n:
            neg.append((v, f"음수 금액 줄 {n}개"))
    if widespread(t, len(neg)):
        # 수정세금계산서처럼 마이너스 전표를 늘 쓰는 회사(2026-10-21 검토)
        t["note"] = f"음수 금액 줄이 있는 전표 {len(neg)}건은 마이너스 전표를 늘 쓰는 회사로 보고 목록에 올리지 않았습니다"
    else:
        done = {id(h["voucher"]): h for h in t["hits"]}
        for v, why in neg:
            if id(v) in done:
                done[id(v)]["why"] += f" · {why}"
            else:
                hit("integrity", v, why)
                # 음수 금액 줄만 있는 전표는 차대 불일치 · 계정 빈 줄과 달리 참고로 본다(2026-11-09, 먼저 볼 전표 점수)
                t["hits"][-1].update(review="optional", weight=1)

    # 전표번호 중복 · 순서 역전 · 빠진 번호
    t = tests["voucher_seq"]
    seq = voucher_seq(cur, t)
    for v, why in seq["hits"]:
        hit("voucher_seq", v, why)
    t["note"] = seq["note"]

    # 한 번만 나온 거래처의 큰 금액
    t = tests["one_time_party"]
    if pm:
        cut = pm * t.get("ratio", 0.5)
        seen = common.prior_parties(j)
        cnt = Counter(p for v in cur for p in v.parties)
        after = Counter(p for v in post for p in v.parties)
        for v in cur:
            ones = [p for p in v.parties if cnt[p] == 1 and (seen is None or p not in seen)]
            if ones and v.amount >= cut:
                extra = "".join(f" · 기말 후 분개장에도 {p} {after[p]}건" for p in ones if after[p])
                hit("one_time_party", v, f"당기 전표 1건뿐인 거래처: {', '.join(ones)}" + ("" if seen is None else " · 전기 분개장에도 없음") +
                    f", 금액 {won(v.amount)} ≥ 수행중요성 × {t.get('ratio', 0.5)}" + extra)
        t["note"] = f"기준 {won(cut)}" + (" · 전기 분개장이 없어 전기 거래 여부는 보지 않았습니다" if seen is None else "")
    else:
        t["note"] = "수행중요성이 없어 시험하지 못했습니다"

    # 결산일 근처 이익을 늘린 전표
    t = tests["profit_up"]
    if pm:
        cut = pm * t.get("ratio", 0.5)
        start = end - timedelta(days=t.get("days", 15))
        for v in cur:
            if v.date > start:
                e = _pnl(v, acc, pl_names)
                if e >= cut:
                    hit("profit_up", v, f"결산일 전 {(end - v.date).days}일, 이익 +{won(e)} ≥ 수행중요성 × {t.get('ratio', 0.5)}")
        t["note"] = f"기준 {won(cut)} · 손익계정은 매출 · 매출원가 · 판관비 · 영업외 · 법인세(제조원가 빼고)"
    else:
        t["note"] = "수행중요성이 없어 시험하지 못했습니다"

    # 중복 의심 전표
    t = tests["duplicate"]
    same: dict[tuple, list] = defaultdict(list)
    for v in cur:
        if v.amount > 0:
            same[(tuple(_keys(v, "dr")), tuple(_keys(v, "cr")), tuple(v.parties), round(v.amount, 2))].append(v)
    # 사슬로 잇지 않고 바로 이웃한 두 전표만 본다. 매주 같은 금액을 주는 거래가 한 해 내내 한 묶음이 되지 않게(2026-10-21 검토)
    pairs: dict[int, list] = {}
    for vs in same.values():
        vs.sort(key=lambda v: (v.date, v.no))
        for a, b in zip(vs, vs[1:]):
            if (b.date - a.date).days <= t.get("days", 3):
                pairs.setdefault(id(a), [a, []])[1].append(b)
                pairs.setdefault(id(b), [b, []])[1].append(a)
    if widespread(t, len(pairs)):
        t["note"] = f"중복 의심 {len(pairs)}건은 같은 금액 거래가 잦은 회사로 보고 목록에 올리지 않았습니다. 거래처별로 따로 보십시오"
    else:
        for v, others in sorted(pairs.values(), key=lambda e: (e[0].date, e[0].no)):
            hit("duplicate", v, "계정 · 거래처 · 금액이 같은 전표 " + ", ".join(f"{o.date.isoformat()} {o.no}" for o in others))

    # 기말 반대 잔액을 만든 전표(2026-10-24)
    if "opposite_cause" in tests:
        opposite_cause(d, cur, tests["opposite_cause"], hit)

    # 대표 · 주주 · 임원 관련 계정, 자본 계정
    words = spec.get("related_parties", [])
    for v in cur + post:
        accs = sorted({x.name or str(x.code) for x in v.lines if _in(x, acc["related"])})
        ps = [p for p in v.parties if any(w in p for w in words)]
        if accs or ps:
            hit("related_party", v, " · ".join(([f"계정 {', '.join(accs)}"] if accs else []) + ([f"거래처 {', '.join(ps)}"] if ps else [])))
        eq = sorted({x.name or str(x.code) for x in v.lines if _in(x, acc["equity"])})
        if eq:
            hit("equity", v, f"계정 {', '.join(eq)}")

    # 적요 주의 낱말
    t = tests["memo_keyword"]
    for v in cur + post:
        k = [w for w in t.get("keywords", []) if w in v.memo]
        if k:
            hit("memo_keyword", v, "적요 낱말 " + ", ".join(f"'{w}'" for w in k[:3]))

    # 계정 평소보다 큰 금액
    t = tests["outlier"]
    by: dict[tuple, list] = defaultdict(list)
    for v in cur:
        for x in v.lines:
            key = x.code or common.reader._norm(x.name)
            for side, amt in (("차변", x.dr), ("대변", x.cr)):
                if key and amt > 0:
                    by[(key, side)].append((amt, v, x))
    floor = pm * t.get("ratio", 0.5) if pm else t.get("min_amount", 10_000_000)
    found: dict[int, list] = {}
    for (key, side), xs in by.items():
        if len(xs) < max(t.get("min_lines", 12), 1):
            continue
        med = statistics.median(a for a, _, _ in xs)
        cut = max(med * t.get("multiple", 10), floor)
        for a, v, x in xs:
            if med > 0 and a >= cut:
                found.setdefault(id(v), [v]).append(f"{x.name or key} {side} {won(a)} = 중앙값 {won(med)} 의 {a / med:,.0f}배")
    for v, *why in sorted(found.values(), key=lambda e: (e[0].date, e[0].no)):
        hit("outlier", v, " · ".join(why))
    t["note"] = f"금액 하한 {won(floor)}" + (" (수행중요성 × " + str(t.get("ratio", 0.5)) + ")" if pm else " (수행중요성이 없어 min_amount)")

    # 작성자 · 승인자 · 입력일시 열이 있을 때만 도는 시험
    cols = entry_cols(j["extra_cols"], spec)
    meta = {id(v): entry_of(v, cols) for v in cur + post}
    t = tests["self_approval"]
    if cols.get("approver"):
        allv = cur + post
        filled = sum(1 for v in allv if meta[id(v)]["approver"])
        none_hits, same_hits = [], []
        for v in allv:
            e = meta[id(v)]
            if not e["approver"]:
                none_hits.append((v, f"승인자 없음(작성 {e['user'] or '빈 칸'})"))
            elif e["user"] and e["user"] == e["approver"]:
                same_hits.append((v, f"작성자와 승인자가 같음({e['user']})"))
        notes = [f"분개장 '{cols.get('user') or '작성자 열 없음'}' · '{cols['approver']}' 열로 판정"]
        if filled < t.get("min_filled", 0.5) * max(len(allv), 1):
            # 승인자 칸이 대부분 빈 회사(자동 전표에 승인자를 남기지 않는 전산). 승인 없음을 전표마다 올리면 목록이 분개장 전체가 된다(2026-10-21 검토)
            notes.append(f"승인자 칸이 채워진 전표가 {filled:,}건({filled / max(len(allv), 1):.0%})뿐이라 승인 없음 {len(none_hits):,}건은 목록에 올리지 않았습니다. "
                         "회사 전산의 승인 절차를 확인해 주십시오")
            none_hits = []
        for v, why in sorted(none_hits + same_hits, key=lambda e: (e[0].date, e[0].no)):
            hit("self_approval", v, why)
        t["note"] = ". ".join(notes)
    else:
        t["note"] = "분개장에 승인자 열이 없어 시험하지 못했습니다. 회사 전산에서 작성자 · 승인자가 든 분개장을 받아 주십시오"
    t = tests["rare_user"]
    if cols.get("user"):
        made = Counter(meta[id(v)]["user"] for v in cur + post if meta[id(v)]["user"])
        if len(made) >= 2:
            for v in cur + post:
                u = meta[id(v)]["user"]
                if u and made[u] <= t.get("max_count", 5):
                    hit("rare_user", v, f"작성자 {u}: 작성한 전표 {made[u]}건(작성자 {len(made)}명)")
            t["note"] = f"분개장 '{cols['user']}' 열로 판정"
        elif made:
            t["note"] = "작성자가 한 명뿐이라 시험하지 않았습니다"
        else:
            t["note"] = f"분개장 '{cols['user']}' 열이 모두 비어 시험하지 못했습니다"
    else:
        t["note"] = "분개장에 작성자 열이 없어 시험하지 못했습니다"
    if cols.get("entered") or cols.get("entered_time"):
        t, o = tests["late_entry"], tests["off_hours"]
        unread = 0
        for v in cur + post:
            e = meta[id(v)]
            ed = e["entered"]
            if ed is None:
                unread += 1
                continue
            why = []
            if v.date <= end < ed:
                why.append(f"결산일 후 {ed.isoformat()} 입력")
            if (ed - v.date).days >= t.get("days", 30):
                why.append(f"전표 일자보다 {(ed - v.date).days}일 늦게 입력")
            if why:
                hit("late_entry", v, " · ".join(why))
            why = []
            h = e["hour"]
            if h is None and ed == v.date:
                # 시각 없이 입력일만 있고 전표 일자와 같으면 주말 · 공휴일 시험과 같은 것을 본다. 두 번 세지 않는다(2026-11-09)
                continue
            if h is not None and (h >= o.get("night_from", 22) or h < o.get("night_to", 6)):
                why.append(f"입력 시각 {h:02d}:{e['minute']:02d}")
            if ed.weekday() >= 5:
                why.append("입력일 " + ("토요일" if ed.weekday() == 5 else "일요일"))
            elif ed in hol:
                why.append("입력일 공휴일")
            if why:
                hit("off_hours", v, " · ".join(why))
        used = " · ".join(f"'{c}'" for c in (cols.get("entered"), cols.get("entered_time")) if c)
        t["note"] = o["note"] = f"분개장 {used} 열로 판정"
        if unread:
            miss = f". 입력일을 읽지 못한 전표 {unread:,}건은 빠졌습니다"
            t["note"] += miss
            o["note"] += miss
        if not any(meta[id(v)]["hour"] is not None for v in cur + post):
            o["note"] += ". 입력일시에 시각이 없어 입력일의 요일 · 공휴일만 봤습니다(입력일이 전표 일자와 같으면 주말 · 공휴일 시험에 맡김)"
    else:
        for k in ("late_entry", "off_hours"):
            tests[k]["note"] = "분개장에 입력일시 열이 없어 시험하지 못했습니다. 회사 전산에서 입력일시가 든 분개장을 받아 주십시오"

    # ---- 2026-11-09 4단계 추가 시험(검토 문서 4.4, 감사기준서 240 A44 · 315 A161 · ICAI 실무 접근)
    def floor_of(t: dict) -> float:
        """금액 하한: 수행중요성 × ratio, 수행중요성이 없으면 min_amount."""
        return pm * t.get("ratio", 0.1) if pm else t.get("min_amount", 10_000_000)

    def floor_note(t: dict) -> str:
        return f"금액 하한 {won(floor_of(t))}" + (f" (수행중요성 × {t.get('ratio', 0.1)})" if pm else " (수행중요성이 없어 min_amount)")

    # 승인 한도 바로 아래 금액
    t = tests.get("below_limit")
    if t is not None:
        limits = sorted(float(x) for x in (t.get("limits") or []) if x)
        if not limits:
            t["note"] = "jet.yaml below_limit.limits 에 회사 전결 규정의 승인 한도가 없어 시험하지 않았습니다. 한도를 넣으면 돕니다"
        else:
            band = t.get("band", 0.9)
            groups: dict[tuple, list] = defaultdict(list)
            for v in cur:
                lim = next((x for x in limits if x * band <= v.amount < x), None)
                if lim is None:
                    continue
                who = (meta.get(id(v)) or {}).get("user") or ", ".join(v.parties) or "(작성자 · 거래처 없음)"
                groups[(lim, who)].append(v)
            for (lim, who), vs in groups.items():
                if len(vs) < t.get("min_count", 2):
                    continue
                for v in vs:
                    hit("below_limit", v, f"한도 {won(lim)} 의 {v.amount / lim:.0%} · {who} 에 이 구간 {len(vs)}건")
            t["note"] = f"한도 {', '.join(won(x) for x in limits)} · {band:.0%} 이상 한도 미만 · 같은 작성자(없으면 거래처) {t.get('min_count', 2)}건 이상"

    # 결산일 근처 가계정 정리
    t = tests.get("suspense")
    if t is not None and "suspense" in acc:
        cut = floor_of(t)
        start = end - timedelta(days=t.get("days", 15))
        for v in cur:
            if not (start < v.date <= end) or v.amount < cut:
                continue
            sus = [x for x in v.lines if _in(x, acc["suspense"])]
            clears = [x for x in sus if (x.dr if "가수" in (x.name or "") else x.cr) > 0]
            others = [x for x in v.lines if x not in sus and not _in(x, acc["cash"])]
            if clears and others:
                names = ", ".join(sorted({x.name or str(x.code) for x in clears}))
                to = ", ".join(sorted({x.name or str(x.code) for x in others}))[:60]
                hit("suspense", v, f"결산일 전 {(end - v.date).days}일, {names} 을 {to} 로 대체")
        t["note"] = floor_note(t)

    # 추정 계정의 기말 조정 · 환입
    t = tests.get("estimate")
    if t is not None and "estimates" in acc:
        cut = floor_of(t)
        for v in cur:
            if v.amount < cut:
                continue
            est = [x for x in v.lines if _in(x, acc["estimates"])]
            if not est:
                continue
            why = []
            if v.date.year == end.year and v.date.month == end.month:
                why.append("결산월 " + ", ".join(sorted({x.name or str(x.code) for x in est})))
            back = sorted({x.name for x in est if x.name and "환입" in x.name})
            if back:
                why.append("환입 " + ", ".join(back))
            if why:
                hit("estimate", v, " · ".join(why))
        t["note"] = floor_note(t)

    # 결산일 근처 매출의 기말 후 회수 없음
    t = tests.get("no_collection")
    if t is not None:
        if not post:
            t["note"] = "결산일 후 분개장이 없어 시험하지 못했습니다. 기말 후 2개월 분개장을 받아 주십시오"
        else:
            cut = floor_of(t)
            start = end - timedelta(days=t.get("days", 15))
            paid = {x.party for v in post for x in v.lines if x.party and x.cr > 0 and _in(x, acc["receivable"])}
            no_party = 0
            for v in cur:
                if not (start < v.date <= end) or v.amount < cut:
                    continue
                ar = [x for x in v.lines if x.dr > 0 and _in(x, acc["receivable"])]
                if not ar or not any(x.cr > 0 and _in(x, acc["revenue"]) for x in v.lines):
                    continue
                ps = sorted({x.party for x in ar if x.party})
                if not ps:
                    no_party += 1
                    continue
                left = [p for p in ps if p not in paid]
                if left:
                    hit("no_collection", v, f"결산일 전 {(end - v.date).days}일 외상 매출 · 기말 후 분개장에 {', '.join(left)} 매출채권 대변 없음")
            t["note"] = floor_note(t) + (f". 거래처가 빈 외상 매출 {no_party}건은 보지 못했습니다" if no_party else "")

    # 현금 · 채권 · 채무 없이 이익을 늘린 전표(기간 전체)
    t = tests.get("noncash_profit")
    if t is not None:
        cut = floor_of(t)
        money = [acc[g] for g in ("cash", "receivable", "payable", "other_payable") if g in acc]
        for v in cur:
            if v.amount < cut:
                continue
            e = _pnl(v, acc, pl_names)
            if e >= cut and not any(_in(x, g) for x in v.lines for g in money):
                hit("noncash_profit", v, f"이익 +{won(e)}, 상대 계정 {v.label('dr') if e > 0 else v.label('cr')}")
        t["note"] = floor_note(t)

    # 드물게 쓰는 계정
    t = tests.get("rare_account")
    if t is not None:
        uses: dict[str, set] = defaultdict(set)
        for v in cur:
            for x in v.lines:
                k = x.code or common.reader._norm(x.name or "")
                if k:
                    uses[k].add(id(v))
        rare = {k for k, s in uses.items() if len(s) <= t.get("max_count", 3)}
        low = float(mat.get("trivial") or 0) or t.get("min_amount", 1_000_000)
        for v in cur:
            if v.amount < low:
                continue
            ks = sorted({x.name or str(x.code) for x in v.lines if (x.code or common.reader._norm(x.name or "")) in rare})
            if ks:
                hit("rare_account", v, f"당기 {t.get('max_count', 3)}건 이하로 쓴 계정: {', '.join(ks)}")
        t["note"] = f"계정 {len(rare)}개가 당기 {t.get('max_count', 3)}건 이하 · 금액 하한 {won(low)}"

    # 모집단 분석: 첫 자리 분포 · 월별
    an = spec.get("analyses") or {}
    analyses = {"benford": {**benford(j["cur"], an.get("benford") or {}), "title": (an.get("benford") or {}).get("title", "첫 자리 분포")},
                "monthly": {**monthly(cur, common.fy_start(d), end, acc, an.get("monthly") or {}),
                            "title": (an.get("monthly") or {}).get("title", "월별 전표 · 매출"), "ratio": (an.get("monthly") or {}).get("ratio", 1.5)}}

    # 완전성: 손익계정
    jnet: dict[str, float] = {}
    for x in j["cur"]:
        if x.code is not None:
            jnet[x.code] = jnet.get(x.code, 0.0) + x.dr - x.cr
    tb_codes = {str(r["code"]) for r in tb}
    # 더존 세목(41501 · 41503)은 합계잔액시산표에 본계정(41500)으로 합쳐 나온다. 시산표에 없는 5자리 코드는 앞 세 자리가 같은
    # 본계정(끝 00, 또는 3자리 코드)이 시산표에 있으면 그 계정에 더한다(2026-10-21, 예: 세목 41501 → 본계정 41500)
    rolled: dict[str, str] = {}
    for c in sorted(jnet):
        s = str(c)
        if s in tb_codes or not (len(s) == 5 and s.isdigit()) or not common.is_pl(s):
            continue
        parent = next((p for p in (s[:3] + "00", s[:3]) if p != s and p in tb_codes), None)
        if parent:
            jnet[parent] = jnet.get(parent, 0.0) + jnet.pop(c)
            rolled[s] = parent
    tb_coded["rolled"] = rolled
    comp = []
    for r in tb:
        if r["pl"]:
            comp.append({"code": r["code"], "name": r["name"], "journal": common.reader._int(jnet.get(str(r["code"]), 0.0)), "tb": r["amount"]})
    for c, v in sorted(jnet.items()):
        if common.is_pl(c) and c not in tb_codes and abs(v) > 0.5:
            comp.append({"code": c, "name": "(시산표에 없음)", "journal": common.reader._int(v), "tb": 0})
    closing = closing_types(cur, spec, end)
    bs = bs_completeness(d, tb, j["cur"])
    sources = voucher_sources(cur, j["extra_cols"], spec)
    if not j["cur"] and j["failed"]:
        # 분개장 파일은 있는데 판독하지 못했다. 시험 0건을 「해당 없음」 으로 읽지 않게 시험마다 까닭을 적는다(R8)
        why = "; ".join(f"{x['path']} {x['why']}" for x in j["failed"])
        for t in tests.values():
            t["note"] = f"분개장을 판독하지 못해 시험하지 못했습니다({why})"
    rec = recurring(cur, spec)
    ov = overview(cur, meta, cols, set(hol), rec)
    return {"tests": list(tests.values()), "completeness": comp, "recurring": rec, "overview": ov,
            "selection": spec.get("selection") or {}, "tb_codes": tb_coded, "bs_completeness": bs, "closing": closing, "sources": sources,
            "files": j["files"], "failed": j["failed"], "file_stats": j.get("file_stats", []), "file_checks": j.get("file_checks", []),
            "excluded": j.get("excluded", []),
            "dr": sum(x.dr for x in j["cur"]), "cr": sum(x.cr for x in j["cur"]), "lines": len(j["cur"]),
            "vouchers": len(cur), "post_vouchers": len(post), "mat": mat,
            "seq": seq, "analyses": analyses, "entry_cols": cols, "meta": meta, "pnl": {id(v): _pnl(v, acc, pl_names) for v in cur + post}}


def make(d: Path, ctx: dict | None = None, force: bool = False) -> dict:
    d = Path(d)
    mat = (ctx or {}).get("mat") or common.materiality(d)
    r = run(d, mat)
    b = wp.Book(d, "3600-JET", standard="감사기준서 240 문단 33(a) · 한공회 3600 부정의 검토 · 분개장 전수")
    ws, row = b.sheet("요약", widths=[30, 14, 18, 18, 18, 40])
    shown = ", ".join(r["files"]) or ("판독 실패" if r["failed"] else "없음")
    if r["failed"]:
        shown += ". 판독 실패: " + "; ".join(f"{x['path']} {x['why']}" for x in r["failed"])
    ws.cell(6, 1, "분개장: " + shown).font = wp.font(size=9, color=wp.MUTED, bold=bool(r["failed"]))

    # 완전성 0: 받은 분개장 파일별 행 수 · 기간 · 차대(2026-11-09). 잘린 파일 · 빠진 달이 있으면 시험 0건이 「해당 없음」 이 아니다
    if r["file_stats"]:
        row = b.section(ws, row, "완전성 0: 받은 분개장 파일 (파일 안 그대로, 겹친 줄을 빼기 전)")
        row = b.head(ws, row, ["파일", "줄 수", "차변 합계", "대변 합계", "차이", "기간"])
        for f in r["file_stats"]:
            b.put(ws, row, 1, f["path"])
            b.put(ws, row, 2, f["lines"], fmt="#,##0")
            b.put(ws, row, 3, f["dr"], fmt=wp.WON)
            b.put(ws, row, 4, f["cr"], fmt=wp.WON)
            b.put(ws, row, 5, f"=C{row}-D{row}", fmt=wp.WON, flag=abs(f["dr"] - f["cr"]) > 0.5)
            b.put(ws, row, 6, f"{f['first']} ~ {f['last']}" if f["first"] else "")
            row += 1
        for x in r["excluded"]:
            if x.get("why"):
                ws.cell(row, 1, f"{x['path']}: {x['why']}" + (f" (뺀 줄 {x['dropped']:,})" if x.get("dropped") else "")).font = wp.font(size=9, color=wp.MUTED)
                row += 1
        if r["file_checks"]:
            ws.cell(row, 1, "모집단 미확정: 아래가 풀리기 전에는 시험 0건을 「해당 없음」 으로 결론 내지 않는다").font = wp.font(size=10, bold=True, color=wp.RED)
            row += 1
            for msg in r["file_checks"]:
                ws.cell(row, 1, "· " + msg).font = wp.font(size=9, bold=True)
                row += 1
            ask(b, ws, row, 6, "확인: 분개장 완전성(잘린 파일 · 빠진 달 · 차대 차이)")
            row += 1
        row += 1

    row = b.section(ws, row, "완전성 1: 당기 분개장 차변 합계 = 대변 합계")
    row = b.head(ws, row, ["항목", "행 수", "차변 합계", "대변 합계", "차이", ""])
    b.put(ws, row, 1, "당기 분개장")
    b.put(ws, row, 2, r["lines"], fmt="#,##0")
    b.put(ws, row, 3, r["dr"], fmt=wp.WON)
    b.put(ws, row, 4, r["cr"], fmt=wp.WON)
    b.put(ws, row, 5, f"=C{row}-D{row}", fmt=wp.WON, flag=abs(r["dr"] - r["cr"]) > 0.5)
    b.verify("분개장 차변 − 대변", f"='요약'!E{row}", r["dr"] - r["cr"])
    row += 2

    row = b.section(ws, row, "완전성 2: 당기 분개장 손익계정 순액 = 회사제시 시산표 (재무상태표 계정은 기초 잔액이 분개장에 없어 대사하지 않는다)")
    row = b.head(ws, row, ["계정", "", "분개장 순액", "시산표", "차이", ""])
    f0 = row
    for c in r["completeness"]:
        b.put(ws, row, 1, f"{c['code']} {c['name']}")
        b.put(ws, row, 3, c["journal"], fmt=wp.WON)
        b.put(ws, row, 4, c["tb"], fmt=wp.WON)
        b.put(ws, row, 5, f"=C{row}-D{row}", fmt=wp.WON, flag=abs(c["journal"] - c["tb"]) > 0.5)
        row += 1
    if r["completeness"]:
        b.put(ws, row, 1, "합계", bold=True)
        for col, L in ((3, "C"), (4, "D"), (5, "E")):
            b.put(ws, row, col, f"=SUM({L}{f0}:{L}{row - 1})", fmt=wp.WON, bold=True)
        b.verify("손익계정 분개장 − 시산표 차이 합", f"='요약'!E{row}", sum(c["journal"] - c["tb"] for c in r["completeness"]))
        b.verify("손익계정 차이 절대값 합", "=" + "+".join(f"ABS('요약'!E{x})" for x in range(f0, row)),
                 sum(abs(c["journal"] - c["tb"]) for c in r["completeness"]))
        row += 1
    tc = r.get("tb_codes") or {}
    if tc.get("journal"):
        msg = f"시산표에 계정코드가 없어 {JOURNAL_CHART}의 [코드]이름 짝으로 계정 {tc['journal']}개의 코드를 붙였습니다"
        if tc.get("guessed"):
            msg += f". 분개장에 같은 이름이 없는 계정 {tc['guessed']}개는 계정 사전 · 재무제표 위치로 붙인 코드입니다"
        ws.cell(row, 1, msg).font = wp.font(size=9, color=wp.MUTED)
        row += 1
    if tc.get("rolled"):
        pairs = sorted(tc["rolled"].items())
        msg = (f"분개장 세목 {len(pairs)}개는 시산표에 본계정으로 합쳐 나와 본계정 순액에 더했습니다: "
               + " · ".join(f"{c} → {p}" for c, p in pairs[:12]) + (" 외" if len(pairs) > 12 else ""))
        ws.cell(row, 1, msg).font = wp.font(size=9, color=wp.MUTED)
        row += 1
    row += 1

    row = b.section(ws, row, "시험 (조건은 definitions/jet.yaml)")
    row = b.head(ws, row, ["시험", "전표 수", "금액", "조건", "", "회계사 확인"])
    for t in r["tests"]:
        b.put(ws, row, 1, t["title"], bold=True)
        b.put(ws, row, 2, f"=COUNTIF('결과 목록'!A:A,A{row})", fmt="#,##0")
        b.put(ws, row, 3, f"=SUMIF('결과 목록'!A:A,A{row},'결과 목록'!J:J)", fmt=wp.WON)
        b.put(ws, row, 4, t["condition"] + (f" · {t['note']}" if t["note"] else ""), wrap=True)
        ws.merge_cells(start_row=row, start_column=4, end_row=row, end_column=5)
        ask(b, ws, row, 6, f"확인: {t['title']}")
        ws.row_dimensions[row].height = 45
        b.verify(f"JET {t['title']} 건수", f"='요약'!B{row}", len(t["hits"]))
        b.verify(f"JET {t['title']} 금액", f"='요약'!C{row}", sum(h["voucher"].amount for h in t["hits"]))
        row += 1
    ws.cell(row, 1, "전표 수는 결과 목록의 줄 수다. 한 전표가 여러 시험에 걸리면 시험마다 한 줄이다").font = wp.font(size=9, color=wp.MUTED)
    row += 2

    # 모집단 분석(2026-10-21): 분개장 전체의 분포를 본다. 자세한 표는 「분포 분석」 · 「전표번호 연속성」 시트
    an = r["analyses"]
    row = b.section(ws, row, "모집단 분석 (분포 분석 · 전표번호 연속성 시트)")
    row = b.head(ws, row, ["분석", "", "", "결과", "", "회계사 확인"])
    bf, mo = an["benford"], an["monthly"]
    b.put(ws, row, 1, bf["title"], bold=True)
    b.put(ws, row, 4, f"줄 {bf['n']:,}개 · MAD " + ("-" if bf["mad"] is None else f"{bf['mad']:.4f}") + f" · {bf['verdict']}", wrap=True,
          flag=bf["verdict"] in ("경계", "부적합"))
    ws.merge_cells(start_row=row, start_column=4, end_row=row, end_column=5)
    ask(b, ws, row, 6, f"확인: {bf['title']}")
    row += 1
    b.put(ws, row, 1, mo["title"], bold=True)
    txt = "결산월 매출 " + ("-" if mo["ye_ratio"] is None else f"= 월평균의 {mo['ye_ratio']:.2f}배") + \
          (f" (기준 {mo['ratio']}배 이상)" if mo["flag"] else "")
    b.put(ws, row, 4, txt, wrap=True, flag=mo["flag"])
    ws.merge_cells(start_row=row, start_column=4, end_row=row, end_column=5)
    ask(b, ws, row, 6, f"확인: {mo['title']}")
    row += 1
    sq = r["seq"]
    b.put(ws, row, 1, "전표번호 연속성", bold=True)
    b.put(ws, row, 4, sq["note"], wrap=True, flag=bool(sq.get("gaps")))
    ws.merge_cells(start_row=row, start_column=4, end_row=row, end_column=5)
    ask(b, ws, row, 6, "확인: 전표번호 연속성")
    ws.row_dimensions[row].height = 30
    row += 2
    # 질문과 전체 기간 고려는 3600 점검표 문항에 있다(2026-11-02 스킬 리뷰에서 칸을 더했다가 겹쳐서 뺐다). 여기서는 잇기만 한다
    ws.cell(row, 1, "재무보고절차 관여자 질문(감사기준서 240 문단 33(a)(i))과 보고기간 전체 테스트 고려(33(a)(iii))는 3600 부정검토 점검표 문항에 적는다").font = \
        wp.font(size=9, color=wp.MUTED)
    row += 2
    b.conclusion(ws, row, 6)

    _overview_sheet(b, r)
    _first_sheet(b, r, d)
    has_entry = any(r["entry_cols"].get(k) for k in ("user", "approver", "entered"))
    wl, rl = b.sheet("결과 목록",widths=[20, 12, 6, 16, 6, 26, 26, 16, 34, 16, 34, 30, 16] + ([30] if has_entry else []))
    rl = b.head(wl, rl, ["시험", "일자", "요일", "전표번호", "줄 수", "차변 계정", "대변 계정", "거래처", "적요", "금액", "근거", "검토 결과", "이익 효과"] +
                (["작성 · 승인 · 입력"] if has_entry else []))
    for t in r["tests"]:
        req = t.get("review") == "required"
        for h in t["hits"]:
            v = h["voucher"]
            b.put(wl, rl, 1, t["title"])
            b.put(wl, rl, 2, v.date.isoformat())
            b.put(wl, rl, 3, WEEKDAYS[v.date.weekday()], flag=v.date.weekday() >= 5)
            b.put(wl, rl, 4, v.no)
            b.put(wl, rl, 5, len(v.lines))
            b.put(wl, rl, 6, v.label("dr"), wrap=True)
            b.put(wl, rl, 7, v.label("cr"), wrap=True)
            b.put(wl, rl, 8, ", ".join(v.parties))
            b.put(wl, rl, 9, common.short(v.memo, 60), wrap=True)
            b.put(wl, rl, 10, v.amount, fmt=wp.WON)
            b.put(wl, rl, 11, h["why"], wrap=True, flag=req)
            # 필수 검토 전표의 답은 「먼저 볼 전표」 시트에서 전표마다 한 번 받는다(2026-10-24). 여기는 시험 단위 참고 칸
            ask(b, wl, rl, 12, f"검토 결과: {t['id']} {v.date.isoformat()} {v.no}", rule="optional")
            pnl = r["pnl"].get(id(v), 0.0)
            b.put(wl, rl, 13, common.reader._int(pnl) if abs(pnl) > 0.5 else None, fmt=wp.WON)
            if has_entry:
                b.put(wl, rl, 14, _entry_text(r["meta"].get(id(v), {})), wrap=True)
            rl += 1
    wl.cell(rl + 1, 1, "이익 효과: 그 전표가 손익계정(매출 · 매출원가 · 판관비 · 영업외 · 법인세)에 준 순효과. + 면 이익이 늘었다").font = \
        wp.font(size=9, color=wp.MUTED)
    _multi_sheet(b, r)
    _bs_sheet(b, r)
    _closing_sheet(b, r)
    _seq_sheet(b, r)
    _dist_sheet(b, r)
    out = common.save(b, force=force)
    out["summary"] = {t["id"]: len(t["hits"]) for t in r["tests"]}
    out["run"] = r
    return out


def _owner_map(d: Path) -> tuple[dict, dict]:
    """(계정코드 → 영역, 조서번호 → 배정). 배정이 없으면 빈 사전."""
    try:
        areas = {str(x["code"]): x.get("area") for x in common.tb_rows(d) if x.get("code") is not None}
    except Exception:  # 시산표가 없거나 영역을 못 정하면 담당 칸을 비운다
        areas = {}
    from .. import assign
    try:
        owners = assign.of(d)
    except Exception:
        owners = {}
    return areas, owners


def priority(r: dict, d: Path | None = None) -> list[dict]:
    """필수 검토 시험에 하나라도 걸린 전표를 전표마다 한 줄로, 점수 높은 순(2026-10-24, 가중치 2026-11-09).

    점수 = 걸린 시험의 weight 합(jet.yaml, 없으면 필수 2 · 참고 1 · 기말 반대 잔액 원인 5) + 금액 점수(selection.amount_points,
    기본은 수행중요성 이상 2 · 절반 이상 1). 시험 결과 한 건에 review · weight 가 따로 있으면 그것을 쓴다(음수 금액 줄만 있는 전표).
    담당은 전표의 주된 계정(현금 · 예금 · 부가세를 뺀 가장 큰 줄)의 영역 조서(4000+영역) 배정."""
    pm = (r.get("mat") or {}).get("performance") or 0
    pts = (r.get("selection") or {}).get("amount_points") or [[1.0, 2], [0.5, 1]]
    by: dict[int, dict] = {}
    for t in r["tests"]:
        for h in t["hits"]:
            req = (h.get("review") or t.get("review")) == "required"
            w = h.get("weight", t.get("weight", (2 if req else 1) + (3 if t["id"] == "opposite_cause" else 0)))
            v = h["voucher"]
            e = by.setdefault(id(v), {"voucher": v, "tests": [], "ids": [], "whys": [], "required": False, "score": 0})
            if t["title"] in e["tests"]:
                continue
            e["tests"].append(t["title"])
            e["ids"].append(t["id"])
            e["whys"].append(h["why"])
            e["required"] |= req
            e["score"] += w
    areas, owners = _owner_map(d) if d else ({}, {})
    out = []
    for e in by.values():
        if not e["required"]:
            continue
        v = e["voucher"]
        if pm:
            e["score"] += next((pt for k, pt in sorted(pts, key=lambda x: -x[0]) if v.amount >= pm * k), 0)
        main = sorted((x for x in v.lines if not any(w in (x.name or "") for w in ("현금", "예금", "부가세"))),
                      key=lambda x: -max(x.dr, x.cr))
        area = areas.get(str(main[0].code)) if main and main[0].code is not None else None
        e["area"] = area
        e["owner"] = (owners.get(f"4000{area}") or {}).get("to") if area else None
        out.append(e)
    return sorted(out, key=lambda e: (-e["score"], -e["voucher"].amount, e["voucher"].date, e["voucher"].no))


def select(r: dict, rows: list[dict]) -> dict:
    """검토 대상 고르기(2026-11-09 3단계, 검토 문서 4.3). rows 는 priority() 결과(점수 높은 순).
    1) selection.all_tests 시험에 걸리고 금액이 all_min 이상인 전표는 전부 고른다(「고위험 시험 전부」).
    2) 나머지는 점수 높은 순으로 top_n 건. 반복 전표 묶음에서는 처음 만난(점수가 가장 높은) 한 건만 고르고 나머지는 「같은 꼴」 로 센다.
    {"picked": [..], "rule": {..}, "counts": {"pool", "all", "top", "same", "left"}}. 고른 줄에는 pick(까닭) · group(묶음 번호)을 붙인다."""
    cfg = r.get("selection") or {}
    mat = r.get("mat") or {}
    titles = {t["id"]: t["title"] for t in r["tests"]}
    all_ids = [x for x in cfg.get("all_tests", []) if x in titles]
    floor = cfg.get("all_min", "trivial")
    floor = float(mat.get("trivial") or 0) if floor == "trivial" else float(floor or 0)
    top_n = int(cfg.get("top_n", 25))
    of = (r.get("recurring") or {}).get("of", {})
    picked, rest = [], []
    for e in rows:
        e["group"] = of.get(id(e["voucher"]))
        hi = [titles[x] for x in e["ids"] if x in all_ids]
        if hi and e["voucher"].amount >= floor:
            e["pick"] = "고위험 시험 전부: " + " · ".join(hi)
            picked.append(e)
        else:
            rest.append(e)
    n_all = len(picked)
    seen, same, n_top = set(), 0, 0
    for e in rest:
        if n_top >= top_n:
            break
        if e["group"] and e["group"] in seen:
            same += 1
            continue
        e["pick"] = f"점수 상위 {top_n}건" + (f"(반복 묶음 {e['group']} 대표)" if e["group"] else "")
        picked.append(e)
        n_top += 1
        if e["group"]:
            seen.add(e["group"])
    return {"picked": picked,
            "rule": {"all_tests": [titles[x] for x in all_ids], "all_min": floor, "top_n": top_n},
            "counts": {"pool": len(rows), "all": n_all, "top": n_top, "same": same, "left": len(rows) - len(picked)}}


def _first_sheet(b: wp.Book, r: dict, d: Path) -> None:
    rows = priority(r, d)
    sel = select(r, rows)
    picked, rule, cnt = sel["picked"], sel["rule"], sel["counts"]
    ws, row = b.sheet("먼저 볼 전표", widths=[6, 6, 30, 12, 10, 16, 30, 40, 24, 24, 18, 30, 10, 10, 26, 26])
    ws.cell(6, 1, "필수 검토 시험에 걸린 전표 가운데 아래 규칙으로 고른 전표다(2026-11-09). 점수 = 걸린 시험의 가중치 합(definitions/jet.yaml weight) "
                  "+ 금액 점수(수행중요성 이상 2 · 절반 이상 1). 가중치 · 규칙은 예시 값이라 회사 위험에 맞게 jet.yaml 에서 바꾼다. "
                  "고르지 않은 전표는 결과 목록에 남는다. 담당은 전표의 주된 계정 영역 조서(4000+영역)의 배정(2110-배정)"
                  ).font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, "고르는 규칙 (definitions/jet.yaml selection · recurring)")
    rec = r.get("recurring") or {}
    floor_txt = f" 에 걸린 전표 가운데 금액 {won(rule['all_min'])} 이상 전부" if rule["all_min"] else " 에 걸린 전표 전부"
    lines = [("고위험 시험 전부", " · ".join(rule["all_tests"]) + floor_txt),
             ("점수 상위", f"나머지에서 점수 높은 순으로 {rule['top_n']}건"),
             ("반복 묶음", f"차변 계정 · 대변 계정 · 거래처 · 금액 크기대(약 1.8배 폭)가 같은 전표가 {rec.get('min_months', 3)}개 달 이상 · {rec.get('min_count', 3)}건 이상이면 "
                       "한 묶음. 점수 상위를 고를 때 묶음마다 한 건만 대표로 올린다")]
    for k, txt in lines:
        b.put(ws, row, 1, k, bold=True)
        ws.merge_cells(start_row=row, start_column=1, end_row=row, end_column=2)
        b.put(ws, row, 3, txt, wrap=True)
        ws.merge_cells(start_row=row, start_column=3, end_row=row, end_column=8)
        ws.row_dimensions[row].height = 30
        row += 1
    row += 1
    row = b.head(ws, row, ["구분", "", "전표 수", "", "", ""])
    c0 = row
    for k, n in (("고위험 시험 전부", cnt["all"]), ("점수 상위", cnt["top"]), ("고르지 않음(반복 묶음 같은 꼴 포함)", cnt["left"])):
        b.put(ws, row, 1, k)
        b.put(ws, row, 3, n, fmt="#,##0")
        row += 1
    b.put(ws, row, 1, "필수 검토 시험에 걸린 전표", bold=True)
    b.put(ws, row, 3, f"=SUM(C{c0}:C{row - 1})", fmt="#,##0", bold=True)
    b.verify("먼저 볼 전표 후보 수", f"='먼저 볼 전표'!C{row}", cnt["pool"])
    row += 1
    if cnt["same"]:
        ws.cell(row, 1, f"점수 상위를 고르는 동안 이미 고른 반복 묶음과 같은 꼴이라 넘긴 전표 {cnt['same']:,}건").font = wp.font(size=9, color=wp.MUTED)
        row += 1
    row += 1
    who = Counter(e["owner"] or "미배정" for e in picked)
    row = b.section(ws, row, "담당자별 건수")
    row = b.head(ws, row, ["담당", "", "전표 수", "", "", ""])
    for name, n in who.most_common():
        b.put(ws, row, 1, name)
        b.put(ws, row, 3, n, fmt="#,##0")
        row += 1
    row += 1
    row = b.section(ws, row, "먼저 볼 전표 (고위험 시험 전부, 그다음 점수 높은 순)")
    row = b.head(ws, row, ["순위", "점수", "고른 까닭", "일자", "전표번호", "금액", "걸린 시험", "근거", "차변 계정", "대변 계정", "거래처", "적요",
                           "반복 묶음", "담당", "확인 결과", "증빙 · 답"])
    for i, e in enumerate(picked, 1):
        v = e["voucher"]
        b.put(ws, row, 1, i)
        b.put(ws, row, 2, e["score"])
        b.put(ws, row, 3, e["pick"], wrap=True)
        b.put(ws, row, 4, v.date.isoformat())
        b.put(ws, row, 5, v.no)
        b.put(ws, row, 6, v.amount, fmt=wp.WON)
        b.put(ws, row, 7, " · ".join(e["tests"]), wrap=True)
        b.put(ws, row, 8, " / ".join(e["whys"]), wrap=True)
        b.put(ws, row, 9, v.label("dr"), wrap=True)
        b.put(ws, row, 10, v.label("cr"), wrap=True)
        b.put(ws, row, 11, ", ".join(v.parties), wrap=True)
        b.put(ws, row, 12, common.short(v.memo, 60), wrap=True)
        b.put(ws, row, 13, e["group"] or "")
        b.put(ws, row, 14, e["owner"] or "")
        ask(b, ws, row, 15, f"확인 결과: {v.date.isoformat()} {v.no}", rule="required")
        ask(b, ws, row, 16, f"증빙 · 답: {v.date.isoformat()} {v.no}", rule="optional")
        row += 1
    if not picked:
        ws.cell(row, 1, "필수 검토 시험에 걸린 전표가 없습니다").font = wp.font(color=wp.MUTED)
    if picked:   # 순위 칸의 가장 큰 값이 전표 수다(재계산기 xlcalc 는 COUNTA 를 모른다)
        b.verify("먼저 볼 전표 수", f"=MAX('먼저 볼 전표'!A{row - len(picked)}:A{row - 1})", len(picked))


def _overview_sheet(b: wp.Book, r: dict) -> None:
    """모집단 개요(2026-11-09 3단계). 시험 결과를 보기 전에 분개장 모양을 본다. 합계는 수식이고 엔진 값과 맞댄다."""
    ov, rec = r.get("overview"), r.get("recurring") or {}
    if not ov or not ov["vouchers"]:
        return
    ws, row = b.sheet("모집단 개요", widths=[26, 14, 14, 18, 14, 14, 40])
    ws.cell(6, 1, "당기 전표(결산 마감 분개 제외). 시험 기준을 정하기 전에 월별 분포 · 전표 크기 · 작성자 · 자주 쓰는 계정 · 반복 전표 비율을 본다"
            ).font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, "월별")
    row = b.head(ws, row, ["월", "전표 수", "줄 수", "금액(차변)", "주말 · 공휴일 전표", "주말 비율", ""])
    m0 = row
    for m in ov["months"]:
        b.put(ws, row, 1, m["month"])
        b.put(ws, row, 2, m["vouchers"], fmt="#,##0")
        b.put(ws, row, 3, m["lines"], fmt="#,##0")
        b.put(ws, row, 4, m["amount"], fmt=wp.WON)
        b.put(ws, row, 5, m["weekend"], fmt="#,##0")
        b.put(ws, row, 6, f"=IF(B{row}=0,0,E{row}/B{row})", fmt="0.0%")
        row += 1
    b.put(ws, row, 1, "합계", bold=True)
    for col, L in ((2, "B"), (3, "C"), (4, "D"), (5, "E")):
        b.put(ws, row, col, f"=SUM({L}{m0}:{L}{row - 1})", fmt=wp.WON if col == 4 else "#,##0", bold=True)
    b.put(ws, row, 6, f"=IF(B{row}=0,0,E{row}/B{row})", fmt="0.0%", bold=True)
    b.verify("모집단 개요 전표 수", f"='모집단 개요'!B{row}", ov["vouchers"])
    b.verify("모집단 개요 줄 수", f"='모집단 개요'!C{row}", ov["lines"])
    tot = row
    row += 2
    row = b.section(ws, row, "전표 크기 (줄 수)")
    row = b.head(ws, row, ["줄 수", "전표 수", "비율", "", "", "", ""])
    s0 = row
    for x in ov["sizes"]:
        lo, hi = x["band"]
        b.put(ws, row, 1, f"{lo}~{hi}줄" if hi else f"{lo}줄 이상")
        b.put(ws, row, 2, x["vouchers"], fmt="#,##0")
        b.put(ws, row, 3, f"=IF($B${tot}=0,0,B{row}/$B${tot})", fmt="0.0%")
        row += 1
    b.put(ws, row, 1, "합계", bold=True)
    b.put(ws, row, 2, f"=SUM(B{s0}:B{row - 1})", fmt="#,##0", bold=True)
    b.verify("전표 크기 합 − 전표 수", f"='모집단 개요'!B{row}-'모집단 개요'!B{tot}", 0)
    row += 2
    if ov["users"]:
        row = b.section(ws, row, "작성자별")
        row = b.head(ws, row, ["작성자", "전표 수", "비율", "금액(차변)", "", "", ""])
        for u in ov["users"][:30]:
            b.put(ws, row, 1, u["user"])
            b.put(ws, row, 2, u["vouchers"], fmt="#,##0")
            b.put(ws, row, 3, f"=IF($B${tot}=0,0,B{row}/$B${tot})", fmt="0.0%")
            b.put(ws, row, 4, u["amount"], fmt=wp.WON)
            row += 1
        if len(ov["users"]) > 30:
            ws.cell(row, 1, f"외 {len(ov['users']) - 30}명").font = wp.font(size=9, color=wp.MUTED)
            row += 1
        row += 1
    row = b.section(ws, row, f"자주 쓰는 계정 상위 {len(ov['accounts'])} (계정 {ov['accounts_n']:,}개 가운데, 줄 수 순)")
    row = b.head(ws, row, ["계정", "줄 수", "쓴 달 수", "차변 합계", "대변 합계", "", ""])
    for a in ov["accounts"]:
        b.put(ws, row, 1, f"{a['code']} {a['name']}" if a["name"] and a["name"] != a["code"] else a["code"])
        b.put(ws, row, 2, a["lines"], fmt="#,##0")
        b.put(ws, row, 3, a["months"])
        b.put(ws, row, 4, a["dr"], fmt=wp.WON)
        b.put(ws, row, 5, a["cr"], fmt=wp.WON)
        row += 1
    row += 1
    gs = rec.get("groups") or []
    share = ov["recurring_vouchers"] / max(ov["vouchers"], 1)
    row = b.section(ws, row, f"반복 전표 묶음 ({len(gs):,}개, 전표 {ov['recurring_vouchers']:,}건 = 당기 전표의 {share:.1%})")
    row = b.head(ws, row, ["묶음", "전표 수", "달 수", "금액 합계", "", "", "차변 계정 / 대변 계정 / 거래처"])
    for g in gs[:30]:
        b.put(ws, row, 1, g["id"])
        b.put(ws, row, 2, g["count"], fmt="#,##0")
        b.put(ws, row, 3, g["months"])
        b.put(ws, row, 4, g["amount"], fmt=wp.WON)
        b.put(ws, row, 7, f"{g['dr']} / {g['cr']}" + (f" / {g['parties']}" if g["parties"] else ""), wrap=True)
        row += 1
    if len(gs) > 30:
        ws.cell(row, 1, f"외 {len(gs) - 30:,}개 묶음").font = wp.font(size=9, color=wp.MUTED)


def _bs_sheet(b: wp.Book, r: dict) -> None:
    """완전성 3: 재무상태표 계정 증감 = 차변 발생 − 대변 발생(R9 B3)."""
    bs = r["bs_completeness"]
    ws, row = b.sheet("재무상태표 대사", widths=[26, 18, 18, 18, 18, 16, 30])
    ws.cell(6, 1, "기말(시산표) − 기초(전기 잔액) = 차변 발생 − 대변 발생(당기 분개장). 전기 잔액은 감사받은 숫자 · 회사제시 전기 시산표만 쓴다"
                  "(장부 값은 늘 0 이 되어 쓰지 않는다). 원천: " + (" · ".join(bs["sources"]) or "없음")).font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, "완전성 3: 재무상태표 계정 (차변 +, 대변 −)")
    row = b.head(ws, row, ["계정", "기초(전기 잔액)", "차변 발생", "대변 발생", "기말(시산표)", "차이", "기초 출처"])
    first = row
    for x in bs["rows"]:
        b.put(ws, row, 1, f"{x['code']} {x['name']}")
        b.put(ws, row, 2, x["open"], fmt=wp.WON)
        b.put(ws, row, 3, x["dr"], fmt=wp.WON)
        b.put(ws, row, 4, x["cr"], fmt=wp.WON)
        b.put(ws, row, 5, x["close"], fmt=wp.WON)
        if x["open"] is None:
            b.put(ws, row, 6, None)
            b.put(ws, row, 7, "전기 잔액 원천 없음(작년 감사 폴더 8800 · 전기조서 8100B · 전기 시산표). 대사하지 못함", wrap=True, flag=True)
        else:
            diff = x["close"] - x["open"] - x["dr"] + x["cr"]
            b.put(ws, row, 6, f"=E{row}-B{row}-C{row}+D{row}", fmt=wp.WON, flag=abs(diff) > 0.5)
            b.put(ws, row, 7, x["basis"], wrap=True)
            b.verify(f"재무상태표 대사 {x['code']} 차이", f"='재무상태표 대사'!F{row}", diff)
        row += 1
    done = [x for x in bs["rows"] if x["open"] is not None]
    if bs["rows"]:
        b.put(ws, row, 1, "차이 합(대사한 계정)", bold=True)
        b.put(ws, row, 6, f"=SUM(F{first}:F{row - 1})", fmt=wp.WON, bold=True)
        b.verify("재무상태표 대사 차이 합", f"='재무상태표 대사'!F{row}", sum(x["close"] - x["open"] - x["dr"] + x["cr"] for x in done))
        row += 1
    ws.cell(row + 1, 1, f"대사한 계정 {len(done)}개 · 원천이 없어 대사하지 못한 계정 {len(bs['rows']) - len(done)}개").font = wp.font(size=9, color=wp.MUTED)


def _closing_sheet(b: wp.Book, r: dict) -> None:
    """결산조정 전표 유형 표와 목록, 전표 출처(입력구분 열)별 건수(R9 B3)."""
    c = r["closing"]
    ws, row = b.sheet("결산조정 전표", widths=[30, 12, 18, 12, 18, 14, 6, 16, 26, 26, 30])
    ws.cell(6, 1, "계정 조합으로 결산조정 전표를 유형별로 나눈다(definitions/jet.yaml closing_types). 분류표다. 이상 여부는 시험 결과 목록과 "
                  "검토 결과 칸에서 본다").font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, "유형별 건수 · 금액 (당기 전체 · 결산월)")
    row = b.head(ws, row, ["유형", "전표 수", "금액", "결산월 전표 수", "결산월 금액", "", "", "", "", "", ""])
    first = row
    ls = first + len(c["types"]) + 3               # 아래 목록의 첫 줄
    le = ls + max(len(c["rows"]), 1) - 1
    for t in c["types"]:
        b.put(ws, row, 1, t["title"], bold=True)
        b.put(ws, row, 2, f"=COUNTIF($A${ls}:$A${le},A{row})", fmt="#,##0")
        b.put(ws, row, 3, t["amount"], fmt=wp.WON)
        b.put(ws, row, 4, t["ye_count"], fmt="#,##0")
        b.put(ws, row, 5, t["ye_amount"], fmt=wp.WON)
        b.verify(f"결산조정 {t['title']} 전표 수", f"='결산조정 전표'!B{row}", t["count"])
        row += 1
    row += 1
    row = b.section(ws, row, f"결산조정 전표 목록 {len(c['rows'])}건")
    row = b.head(ws, row, ["유형", "일자", "전표번호", "", "금액", "", "요일", "거래처", "차변 계정", "대변 계정", "적요"])
    assert row == ls
    for title, v in c["rows"]:
        b.put(ws, row, 1, title)
        b.put(ws, row, 2, v.date.isoformat())
        b.put(ws, row, 3, v.no)
        b.put(ws, row, 5, v.amount, fmt=wp.WON)
        b.put(ws, row, 7, WEEKDAYS[v.date.weekday()])
        b.put(ws, row, 8, ", ".join(v.parties))
        b.put(ws, row, 9, v.label("dr"), wrap=True)
        b.put(ws, row, 10, v.label("cr"), wrap=True)
        b.put(ws, row, 11, common.short(v.memo, 60), wrap=True)
        row += 1
    row += 1
    src = r.get("sources")
    row = b.section(ws, row, "전표 출처(분개장 입력구분 열)")
    if not src:
        ws.cell(row, 1, "분개장에 입력구분 · 전표구분 열이 없어 수기 · 자동을 가르지 못했습니다. 수기 조정 전표 시험은 적요 낱말로 대신했습니다"
                ).font = wp.font(size=9, color=wp.MUTED)
        return
    row = b.head(ws, row, ["값(" + ", ".join(src["columns"]) + ")", "전표 수", "금액", "구분", "", "", "", "", "", "", ""])
    for e in src["rows"]:
        b.put(ws, row, 1, e["value"])
        b.put(ws, row, 2, e["count"], fmt="#,##0")
        b.put(ws, row, 3, e["amount"], fmt=wp.WON)
        b.put(ws, row, 4, e["kind"], flag=e["kind"] == "수기")
        row += 1
    ws.cell(row, 1, "구분: 값에 수기 · 수동 · 조정 · 결산 낱말이 있으면 수기(definitions/jet.yaml manual_values)").font = wp.font(size=9, color=wp.MUTED)


def multi_hits(r: dict) -> list[dict]:
    """시험 둘 이상에 걸린 전표(2026-10-21). 걸린 시험 수가 많은 순, 같으면 금액 큰 순."""
    by: dict[int, dict] = {}
    for t in r["tests"]:
        for h in t["hits"]:
            v = h["voucher"]
            e = by.setdefault(id(v), {"voucher": v, "titles": []})
            if t["title"] not in e["titles"]:
                e["titles"].append(t["title"])
    out = [e for e in by.values() if len(e["titles"]) >= 2]
    return sorted(out, key=lambda e: (-len(e["titles"]), -e["voucher"].amount, e["voucher"].date, e["voucher"].no))


def _multi_sheet(b: wp.Book, r: dict) -> None:
    """여러 시험에 걸린 전표(2026-10-21). 결과 목록은 시험마다 한 줄이라 한 전표가 흩어져 보인다. 전표마다 모아 먼저 볼 순서로 늘어놓는다."""
    rows = multi_hits(r)
    ws, row = b.sheet("여러 시험에 걸린 전표", widths=[16, 12, 16, 30, 16, 16, 10, 70])
    ws.cell(6, 1, "시험 둘 이상에 걸린 전표를 걸린 시험 수가 많은 순으로 모았다. 검토 결과는 결과 목록에 적는다").font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, f"여러 시험에 걸린 전표 {len(rows)}건")
    if not rows:
        return
    row = b.head(ws, row, ["전표번호", "일자", "거래처", "적요", "금액", "이익 효과", "시험 수", "걸린 시험"])
    for e in rows:
        v = e["voucher"]
        pnl = r["pnl"].get(id(v), 0.0)
        b.put(ws, row, 1, v.no)
        b.put(ws, row, 2, v.date.isoformat())
        b.put(ws, row, 3, ", ".join(v.parties))
        b.put(ws, row, 4, common.short(v.memo, 60), wrap=True)
        b.put(ws, row, 5, v.amount, fmt=wp.WON)
        b.put(ws, row, 6, common.reader._int(pnl) if abs(pnl) > 0.5 else None, fmt=wp.WON)
        b.put(ws, row, 7, len(e["titles"]), fmt="#,##0", flag=len(e["titles"]) >= 4)
        b.put(ws, row, 8, " · ".join(e["titles"]), wrap=True)
        row += 1


def _seq_sheet(b: wp.Book, r: dict) -> None:
    """전표번호 연속성(2026-10-21). 번호 앞부분(일자별 체계면 일자)마다 첫 · 끝 번호와 빠진 번호."""
    sq = r["seq"]
    ws, row = b.sheet("전표번호 연속성", widths=[24, 12, 12, 12, 14, 60])
    ws.cell(6, 1, "전표번호 끝 숫자를 앞부분(예: 202512-)마다 이어 본다. 빠진 번호는 지운 전표 · 취소한 전표일 수 있다. 회사 전산의 삭제 · 취소 전표 목록과 "
                  "대조한다. " + sq["note"]).font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, "번호 체계: " + (sq["scheme"] or "판정 못함"))
    if not sq["rows"]:
        ws.cell(row, 1, "빠진 번호가 없거나 전표번호가 없어 표를 만들지 않았습니다").font = wp.font(size=9, color=wp.MUTED)
        return
    row = b.head(ws, row, ["번호 단위 · 앞부분", "첫 번호", "끝 번호", "전표 수", "빠진 번호 수", "빠진 번호(앞 20개)"])
    first = row
    for x in sq["rows"]:
        b.put(ws, row, 1, x["key"])
        b.put(ws, row, 2, x["first"], fmt="#,##0")
        b.put(ws, row, 3, x["last"], fmt="#,##0")
        b.put(ws, row, 4, x["count"], fmt="#,##0")
        b.put(ws, row, 5, x["missing"], fmt="#,##0", flag=bool(x["missing"]))
        txt = ", ".join(map(str, x["sample"])) + (f" 외 {x['missing'] - len(x['sample']):,}개" if x["missing"] > len(x["sample"]) else "")
        if x.get("runs", 1) > 1:
            txt += f" (번호대 {x['runs']}개로 나눠 셈)"
        b.put(ws, row, 6, txt, wrap=True)
        row += 1
    b.put(ws, row, 1, "합계", bold=True)
    b.put(ws, row, 4, f"=SUM(D{first}:D{row - 1})", fmt="#,##0", bold=True)
    b.put(ws, row, 5, f"=SUM(E{first}:E{row - 1})", fmt="#,##0", bold=True)
    b.verify("전표번호 빠진 번호 수", f"='전표번호 연속성'!E{row}", sq.get("gaps", 0))


def _dist_sheet(b: wp.Book, r: dict) -> None:
    """분포 분석(2026-10-21): 줄 금액 첫 자리(벤포드)와 월별 전표 · 매출."""
    bf, mo = r["analyses"]["benford"], r["analyses"]["monthly"]
    ws, row = b.sheet("분포 분석", widths=[16, 14, 14, 14, 14, 16])
    ws.cell(6, 1, "분개장 전체의 분포다. 첫 자리 분포는 자연스럽게 생긴 금액이 벤포드 법칙(첫 자리 1 이 약 30%)을 따른다는 데 기댄다. "
                  "정가 · 고정 금액이 많은 회사나 줄이 적은 분개장은 맞지 않는 것이 정상일 수 있다").font = wp.font(size=9, color=wp.MUTED)
    row = b.section(ws, row, f"{bf['title']}: 줄 {bf['n']:,}개 · {bf['verdict']}")
    row = b.head(ws, row, ["첫 자리", "줄 수", "실제 비율", "기대 비율", "차이(절대값)", ""])
    first = row
    for dgt in range(1, 10):
        b.put(ws, row, 1, dgt)
        b.put(ws, row, 2, bf["counts"][dgt], fmt="#,##0")
        b.put(ws, row, 3, f"=IF(SUM($B${first}:$B${first + 8})=0,0,B{row}/SUM($B${first}:$B${first + 8}))", fmt="0.0%")
        b.put(ws, row, 4, math.log10(1 + 1 / dgt), fmt="0.0%")
        b.put(ws, row, 5, f"=ABS(C{row}-D{row})", fmt="0.0000")
        row += 1
    b.put(ws, row, 1, "MAD", bold=True)
    b.put(ws, row, 2, f"=SUM(B{first}:B{row - 1})", fmt="#,##0", bold=True)
    b.put(ws, row, 5, f"=SUM(E{first}:E{row - 1})/9", fmt="0.0000", bold=True, flag=bf["verdict"] in ("경계", "부적합"))
    if bf["mad"] is not None:
        # 검산 허용 오차가 0.5 라 MAD 는 100만 배로 맞춘다
        b.verify("첫 자리 분포 MAD × 1,000,000", f"='분포 분석'!E{row}*1000000", round(bf["mad"] * 1_000_000, 4))
    b.verify("첫 자리 분포 줄 수", f"='분포 분석'!B{row}", bf["n"])
    ws.cell(row + 1, 1, "기대 비율 = LOG10(1 + 1/첫 자리). MAD = 차이 아홉 개의 평균. 판정 경계(Nigrini): 0.006 이하 적합 · 0.012 이하 대체로 적합 · "
                        "0.015 이하 경계 · 그 위 부적합 (definitions/jet.yaml analyses)").font = wp.font(size=9, color=wp.MUTED)
    row += 3

    row = b.section(ws, row, mo["title"] + ("" if mo["ye_ratio"] is None else f": 결산월 매출 = 월평균의 {mo['ye_ratio']:.2f}배"))
    row = b.head(ws, row, ["월", "전표 수", "금액", "매출 순액", "월평균 대비", ""])
    first = row
    for x in mo["rows"]:
        b.put(ws, row, 1, x["ym"])
        b.put(ws, row, 2, x["count"], fmt="#,##0")
        b.put(ws, row, 3, x["amount"], fmt=wp.WON)
        b.put(ws, row, 4, common.reader._int(x["revenue"]), fmt=wp.WON)
        row += 1
    last = row - 1
    for k in range(first, last + 1):
        b.put(ws, k, 5, f"=IF(SUM($D${first}:$D${last})=0,0,D{k}/(SUM($D${first}:$D${last})/{last - first + 1}))", fmt="0.00",
              flag=k == last and mo["flag"])
    b.put(ws, row, 1, "합계", bold=True)
    for col, L in ((2, "B"), (3, "C"), (4, "D")):
        b.put(ws, row, col, f"=SUM({L}{first}:{L}{last})", fmt="#,##0" if col == 2 else wp.WON, bold=True)
    b.verify("월별 전표 수 합", f"='분포 분석'!B{row}", sum(x["count"] for x in mo["rows"]))
    b.verify("월별 매출 순액 합", f"='분포 분석'!D{row}", common.reader._int(sum(x["revenue"] for x in mo["rows"])))
    ws.cell(row + 1, 1, "매출 순액: 매출 계정 대변 − 차변. 월평균 대비는 사업연도 달 전체의 평균과 견준 배수다").font = wp.font(size=9, color=wp.MUTED)
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall