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/start.py

View on GitHub
"""시작 자료: 전기 감사보고서 · 전기조서 · 전기 재무제표 · DART 로 회사 정보와 첫 조서를 채운다(R2, 2026-10-05).

  build(d, dart_target=None, force=False)       읽기 → _색인/시작자료.json → 감사건 company → 조서(PBC · 1100 · 1200 · 2100)
                                               → 요청 메일 초안 → 폴더 훑기 · 지휘. 보고(dict)를 돌려준다
  read_prior_report(path)                      전기 감사보고서 PDF · DART html 판독
  read_prior_workpapers(paths)                 전기조서 엑셀(2700A · 8100B · 8100A) 판독
  apply(d, patch)                              엔진이 못 찾은 글 항목(감사인 · 의견 · 업종 등)을 AI · 사람 판독으로 넣는다
  mark_requested(d, at)                        요청 메일을 보낸 날을 빠진 자료에 적는다(회계사가 보낸 뒤)
  write_mail(d)                                빠진 자료 요청 메일 초안(.txt)을 1000 감사계약/ 에 쓴다

숫자는 엔진이 표 칸 · 엑셀 셀에서 읽은 값만 쓴다. 감사의견 · 감사인 같은 글 항목은 정해진 문형으로 찾고,
못 찾으면 비워 두고 need_ai 에 남긴다. 판단 칸(계약 수락 · 위험 평가 · 결론)은 기입란으로 비운다.
"""
from __future__ import annotations

import copy
import hashlib
import json
import re
import shutil
from datetime import date, datetime
from pathlib import Path

from . import dart, director, figures, folder, index, prior, reader, wp
from .errors import IntakeError

START_FILE = "시작자료.json"
PRIOR_TEXT_AI = "전기조서에서 글 블록 라벨을 찾지 못했습니다. 읽어서 prior apply 로 넣어 주십시오(확인 전)"
AREA_WP = "계정 조서(글은 전기조서.json)"
PRIOR_TABLE_AI = "전기조서에서 엔진이 아는 표(중요성 · 수정사항 · 미수정 왜곡 · 정산표)를 찾지 못했습니다"
PRIOR_REPORT = "전기 감사보고서"
PRIOR_WP = "전기조서"
PRIOR_FS = figures.PRIOR_FS
TAX_KINDS = ("부가세 신고서", "법인세 신고서", "원천세 신고서")
KEY_FIGS = ("자산총계", "부채총계", "자본총계", "매출액", "영업이익", "당기순이익")
MAIL_PREFIX = "PBC_요청자료목록_메일_"
AI_FIELDS = {"prior_report.auditor": str, "prior_report.opinion": str, "prior_report.emphasis": bool,
             "prior_report.going_concern": bool, "prior_report.report_date": str, "company.industry": str}

# PBC 분류(한공회 요청자료 목록 순서). 번호는 pbc_match.yaml 의 row 와 같다
PBC_CATEGORY = {1: "결산", 2: "결산", 3: "결산", 4: "결산", 5: "세무", 6: "세무", 7: "세무", 8: "지배구조", 9: "지배구조",
                10: "현금·차입", 11: "현금·차입", 12: "매출·채권", 13: "재고", 14: "유형·무형", 15: "유형·무형",
                16: "인건비", 17: "우발·약정", 18: "기타"}


def _now() -> str:
    return folder._now()


def _sha(p: Path) -> str:
    return hashlib.sha256(Path(p).read_bytes()).hexdigest()


def _won(v) -> str:
    return f"{v:,}원" if isinstance(v, int) else str(v)


def _idx(d: Path, name: str, default=None):
    p = Path(d) / "_색인" / name
    return json.loads(p.read_text(encoding="utf-8")) if p.exists() else default


def _fy_end(case: dict) -> date:
    return date.fromisoformat(case["fiscal_year_end"])


# ---------------------------------------------------------------- 전기 감사보고서
def _pdf_lines(path: Path) -> list[tuple[int, str]]:
    out = []
    for no, text in reader.pdf_text(path):
        for line in text.splitlines():
            if line.strip():
                out.append((no, line.strip()))
    return out


AMOUNT_TAIL = re.compile(r"^(.*?[가-힣A-Za-z\)])\s*(\(?[△\-]?[\d,]+\)?|-)(?:\s+(\(?[△\-]?[\d,]+\)?|-))?\s*$")


PAGE_NOISE = re.compile(r"^(전자공시시스템\s*dart\.fss\.or\.kr|Page\s*\d+|-\s*\d+\s*-)$")
STATEMENT_START = ("재무상태표", "대차대조표")
STATEMENT_STOP = ("자본변동표", "현금흐름표", "이익잉여금처분계산서", "결손금처리계산서", "이익잉여금처분계산서(안)")


def _statement_lines(lines: list[tuple[int, str]]) -> list[tuple[int, str]]:
    """재무상태표 제목부터 자본변동표 · 현금흐름표 제목 전까지(재무상태표 · 손익계산서 쪽). 목차 줄(점선)은 제목으로 보지 않는다.
    현금흐름표 「매출채권의 증감」 · 주석 표가 요약 숫자로 잡히지 않게 한다(2026-10-18 실제 회사 자료). 제목이 없으면 전부."""
    start = next((i for i, (_, t) in enumerate(lines) if dart.norm(t) in STATEMENT_START), None)
    if start is None:
        return lines
    end = next((i for i in range(start + 1, len(lines)) if dart.norm(lines[i][1]) in STATEMENT_STOP), len(lines))
    return lines[start:end]


def _pdf_items(lines: list[tuple[int, str]]) -> dict[str, tuple[int, int]]:
    """'과목 금액' 이 한 줄이거나, 과목 줄 다음 줄이 금액인 꼴을 읽는다. {과목: (금액, 쪽)}
    과목 줄의 숫자는 주석 번호 「(주석4,12)」 를 뗀 뒤에 본다. 떼지 않으면 「매출채권(주석4,12)」 줄을 놓친다."""
    out: dict[str, tuple[int, int]] = {}
    lines = [x for x in lines if not PAGE_NOISE.match(x[1])]      # 쪽 머리글 · 바닥글이 과목 줄과 금액 줄 사이에 끼면 놓친다
    for i, (page, line) in enumerate(lines):
        m = AMOUNT_TAIL.match(line)
        if m and dart.amount(m.group(2)) is not None and not re.search(r"\(주석[\d,\s]*$", m.group(1)):
            name, v = dart.item_name(m.group(1)), dart.amount(m.group(2))
        elif i + 1 < len(lines) and not re.search(r"\d", dart.item_name(line)) and dart.amount(lines[i + 1][1]) is not None:
            name, v = dart.item_name(line), dart.amount(lines[i + 1][1])
        else:
            continue
        if name and len(name) <= 30 and name not in out:
            out[name] = (v, page)
    return out


def _report_date(texts: list[str], fiscal_year_end: str | None) -> str | None:
    """감사보고서일. 「감사보고서일(2024년 3월 6일) 현재로 유효」 문형이 먼저, 없으면 첨부 재무제표 앞의 날짜만 있는 줄 가운데
    결산일이 아닌 마지막 줄(서명 날짜). 결산일을 감사보고서일로 읽던 것을 고쳤다(2026-10-18 실제 회사 자료)."""
    m = re.search(r"감사보고서일\(?(20\d\d년\d{1,2}월\d{1,2}일)", dart.norm(" ".join(texts)))
    if m:
        return dart.date_of(m.group(1))
    stop = next((i for i, t in enumerate(texts) if dart.norm(t) in ("(첨부)재무제표",) + STATEMENT_START), len(texts))
    dates = [dart.date_of(t) for t in texts[:stop] if re.fullmatch(r"20\d\d년\d{1,2}월\d{1,2}일", dart.norm(t))]
    dates = [x for x in dates if x != fiscal_year_end]
    return dates[-1] if dates else None


def corp_name(name: str | None) -> str:
    """회사명 비교용. 「주식회사 · (주) · ㈜」 와 공백을 뗀다(감사 폴더 「채널코퍼레이션」 과 보고서 「주식회사 채널코퍼레이션」 은 같다)."""
    n = dart.norm(name or "")
    for t in ("주식회사", "(주)", "(주)", "㈜"):
        n = n.replace(t, "")
    return n


def read_prior_report(path: Path) -> dict:
    """전기 감사보고서 한 파일(PDF 또는 DART html). 숫자는 표에서, 의견 · 감사인은 정해진 문형으로."""
    path = Path(path)
    if path.suffix.lower() in (".html", ".htm"):
        r = dart.parse(path.read_bytes().decode("utf-8", errors="replace"))
        figs = {k: v[0] for k, v in {**r["key_bs"], **r["key_is"]}.items() if v[0] is not None}
        return {"format": "DART", "company": r["company"], "auditor": r["auditor"], "opinion": r["opinion"],
                "emphasis": r["emphasis"], "going_concern": r["going_concern"], "report_date": r["report_date"],
                "fiscal_year_end": r["fiscal_year_end"], "framework": r["framework"], "figures": figs,
                "figure_pages": {}, "need_ai": list(r["need_ai"]), "dart": r, "term": r.get("term")}
    lines = _pdf_lines(path)
    if not lines:
        return {"format": "PDF", "company": None, "auditor": None, "opinion": None, "emphasis": None, "going_concern": None,
                "report_date": None, "fiscal_year_end": None, "framework": None, "figures": {}, "figure_pages": {}, "term": None,
                "need_ai": ["PDF 에서 글자를 뽑지 못했습니다(스캔본). 글자 판독이 필요합니다"]}
    texts = [t for _, t in lines]
    whole = " ".join(texts)
    out = {"format": "PDF", "need_ai": []}
    company = None
    for i, t in enumerate(texts):
        n = dart.norm(t)
        if n.endswith("귀중"):
            company = n[: n.find("주주")] if "주주" in n else ""
            if not company and i:
                company = dart.norm(texts[i - 1])
            break
    out["company"] = company or None
    a = whole.find("감사의견")
    b = whole.find("근거", a + 4) if a >= 0 else -1
    op_text = whole[a: b if b > 0 else None] if a >= 0 else whole
    out["opinion"] = dart.opinion_of(op_text)
    out["framework"] = dart.framework_of(op_text) or dart.framework_of(whole)
    out["fiscal_year_end"] = dart.date_of(op_text)
    nw = dart.norm(whole)
    out["emphasis"] = "강조사항" in nw
    out["going_concern"] = "계속기업관련중요한불확실성" in nw
    out["auditor"] = dart.auditor_of(texts)
    out["term"] = dart.term_of(texts)
    out["report_date"] = _report_date(texts, out["fiscal_year_end"])
    # 요약 숫자는 재무상태표 · 손익계산서 쪽에서 먼저 찾고, 거기 없는 과목만 나머지 쪽에서 찾는다
    items = _pdf_items(_statement_lines(lines))
    for k, v in _pdf_items(lines).items():
        items.setdefault(k, v)
    out["figures"], out["figure_pages"] = {}, {}
    for name, (v, page) in items.items():
        for key, pat in dart.KEY_BS + dart.KEY_IS:
            if key not in out["figures"] and re.search(pat, name):
                out["figures"][key] = dart.signed(name, v)          # 영업손실 · 당기순손실 · 결손금은 음수
                out["figure_pages"][key] = f"{page}쪽"
                break
    for k, label in (("company", "회사명"), ("auditor", "감사인"), ("opinion", "감사의견"), ("framework", "회계기준")):
        if not out[k]:
            out["need_ai"].append(f"{label} 문형을 찾지 못했습니다")
    if not out["figures"]:
        out["need_ai"].append("재무제표 요약 숫자를 찾지 못했습니다")
    return out


# ---------------------------------------------------------------- 전기조서
def _rows(ws) -> list[tuple]:
    return [tuple(r) for r in ws.iter_rows(values_only=True)]


def _is_num(v) -> bool:
    return isinstance(v, (int, float)) and not isinstance(v, bool)


def _header(rows: list[tuple], need: list[tuple[str, ...]]) -> tuple[int, dict[str, int]] | None:
    """첫 15행에서 머리줄을 찾는다. need 는 (열쇠, 후보 낱말...) 목록. 모두 찾으면 (행 번호, {열쇠: 열})."""
    for i, r in enumerate(rows[:15]):
        cells = [dart.norm(str(v)) if v is not None else "" for v in r]
        cols = {}
        for key, *words in need:
            j = next((j for j, c in enumerate(cells) if c and any(w in c for w in words) and j not in cols.values()), None)
            if j is None:
                break
            cols[key] = j
        else:
            return i, cols
    return None


def _cell(r: tuple, j: int | None):
    return r[j] if j is not None and j < len(r) else None


def _materiality(wb) -> dict:
    labels = [("performance", ("수행중요성",)), ("trivial", ("명백히사소한", "명백하게사소한")),
              ("overall", ("재무제표전체중요성", "전체중요성", "재무제표전체에대한중요성"))]
    out, sheet_unit = {}, {}
    for ws in wb.worksheets:
        for r in _rows(ws):
            first = next(((j, v) for j, v in enumerate(r) if isinstance(v, str) and v.strip()), None)
            if not first:
                continue
            j, label = first
            n = dart.norm(label)
            if len(n) > 20:
                continue
            key = next((k for k, words in labels if any(w in n for w in words)), None)
            if not key or key in out:
                continue
            k = next((k for k in range(j + 1, len(r)) if _is_num(r[k])), None)
            if k is None:
                continue
            basis = next((r[x] for x in range(k + 1, len(r)) if isinstance(r[x], str) and r[x].strip()), None)
            # 단위(R8, 진단 #11): 금액 바로 뒤 칸이 「백만원」 · 「천원」 이면 그 단위, 없으면 시트 위쪽 「(단위: 백만원)」
            unit = _unit_of(basis) or sheet_unit.setdefault(ws.title, _sheet_unit(ws))
            mult = UNITS.get(unit, 1)
            row = {"amount": reader._int(float(r[k]) * mult), "basis": None if _unit_of(basis) else (basis.strip() if basis else None),
                   "sheet": ws.title}
            if unit and unit != "원":
                row["unit"] = unit
                row["amount_in_unit"] = reader._int(float(r[k]))
            out[key] = row
    return out


UNITS = {"원": 1, "천원": 1_000, "백만원": 1_000_000, "억원": 100_000_000}


def _unit_of(v) -> str | None:
    """'백만원' · '(단위: 천원)' · '단위:원' 같은 칸이면 단위 이름."""
    if not isinstance(v, str):
        return None
    m = re.fullmatch(r"\(?\s*(?:단위\s*[::]?\s*)?(원|천원|백만원|억원)\s*\)?", v.strip())
    return m.group(1) if m else None


def _sheet_unit(ws) -> str | None:
    """시트 첫 6행의 단위 표기."""
    for r in ws.iter_rows(values_only=True, max_row=6):
        for v in r:
            if isinstance(v, str) and "단위" in v:
                m = re.search(r"단위\s*[::]?\s*(원|천원|백만원|억원)", v)
                if m:
                    return m.group(1)
    return None


def _adjustments(wb, unadjusted: bool) -> list[dict]:
    out = []
    for ws in wb.worksheets:
        rows = _rows(ws)
        # 머리줄: 「내용 · 금액」, 또는 회계법인 수정 시트 「구분 · 적요 · 차변 · 금액 · 대변 · 금액」(R8, 진단 #19)
        h = _header(rows, [("text", "내용"), ("amount", "금액")]) or _header(rows, [("text", "적요"), ("amount", "금액")])
        if not h:
            continue
        i, c = h
        heads = [dart.norm(str(v)) if v is not None else "" for v in rows[i]]

        def col(*words):
            return next((j for j, x in enumerate(heads) if x and any(w in x for w in words)), None)

        cols = {"no": col("번호", "#"), "kind": col("구분"), "dr": col("차변"), "cr": col("대변"),
                "account": col("계정"), "booked": col("반영"), "reason": col("사유")}
        for r in rows[i + 1:]:
            text = _cell(r, c["text"])
            amt = _cell(r, c["amount"])
            if not isinstance(text, str) or not text.strip() or not _is_num(amt):
                continue
            if dart.norm(text) in ("합계", "계", "명백히사소한금액") or dart.norm(text).startswith("명백히사소한"):
                continue
            row = {"text": text.strip(), "amount": reader._int(float(amt)), "sheet": ws.title}
            for k, j in cols.items():
                v = _cell(r, j)
                if v is not None and str(v).strip():
                    row[k] = reader._int(float(v)) if k == "no" and _is_num(v) else str(v).strip()
            out.append(row)
    if not out:
        out = _firm_adjustments(wb)
    return out


def _firm_adjustments(wb) -> list[dict]:
    """감사 법인 WTB 의 AJE · RJE 시트(No. | 내역 | 차변 A/C · 금액 | 대변 A/C · 금액, 두 줄 머리). 머리줄에 「금액」 이 다음 줄에 있어
    위 머리줄 규칙으로는 못 읽는다. 읽기는 DSD 정산표 대사(audit/report/dsd_wtb.py)와 같은 함수를 쓴다(2026-10-19 가상 회사 세트)."""
    from .report import dsd_wtb

    out = []
    for ws in wb.worksheets:
        if not dsd_wtb.AJE_SHEET.match(ws.title):
            continue
        try:
            entries = dsd_wtb._firm_aje(ws)
        except Exception:  # noqa: BLE001  읽기 전용 시트 등은 건너뛴다
            continue
        for e in entries:
            dr = [x for x in e["lines"] if x[0] == "차변"]
            cr = [x for x in e["lines"] if x[0] == "대변"]
            if not dr and not cr:
                continue
            row = {"text": e["desc"] or f"수정분개 {e['no']}", "amount": reader._int(float(sum(x[2] for x in dr) or sum(x[2] for x in cr))),
                   "sheet": ws.title, "no": e["no"], "dr": " · ".join(x[1] for x in dr), "cr": " · ".join(x[1] for x in cr)}
            out.append(row)
    return out


FIRM_FS_SHEETS = {"BS": "BS", "IS": "IS", "PL": "IS"}


def _firm_fs_lines(wb) -> dict[str, list[dict]]:
    """감사 법인 WTB 의 BS · IS 시트(과목 | 당기 | 전기, 표시과목 줄). {시트: [{name, kind, final, company}]}.
    이 양식은 계정 단위 WBS · WIS 와 표시과목 단위 BS · IS 를 함께 둔다. 전기 재무제표 줄은 표시과목 단위인 BS · IS 에서 읽는다.
    WBS · WIS 를 리드 꼴로 읽으면 계정 이름과 표시과목이 섞인다(2026-10-19 가상 회사 세트). 읽기는 DSD 정산표 대사와 같은 함수다."""
    from .report import dsd_wtb

    out = {}
    for ws in wb.worksheets:
        kind = FIRM_FS_SHEETS.get(dart.norm(ws.title).upper())
        if not kind:
            continue
        try:
            got = dsd_wtb._firm_fs(ws)
        except Exception:  # noqa: BLE001  양식이 다르면 리드 꼴로 읽는다
            got = None
        # 결손금 · 영업손실처럼 이름으로 손실을 나타낸 줄은 감사보고서 판독과 같이 음수로 둔다(dart.signed)
        lines = [{"name": x["name"], "kind": kind, "final": dart.signed(x["name"], reader._int(float(x["final"]))), "company": None}
                 for x in got or [] if x.get("final") is not None and x["name"]]
        if lines:
            out[ws.title] = lines
    return out


def _wtb(wb) -> dict:
    out = {"accounts": [], "lines": [], "sheets": []}
    firm = _firm_fs_lines(wb)
    for title, lines in firm.items():
        out["lines"] += lines
        out["sheets"].append(title)
    for ws in wb.worksheets:
        if ws.title in firm:
            continue
        rows = _rows(ws)
        h = _header(rows, [("code", "계정코드", "코드"), ("name", "계정명", "계정과목"), ("final", "최종")])
        if h:
            i, c = h
            line_col = _header(rows, [("line", "표시과목")])
            for r in rows[i + 1:]:
                code = reader._code(_cell(r, c["code"]))
                v = _cell(r, c["final"])
                if code is None or not _is_num(v):
                    continue
                out["accounts"].append({"code": str(code), "name": str(_cell(r, c["name"]) or "").strip(),
                                        "line": str(_cell(r, line_col[1]["line"]) or "").strip() if line_col else None,
                                        "final": reader._int(float(v))})
            out["sheets"].append(ws.title)
            continue
        h = _header(rows, [("line", "표시과목"), ("final", "최종")])
        if h:
            i, c = h
            heads = [dart.norm(str(v)) if v is not None else "" for v in rows[i]]
            kind_col = next((j for j, x in enumerate(heads) if x == "구분"), None)
            comp_col = next((j for j, x in enumerate(heads) if "회사제시" in x), None)
            for r in rows[i + 1:]:
                name, v = _cell(r, c["line"]), _cell(r, c["final"])
                if not isinstance(name, str) or not name.strip() or not _is_num(v):
                    continue
                kind = str(_cell(r, kind_col) or "").strip().upper() or None
                comp = _cell(r, comp_col)
                out["lines"].append({"name": name.strip(), "kind": kind, "final": reader._int(float(v)),
                                     "company": reader._int(float(comp)) if _is_num(comp) else None})
            out["sheets"].append(ws.title)
            continue
        got = [] if firm else _lead(rows)
        if got:
            out["lines"] += got
            out["sheets"].append(ws.title)
    return out


LEAD_NAME = ("계정과목", "과목", "BS", "PL", "IS", "NAME", "계정")
LEAD_FINAL = ("AUDITED", "FINAL", "REVIEWED", "최종", "감사후", "수정후")
LEAD_COMPANY = ("PROPOSED", "PRELIMINARY", "회사제시", "감사전", "수정전")


def _lead(rows: list[tuple]) -> list[dict]:
    """회계법인 계정별 리드(R8, 진단 #19): 두 줄 머리 「계정과목 | 기말일 | 수정사항 | 기말일 | 전기말」 /
    「 | Proposed | 차변 | 대변 | Audited | Audited」 처럼 코드 열 없이 수정 전 · 수정 · 수정 후(Audited · Final · Reviewed) 열을 둔 표.
    수정 후 열이 둘 이상이면 왼쪽(당기)이다. [{name, kind: None, final, company}]"""
    for i in range(min(15, len(rows))):
        top = [dart.norm(str(v)).upper() if v is not None else "" for v in rows[i]]
        nxt = [dart.norm(str(v)).upper() if v is not None else "" for v in rows[i + 1]] if i + 1 < len(rows) else []
        name_col = next((j for j, c in enumerate(top) if c in LEAD_NAME), None)
        if name_col is None:
            continue
        both = [(j, (top[j] if j < len(top) else "") + "|" + (nxt[j] if j < len(nxt) else "")) for j in range(name_col + 1, max(len(top), len(nxt)))]
        final = next((j for j, c in both if any(w in c for w in LEAD_FINAL)), None)
        if final is None:
            continue
        comp = next((j for j, c in both if any(w in c for w in LEAD_COMPANY) and j < final), None)
        start = i + 2 if any(any(w in c for w in LEAD_FINAL + LEAD_COMPANY) for c in nxt) else i + 1
        out = []
        for r in rows[start:]:
            name, v = _cell(r, name_col), _cell(r, final)
            if not isinstance(name, str) or not name.strip() or not _is_num(v):
                continue
            n = dart.norm(name)
            if n in ("합계", "계", "총계", "소계") or n.upper() in ("TOTAL", "SUBTOTAL"):
                continue
            c = _cell(r, comp)
            out.append({"name": name.strip(), "kind": None, "final": reader._int(float(v)),
                        "company": reader._int(float(c)) if _is_num(c) else None})
        if out:
            return out
    return []


def read_prior_workpapers(d: Path, paths: list[str]) -> dict:
    """전기조서 엑셀들에서 전기 중요성 · 수정사항 · 미수정 왜곡 · 정산표 최종 금액을 읽는다.
    글 블록 라벨이 있는 계정 조서(파일 이름이 4000 영역으로 이어지고 Audit memo · 감사절차 · Conclusion 같은 라벨이 있는 손 조서)는
    여기서 읽지 않는다. Lead 표와 표본 표가 정산표 · 수정사항 머리줄과 겹쳐 전기 숫자로 읽히기 때문이다(예시 조서 25개 가운데 10개가
    그랬고 한 파일은 수정사항이 1,044줄로 읽혔다, 2026-10-12). 그 조서의 글은 audit/priorwp.py 가 읽어 _색인/전기조서.json 에 둔다.
    라벨이 없는 법인 리드 꼴(계정과목 · Proposed · 수정사항 · Audited 열, R8)은 앞에서처럼 정산표로 읽는다."""
    from . import priorwp

    out = {"materiality": {}, "adjustments": [], "unadjusted": [], "wtb": {"accounts": [], "lines": []}, "files": {}, "need_ai": []}
    skip = priorwp.text_workpapers(Path(d), paths)
    for rel in paths:
        p = Path(d) / rel
        if rel in skip:
            out["files"][rel] = [AREA_WP]
            continue
        if p.suffix.lower() not in reader.EXCEL:
            out["need_ai"].append(f"엑셀이 아닌 전기조서는 엔진이 읽지 않습니다: {rel}")
            continue
        try:
            wb = reader.open_plain(p)                  # 손 조서는 깨진 이름 정의가 있어도 열리게 이름 정의를 빼고 연다(2026-10-12)
        except Exception as e:  # noqa: BLE001  열지 못한 파일은 남기고 다음 파일로 간다
            out["need_ai"].append(f"전기조서를 열지 못했습니다({type(e).__name__}): {rel}")
            continue
        try:
            name = dart.norm(p.stem)
            got = []
            mat = _materiality(wb)
            if mat and not out["materiality"]:
                out["materiality"] = {k: dict(v, path=rel) for k, v in mat.items()}
                got.append("중요성")
            unadj = "미수정" in name or "8100A" in name or any("미수정" in ws.title for ws in wb.worksheets)
            adj = _adjustments(wb, unadj)
            if adj:
                (out["unadjusted"] if unadj else out["adjustments"]).extend(dict(a, path=rel) for a in adj)
                got.append("미수정 왜곡" if unadj else "수정사항")
            w = _wtb(wb)
            if w["accounts"] or w["lines"]:
                out["wtb"]["accounts"] += w["accounts"]
                out["wtb"]["lines"] += w["lines"]
                out["wtb"]["path"] = rel
                got.append("정산표")
            out["files"][rel] = got
            if not got:
                out["need_ai"].append(f"{PRIOR_TABLE_AI}: {rel}")
        finally:
            wb.close()
    return out


# ---------------------------------------------------------------- 다른 받은자료
# 업종 칸 옆에 오는 다른 칸 이름(2026-10-18 실제 회사 자료 부가세 신고서: 「업 종 코 드」 · 「해당국가」 를 업종으로 읽었다)
INDUSTRY_LABEL = re.compile(r"코드|국가|금액|번호|구분|일자|합계|^\(?\d")


def _industry_from_docs(d: Path) -> tuple[str, str] | None:
    """세무신고 PDF 의 '업종' 칸. (업종, '파일 n쪽')."""
    for kind in TAX_KINDS:
        for rel in figures.received(d, kind):
            p = Path(d) / rel
            if p.suffix.lower() != ".pdf":
                continue
            lines = _pdf_lines(p)
            for i, (page, t) in enumerate(lines):
                n = dart.norm(t)
                if n == "업종" and i + 1 < len(lines) and not INDUSTRY_LABEL.search(dart.norm(lines[i + 1][1])):
                    return lines[i + 1][1].strip(), f"{rel} {page}쪽"
                m = re.match(r"^업\s*종\s*[::]?\s*(\S.*)$", t)
                if m and not INDUSTRY_LABEL.search(dart.norm(m.group(1))):      # 「업 종 코 드」 칸 이름을 업종으로 읽지 않는다
                    return m.group(1).strip(), f"{rel} {page}쪽"
    return None


def _current_journal(d: Path, fy: date) -> str | None:
    docs = _idx(d, "문서목록.json", {"files": []})
    for f in docs["files"]:
        if f.get("role") == "received" and f.get("kind") == reader.JOURNAL and Path(f["path"]).suffix.lower() in reader.EXCEL:
            rng = reader.journal_range(f.get("facts") or [])
            if rng and rng[0].year == rng[1].year == fy.year:
                return f["path"]
    return None


def _code3(code) -> int | None:
    if code is None:
        return None
    return code if code < 1000 else int(str(code)[:3])


def top_parties(d: Path, fy: date, n: int = 10) -> dict:
    """당기 분개장에서 매출처(더존 401~430 대변 순액)와 매입처(251~252 대변) 상위 n 곳."""
    rel = _current_journal(d, fy)
    if not rel:
        return {"path": None, "sales": [], "purchases": [], "sales_total": 0, "purchases_total": 0}
    _, lines = reader._journal(Path(d) / rel)
    sales: dict[str, float] = {}
    buys: dict[str, float] = {}
    for _, _, dr, cr, party, _, code in lines:
        c = _code3(code)
        if c is None or not party:
            continue
        if 401 <= c <= 430:
            sales[party] = sales.get(party, 0) + cr - dr
        elif 251 <= c <= 252:
            buys[party] = buys.get(party, 0) + cr

    def top(m):
        total = sum(v for v in m.values() if v > 0)
        rows = sorted(((k, reader._int(v)) for k, v in m.items() if v > 0), key=lambda x: (-x[1], x[0]))
        return [{"party": k, "amount": v, "share": round(v / total, 4) if total else None} for k, v in rows[:n]], reader._int(total)

    s, st = top(sales)
    b, bt = top(buys)
    return {"path": rel, "sales": s, "purchases": b, "sales_total": st, "purchases_total": bt, "sales_count": len(sales),
            "purchases_count": len(buys)}


# ---------------------------------------------------------------- 당기 회사제시와 전기 비교
def _credit(code: int) -> bool:
    """더존 계정 대역에서 대변 성격(부채 · 자본 · 매출 · 영업외수익)."""
    return 251 <= code <= 430 or 901 <= code <= 950


def current_statement(d: Path) -> dict:
    """회사제시 시산표(마감 전)를 표시 금액으로. 이익잉여금에는 당기순이익을 더해 마감 후로 맞춘다. 합계는 더존 대역으로 센다."""
    rows = figures.current_tb(d)
    if not rows:
        return {"lines": {}, "totals": {}, "kinds": {}}
    lines: dict[str, int] = {}
    kinds: dict[str, str] = {}
    codes: dict[str, int] = {}
    for r in rows:
        c = _code3(int(r["code"]))
        sign = -1 if _credit(c) else 1
        lines[r["line"]] = lines.get(r["line"], 0) + sign * r["amount"]
        kinds.setdefault(r["line"], "BS" if c < 400 else "IS")
        codes.setdefault(r["line"], c)
    pl = [(_code3(int(r["code"])), r["amount"]) for r in rows]
    ni = -sum(a for c, a in pl if c >= 400)
    for name, c in codes.items():
        if 370 <= c <= 379 or "이익잉여금" in name:
            lines[name] += ni
            break
    t = {"자산총계": sum(a for c, a in pl if c < 251), "부채총계": -sum(a for c, a in pl if 251 <= c <= 330),
         "자본총계": -sum(a for c, a in pl if 331 <= c <= 399) + ni, "매출액": -sum(a for c, a in pl if 401 <= c <= 430),
         "매출총이익": -sum(a for c, a in pl if 401 <= c <= 499), "영업이익": -sum(a for c, a in pl if 401 <= c <= 899),
         "법인세비용차감전순이익": -sum(a for c, a in pl if 401 <= c <= 997), "당기순이익": ni}
    t["부채와자본총계"] = t["부채총계"] + t["자본총계"]
    return {"lines": lines, "totals": t, "kinds": kinds}


def big_changes(cur: dict, prior_fs: dict | None, threshold: int | None) -> dict:
    """표시과목 · 합계마다 전기 대비 증감. 큰 변동: |증감| ≥ 기준 금액(있으면) 이고 |증감률| ≥ 10% 또는 전기 없음."""
    if not prior_fs:
        return {"rows": [], "unmatched_current": sorted(cur["lines"]), "unmatched_prior": [], "threshold": threshold}
    prior = {**prior_fs.get("bs", {}), **prior_fs.get("is", {})}
    rows, seen = [], set()
    names = list(cur["lines"]) + [k for k in cur["totals"] if k not in cur["lines"]]
    for name in names:
        c = cur["lines"].get(name, cur["totals"].get(name))
        p = prior.get(name)
        if p is None and name in cur["totals"]:
            continue
        seen.add(name)
        diff = c - (p or 0)
        ratio = None if not p else diff / abs(p)
        # 전기 과목이 없으면 새 과목인지 이름만 다른지 엔진이 모른다. 큰 변동으로 세지 않고 따로 표시한다
        big = p is not None and (threshold is None or abs(diff) >= threshold) and (p == 0 or abs(ratio) >= 0.1) and diff != 0
        rows.append({"name": name, "kind": cur["kinds"].get(name) or ("IS" if name in prior_fs.get("is", {}) else "BS"),
                     "prior": p, "current": c, "diff": diff, "ratio": None if ratio is None else round(ratio, 4),
                     "total": name in cur["totals"] and name not in cur["lines"], "big": big, "prior_missing": p is None})
    return {"rows": rows, "unmatched_current": [r["name"] for r in rows if r["prior_missing"]],
            "unmatched_prior": [k for k in prior if k not in seen], "threshold": threshold}


# ---------------------------------------------------------------- 모으기
def _pick_report(d: Path) -> tuple[str | None, str | None]:
    """(회사가 준 전기 감사보고서 PDF, DART html). 여럿이면 이름 순 마지막(최근 연도)."""
    files = sorted(figures.received(d, PRIOR_REPORT))
    pdf = [p for p in files if p.lower().endswith(".pdf")]
    htm = [p for p in files if p.lower().endswith((".html", ".htm"))]
    return (pdf[-1] if pdf else None), (htm[-1] if htm else None)


def _dart_name(r: dict, src: str) -> str:
    key = r.get("rcp_no") or re.sub(r"[^0-9A-Za-z가-힣]+", "_", Path(src).stem)[:30]
    return f"DART_감사보고서_{key}.html"


def gather(d: Path, dart_target: str | None = None) -> dict:
    """받은자료와 DART 에서 시작 자료를 모은다(아직 쓰지 않는다)."""
    d = Path(d)
    case = _idx(d, "감사건.json")
    _fy_end(case)                    # 결산일이 없으면 여기서 멈춘다
    # 전기말 = 사업연도 시작일 전날(반기 · 짧은 사업연도는 감사건 fiscal_year_start, R9)
    prior_end = folder.periods(case)["prior_end"].isoformat()
    warnings: list[str] = []
    saved_dart = None
    if dart_target:
        html = dart.fetch(dart_target)
        r = dart.parse(html)
        dest = d / "00 받은자료" / "전기" / _dart_name(r, dart_target)
        src = Path(dart_target)
        if not (src.exists() and src.resolve() == dest.resolve()):
            dest.parent.mkdir(parents=True, exist_ok=True)
            dest.write_text(html, encoding="utf-8")
        saved_dart = dest.relative_to(d).as_posix()
        folder.scan(d)
    else:
        # 받은자료 목록을 새로 훑는다(내용 판독은 index read 몫). 요청 단계에서 전기 감사보고서 · 전기조서만 넣고 start 를 돌리면
        # 앞선 색인에 그 파일이 없어 「전기 감사보고서가 받은자료에 없습니다」 가 나왔다(2026-10-19 가상 회사 세트 단계 1)
        folder.scan(d, quiet_log=True)

    pdf, htm = _pick_report(d)
    rep = read_prior_report(d / pdf) if pdf else None
    drep = read_prior_report(d / htm) if htm else None
    prior_report = None
    if rep or drep:
        base = rep or drep
        src = pdf or htm
        prior_report = {k: base.get(k) for k in ("auditor", "opinion", "emphasis", "going_concern", "report_date",
                                                  "fiscal_year_end", "framework", "figures", "term")}
        prior_report.update(path=src, format=base["format"], figure_pages=base.get("figure_pages", {}),
                            need_ai=list(base["need_ai"]), company=base.get("company"))
        prior_report["basis"] = {k: ("엔진" if prior_report.get(k) is not None else "판독 필요")
                                 for k in ("auditor", "opinion", "emphasis", "report_date", "framework")}
        if prior_report["fiscal_year_end"] and prior_report["fiscal_year_end"] != prior_end:
            warnings.append(f"전기 감사보고서의 결산일({prior_report['fiscal_year_end']})이 전기 결산일({prior_end})과 다릅니다: {src}")

    dart_part = None
    if drep:
        r = drep["dart"]
        dart_part = {"path": htm, "source": r.get("source"), "rcp_no": r.get("rcp_no"), "corp_code": r.get("corp_code"),
                     "company": r.get("company"), "industry": r.get("industry"), "auditor": r.get("auditor"),
                     "opinion": r.get("opinion"), "framework": r.get("framework"), "emphasis": r.get("emphasis"),
                     "going_concern": r.get("going_concern"), "report_date": r.get("report_date"),
                     "fiscal_year_end": r.get("fiscal_year_end"), "unit": r.get("unit"), "term": r.get("term"),
                     "key_bs": {k: v[0] for k, v in r["key_bs"].items()}, "key_is": {k: v[0] for k, v in r["key_is"].items()},
                     "bs_items": len(r["bs"]), "is_items": len(r["is"]), "overview": r.get("overview"), "need_ai": r["need_ai"]}
        if rep and prior_report:
            # 회사가 준 감사보고서에서 못 찾은 글 항목은 같은 보고서의 DART 공시에서 엔진이 읽은 값으로 채운다
            filled = []
            for k in ("auditor", "opinion", "report_date", "framework"):
                if prior_report.get(k) is None and drep.get(k):
                    prior_report[k] = drep[k]
                    prior_report["basis"][k] = "엔진"
                    filled.append(k)
            if filled:
                prior_report["filled_from_dart"] = filled
                labels = [NEED_LABEL.get(k, k) for k in filled]
                prior_report["need_ai"] = [n for n in prior_report["need_ai"] if not any(n.startswith(x) for x in labels)]
        if rep:
            diffs = []
            for k in ("opinion", "auditor"):
                if rep.get(k) and drep.get(k) and dart.norm(rep[k]) != dart.norm(drep[k]):
                    diffs.append(f"{k}: 감사보고서 {rep[k]} · DART {drep[k]}")
            for k, v in rep["figures"].items():
                dv = drep["figures"].get(k)
                if dv is not None and dv != v:
                    diffs.append(f"{k}: 감사보고서 {v:,} · DART {dv:,}")
            dart_part["diffs_vs_report"] = diffs
            warnings += [f"전기 감사보고서와 DART 가 다릅니다. {x}" for x in diffs]

    wps_paths = sorted(figures.received(d, PRIOR_WP))
    pw = read_prior_workpapers(d, wps_paths) if wps_paths else None

    # 전기 재무제표: 받은자료 엑셀 → 전기조서 정산표 → DART → 감사보고서 요약
    prior_fs = None
    xl = figures.prior_excel(d)
    if xl and (xl["bs"] or xl["is"]):
        prior_fs = {"as_of": xl.get("as_of"), "bs": xl["bs"], "is": xl["is"], "source": xl["path"], "basis": "전기 재무제표 엑셀"}
    elif pw and pw["wtb"]["lines"]:
        ls = pw["wtb"]["lines"]
        prior_fs = {"as_of": prior_end, "bs": {x["name"]: x["final"] for x in ls if x["kind"] != "IS"},
                    "is": {x["name"]: x["final"] for x in ls if x["kind"] == "IS"}, "source": pw["wtb"]["path"],
                    "basis": "전기조서 8100B 최종 열"}
    elif drep and (drep["dart"]["bs"] or drep["dart"]["is"]):
        prior_fs = {"as_of": drep.get("fiscal_year_end") or prior_end, "bs": drep["dart"]["bs"], "is": drep["dart"]["is"],
                    "source": htm, "basis": "DART 감사보고서 재무제표"}
    elif rep and rep["figures"]:
        f = rep["figures"]
        prior_fs = {"as_of": rep.get("fiscal_year_end") or prior_end,
                    "bs": {k: v for k, v in f.items() if k in dict(dart.KEY_BS)},
                    "is": {k: v for k, v in f.items() if k in dict(dart.KEY_IS)}, "source": pdf, "basis": "전기 감사보고서 요약"}

    # 회사 정보
    name = case["company"]["name"]
    basis = ["폴더 이름"]      # 감사건의 앞선 basis 를 이어 쓰지 않는다(다시 돌릴 때 쌓이지 않게)
    pairs = ([("전기 감사보고서", rep.get("company"))] if rep else []) + ([("DART", drep.get("company"))] if drep else [])
    for label, x in pairs:
        if not x:
            continue
        if corp_name(x) == corp_name(name):          # 「주식회사 · (주) · ㈜」 표기와 공백 차이는 같은 회사로 본다
            basis.append(f"{label} 회사명 일치")
        else:
            warnings.append(f"감사 폴더 회사명({name})과 전기 감사보고서 · DART 회사명({x})이 다릅니다. 같은 회사인지 확인해 주십시오")
    industry, industry_basis = None, None
    if dart_part and dart_part.get("industry"):
        industry, industry_basis = dart_part["industry"], "DART 기업개황 업종명"
    else:
        found = _industry_from_docs(d)
        if found:
            industry, industry_basis = found[0], f"세무신고 업종 칸({found[1]})"
    corp_code = dart_part.get("corp_code") if dart_part else None
    if corp_code:
        basis.append("DART 고유번호")
    if industry_basis:
        basis.append(industry_basis.split("(")[0])
    company = {"name": name, "dart_corp_code": corp_code, "industry": industry, "industry_basis": industry_basis,
               "framework": (prior_report or {}).get("framework") or (dart_part or {}).get("framework"),
               "basis": " · ".join(dict.fromkeys(basis)), "overview": (dart_part or {}).get("overview")}

    need = []
    if prior_report:
        need += [f"{prior_report['path']}: {x}" for x in prior_report["need_ai"]]
    else:
        need.append("전기 감사보고서가 받은자료에 없습니다(초도감사면 DART 로 받습니다)")
    if pw:
        need += pw["need_ai"]
    elif case.get("engagement_kind") == "계속감사":
        need.append("전기조서가 받은자료에 없습니다")
    if not industry:
        need.append("업종을 찾지 못했습니다(DART 기업개황 · 세무신고 업종 칸 없음)")

    return {"prior_end": prior_end, "prior_report": prior_report, "dart": dart_part, "prior_workpapers": pw,
            "prior_fs": prior_fs, "company": company, "need_ai": need, "warnings": warnings, "saved_dart": saved_dart,
            "term": term_of(d, prior_report, dart_part)}


def term_of(d: Path, prior_report: dict | None, dart_part: dict | None) -> dict | None:
    """당기 기수(2026-10-06). 작년 감사 폴더 감사건의 기수 → 전기 감사보고서 · DART 의 「제 N 기」 순서로 전기 기수를 찾고
    당기 = 전기 + 1 로 둔다. 못 찾으면 None 이고, 회계사가 8600 「회사 정보」 시트에 적는다(엔진은 추측하지 않는다)."""
    pe = prior.prior_engagement(d)
    if pe is not None:
        t = (_idx(pe, "감사건.json", {}) or {}).get("term") or {}
        if isinstance(t, dict) and isinstance(t.get("current"), int):
            return {"current": t["current"] + 1, "prior": t["current"], "basis": f"작년 감사 폴더 감사건 「제 {t['current']} 기」"}
    for src, label in ((prior_report, "전기 감사보고서"), (dart_part, "DART 감사보고서")):
        n = (src or {}).get("term")
        if isinstance(n, int):
            return {"current": n + 1, "prior": n, "basis": f"{label}({(src or {}).get('path')}) 「제 {n} 기」"}
    return None


# ---------------------------------------------------------------- AI · 사람 판독
NEED_LABEL = {"auditor": "감사인", "opinion": "감사의견", "industry": "업종", "framework": "회계기준", "report_date": "감사보고서일"}


def _merge_ai(data: dict) -> None:
    """엔진이 비워 둔 글 항목만 AI · 사람 판독으로 채운다. 엔진 값은 덮지 않는다. 근거는 basis 에 남긴다."""
    for x in data.get("ai", []):
        sect, key = x["field"].split(".")
        part = data.get(sect)
        if not isinstance(part, dict):
            continue
        if sect == "prior_report":
            b = part.setdefault("basis", {})
            if part.get(key) is not None and b.get(key) == "엔진":
                continue
            part[key] = x["value"]
            b[key] = x["basis"]
            label = NEED_LABEL.get(key)
            if label:
                part["need_ai"] = [n for n in part.get("need_ai", []) if not n.startswith(label)]
        else:
            if part.get(key) is not None and not str(part.get("industry_basis") or "").startswith(("AI", "사람")):
                continue
            part[key] = x["value"]
            part["industry_basis"] = f"{x['basis']} 판독({x.get('source_page') or '쪽 없음'})"
        label = NEED_LABEL.get(key)
        if label:
            data["need_ai"] = [n for n in data.get("need_ai", []) if label not in n]


def apply(d: Path, patch: dict, now: str | None = None) -> dict:
    """{"fields": [{"field": "prior_report.auditor", "value": "...", "basis": "AI", "source_page": "1쪽"}]}
    글 항목만 받는다. 금액으로 보이는 숫자가 있으면 아무것도 쓰지 않고 거부한다."""
    d = Path(d)
    data = _idx(d, START_FILE)
    if data is None:
        raise IntakeError("시작자료.json 이 없습니다. 먼저 python -m audit start <감사 폴더> 를 돌려 주십시오")
    items = patch.get("fields") if isinstance(patch, dict) else None
    if not isinstance(items, list) or not items:
        raise index.PatchRejected(['patch 는 {"fields": [...]} 꼴이고 항목이 하나 이상 있어야 합니다'])
    probs = []
    for i, x in enumerate(items, 1):
        where = f"{i}번째 항목"
        if not isinstance(x, dict) or x.get("field") not in AI_FIELDS:
            probs.append(f"{where}: 넣을 수 있는 항목은 {', '.join(AI_FIELDS)} 입니다")
            continue
        if x.get("basis") not in ("AI", "사람"):
            probs.append(f"{where}: basis 는 AI 또는 사람 이어야 합니다")
        t = AI_FIELDS[x["field"]]
        v = x.get("value")
        if not isinstance(v, t):
            probs.append(f"{where}: {x['field']} 값의 꼴이 맞지 않습니다")
            continue
        if x["field"] == "prior_report.opinion" and v not in dart.OPINIONS:
            probs.append(f"{where}: 의견은 {' · '.join(dart.OPINIONS)} 가운데 하나입니다")
        if x["field"] == "prior_report.report_date" and not re.fullmatch(r"\d{4}-\d{2}-\d{2}", v):
            probs.append(f"{where}: 날짜는 2025-03-14 꼴입니다")
        if isinstance(v, str) and x["field"] != "prior_report.report_date":
            amt = index.amount_in_text(v)
            if amt:
                probs.append(f"{where}: 금액으로 보이는 숫자 '{amt}' 가 있습니다. 숫자는 엔진 판독만 씁니다")
    if probs:
        raise index.PatchRejected(probs)
    keep = {x["field"]: x for x in data.get("ai", [])}
    for x in items:
        keep[x["field"]] = {"field": x["field"], "value": x["value"], "basis": x["basis"], "source_page": x.get("source_page")}
    data["ai"] = list(keep.values())
    folder._write(d / "_색인" / START_FILE, data)
    return build(d, now=now, reuse=True)


# ---------------------------------------------------------------- 색인 쓰기
def _doc_facts(d: Path, data: dict) -> list[str]:
    """시작 자료로 읽은 받은자료에 엔진 사실을 붙인다(AI 사실은 둔다)."""
    docs = _idx(d, "문서목록.json")
    by = {f["path"]: f for f in docs["files"]}
    touched = []

    def put(rel, facts):
        f = by.get(rel)
        if not f or not facts:
            return
        f["facts"] = facts + [x for x in f.get("facts") or [] if x.get("basis") != "엔진"]
        touched.append(rel)

    pr = data.get("prior_report")
    if pr and pr.get("basis"):
        fs = []
        for k, label in (("opinion", "전기 감사의견"), ("auditor", "전기 감사인"), ("report_date", "전기 감사보고서일")):
            if pr.get(k) and pr["basis"].get(k) == "엔진":
                fs.append({"text": f"{label} {pr[k]}", "basis": "엔진", "value": None})
        if pr.get("emphasis") is not None and pr["basis"].get("emphasis") == "엔진":
            fs.append({"text": "강조사항 문단 " + ("있음" if pr["emphasis"] else "없음"), "basis": "엔진", "value": None})
        for k, v in (pr.get("figures") or {}).items():
            f = {"text": f"{k} {_won(v)}", "basis": "엔진", "value": v}
            if pr.get("figure_pages", {}).get(k):
                f["source_page"] = pr["figure_pages"][k]
            fs.append(f)
        put(pr["path"], fs)
    dp = data.get("dart")
    if dp and dp.get("path") != (pr or {}).get("path"):
        fs = [{"text": f"DART 감사의견 {dp['opinion']}", "basis": "엔진", "value": None}] if dp.get("opinion") else []
        if dp.get("auditor"):
            fs.append({"text": f"DART 감사인 {dp['auditor']}", "basis": "엔진", "value": None})
        for k in ("자산총계", "매출액", "당기순이익"):
            v = (dp.get("key_bs") or {}).get(k, (dp.get("key_is") or {}).get(k))
            if v is not None:
                fs.append({"text": f"DART {k} {_won(v)}", "basis": "엔진", "value": v})
        put(dp["path"], fs)
    pw = data.get("prior_workpapers")
    if pw:
        mat = pw.get("materiality") or {}
        names = {"overall": "전기 재무제표 전체 중요성", "performance": "전기 수행중요성", "trivial": "전기 명백히 사소한 금액"}
        by_file: dict[str, list] = {}
        for k, v in mat.items():
            by_file.setdefault(v["path"], []).append({"text": f"{names[k]} {_won(v['amount'])}", "basis": "엔진", "value": v["amount"],
                                                      "source_page": f"{v['sheet']} 시트"})
        for key, label in (("adjustments", "전기 수정사항"), ("unadjusted", "전기 미수정 왜곡")):
            for p in {a["path"] for a in pw.get(key, [])}:
                rows = [a for a in pw[key] if a["path"] == p]
                total = sum(a["amount"] for a in rows)
                by_file.setdefault(p, []).append({"text": f"{label} {len(rows)}건, 합계 {_won(total)}", "basis": "엔진", "value": total})
        if pw["wtb"].get("path"):
            n = len(pw["wtb"]["accounts"])
            by_file.setdefault(pw["wtb"]["path"], []).append({"text": f"전기 정산표 계정 {n}개 · 표시과목 {len(pw['wtb']['lines'])}개", "basis": "엔진", "value": n})
        for p, fs in by_file.items():
            put(p, fs)
    folder._write(d / "_색인" / "문서목록.json", docs)
    return touched


def _update_case(d: Path, data: dict, at: str, wrote: list[str], read: list[str]) -> None:
    case = _idx(d, "감사건.json")
    c = data["company"]
    basis = c.get("basis") or "폴더 이름"
    if str(c.get("industry_basis") or "").startswith(("AI", "사람")):
        basis += f" · 업종 {c['industry_basis'].split()[0]} 판독" + (" (확인 전)" if c["industry_basis"].startswith("AI") else "")
    case["company"] = {"name": c["name"], "dart_corp_code": c.get("dart_corp_code"), "industry": c.get("industry"), "basis": basis}
    if data.get("term"):                 # 기수는 찾았을 때만 쓴다. 못 찾았으면 앞선 값(회계사가 고친 값 포함)을 둔다
        case["term"] = data["term"]
    got = [x for x, ok in (("전기 감사보고서", data.get("prior_report")), ("전기조서", data.get("prior_workpapers")),
                           ("DART", data.get("dart")), ("전기 재무제표", data.get("prior_fs"))) if ok]
    what = f"시작 자료를 읽었습니다({' · '.join(got) or '읽은 자료 없음'}). {prior.label(data.get('prior_source'))}. 조서 {len(wrote)}개를 만들었습니다"
    if data.get("need_ai"):
        what += f". 판독이 필요한 것 {len(data['need_ai'])}건"
    case["log"].insert(0, {"at": at, "who": "시작 자료", "what": what, "read": read, "wrote": wrote + ["_색인/시작자료.json", "_색인/감사건.json"]})
    folder._write(d / "_색인" / "감사건.json", case)


# ---------------------------------------------------------------- 조서
def _may_write(path: Path, made: dict, force: bool) -> bool:
    """없거나, 엔진이 만든 뒤 아무도 손대지 않은 파일(해시가 같음)이면 다시 쓴다. force 면 언제나."""
    if force or not path.exists():
        return True
    return made.get(path.name) == _sha(path)


def _rel(d: Path, p: Path) -> str:
    return p.relative_to(d).as_posix()


def _company_rows(b: wp.Book, ws, row: int, data: dict, case: dict) -> int:
    c = data["company"]
    pr = data.get("prior_report") or {}
    row = b.head(ws, row, ["항목", "내용", "출처"])
    rows = [("회사명", c["name"], c.get("basis")),
            ("DART 고유번호", c.get("dart_corp_code") or "없음", "DART" if c.get("dart_corp_code") else "DART 링크를 주면 채웁니다"),
            ("업종", c.get("industry") or "판독 필요", c.get("industry_basis") or ""),
            ("결산일", case.get("fiscal_year_end"), "감사건"),
            ("감사 구분", case.get("engagement_kind"), "감사건"),
            ("전기 회계기준", c.get("framework") or "판독 필요", pr.get("path") or ""),
            ("회사제시 판", case.get("company_version") or "없음", "회사제시 폴더")]
    for k, v, src in rows:
        b.put(ws, row, 1, k)
        b.put(ws, row, 2, v, flag=v in ("판독 필요",), wrap=True)
        b.put(ws, row, 3, src, wrap=True, color=wp.MUTED)
        row += 1
    return row + 1


def _prior_summary_rows(b: wp.Book, ws, row: int, data: dict) -> int:
    fs = data.get("prior_fs")
    row = b.section(ws, row, "전기 재무 요약 (엔진, 표시 금액)")
    row = b.head(ws, row, ["과목", "전기 금액", "출처"])
    allf = {**(fs or {}).get("bs", {}), **(fs or {}).get("is", {})}
    pr_f = (data.get("prior_report") or {}).get("figures") or {}
    for k in KEY_FIGS:
        v = allf.get(k, pr_f.get(k))
        src = (fs or {}).get("source") if k in allf else ((data.get("prior_report") or {}).get("path") if k in pr_f else "없음")
        b.put(ws, row, 1, k)
        b.put(ws, row, 2, v, fmt=wp.WON)
        b.put(ws, row, 3, src, color=wp.MUTED, wrap=True)
        row += 1
    return row + 1


def _checklist(b: wp.Book, ws, row: int, no: str) -> int:
    items = json.loads((Path(__file__).resolve().parent.parent / "tools" / "proto_data" / "kicpa_checklists.json").read_text(encoding="utf-8"))[no]
    row = b.section(ws, row, items["title"] + " (한공회 감사조서 서식 문항)")
    row = b.head(ws, row, ["항목", "조서번호", "수행자", "수행 결과·비고"])
    for n, (text, ref) in enumerate(items["items"], 1):
        numbered = bool(re.match(r"^\d+[.,]", text.strip()))
        b.put(ws, row, 1, text, wrap=True, bold=numbered)
        b.put(ws, row, 2, ref or None)
        if numbered:
            b.ask(ws, row, 3, f"점검 {n} 수행자", rule="optional")
            b.ask(ws, row, 4, f"점검 {n} 수행 결과", rule="required")
        ws.row_dimensions[row].height = 15 * max(1, min(6, len(text) // 60 + 1))
        row += 1
    return row + 1


def make_1100(d: Path, data: dict, case: dict) -> wp.Book:
    b = wp.Book(d, "1100", standard="감사기준서 210 · 220 · 한공회 서식 1100")
    ws, row = b.sheet("1100", [34, 44, 40, 40])
    row = b.section(ws, row, "회사 개황 (엔진)")
    row = _company_rows(b, ws, row, data, case)
    row = _prior_summary_rows(b, ws, row, data)
    pr = data.get("prior_report") or {}
    row = b.section(ws, row, "전기 감사 (전기 감사보고서 판독)")
    row = b.head(ws, row, ["항목", "내용", "근거"])
    for k, label in (("auditor", "전기 감사인"), ("opinion", "전기 감사의견"), ("emphasis", "강조사항 문단"),
                     ("going_concern", "계속기업 관련 중요한 불확실성"), ("report_date", "전기 감사보고서일")):
        v = pr.get(k)
        if isinstance(v, bool):
            v = "있음" if v else "없음"
        basis = (pr.get("basis") or {}).get(k, "엔진" if v is not None else "판독 필요")
        b.put(ws, row, 1, label)
        b.put(ws, row, 2, v if v is not None else "판독 필요", flag=v is None, wrap=True)
        b.put(ws, row, 3, f"{basis} · {pr.get('path') or '전기 감사보고서 없음'}", color=wp.MUTED, wrap=True)
        row += 1
    dp = data.get("dart")
    if dp:
        for k, label in (("auditor", "DART 감사인"), ("opinion", "DART 감사의견")):
            b.put(ws, row, 1, label)
            b.put(ws, row, 2, dp.get(k) or "판독 필요", flag=not dp.get(k))
            b.put(ws, row, 3, f"엔진 · {dp.get('source') or dp['path']}", color=wp.MUTED, wrap=True)
            row += 1
        for x in dp.get("diffs_vs_report") or []:
            b.put(ws, row, 1, "감사보고서와 DART 차이")
            b.put(ws, row, 2, x, flag=True, wrap=True)
            row += 1
    if pr.get("opinion") not in (None, "적정") or pr.get("emphasis") or pr.get("going_concern"):
        ws.cell(row, 1, "전기 의견이 적정이 아니거나 강조사항 · 계속기업 불확실성이 있습니다. 계약 수락 판단에 반영해 주십시오").font = wp.font(size=9, color=wp.RED)
        row += 1
    row += 1
    row = b.section(ws, row, "감사인 교체")
    row = b.head(ws, row, ["항목", "내용", "근거"])
    b.put(ws, row, 1, "감사 구분(감사건)")
    b.put(ws, row, 2, case.get("engagement_kind"))
    b.put(ws, row, 3, "초도감사면 전기 감사인과 다른 감사인입니다", color=wp.MUTED, wrap=True)
    row += 1
    b.put(ws, row, 1, "전기 감사인")
    b.put(ws, row, 2, pr.get("auditor") or "판독 필요", flag=not pr.get("auditor"))
    row += 1
    b.put(ws, row, 1, "감사인 교체 여부(예 · 아니오)")
    b.ask(ws, row, 2, "감사인 교체 여부", rule="yesno")
    row += 1
    b.put(ws, row, 1, "교체라면 전임 감사인과 커뮤니케이션 결과")
    b.ask(ws, row, 2, "전임 감사인 커뮤니케이션", rule="optional")
    row += 2
    pw = data.get("prior_workpapers") or {}
    row = b.section(ws, row, "전기 수정사항 · 미수정 왜곡 (전기조서)")
    row = b.head(ws, row, ["구분", "내용", "금액", "출처"])
    for key, label in (("adjustments", "수정사항"), ("unadjusted", "미수정 왜곡")):
        for a in pw.get(key, []):
            b.put(ws, row, 1, label)
            b.put(ws, row, 2, a["text"], wrap=True)
            b.put(ws, row, 3, a["amount"], fmt=wp.WON)
            b.put(ws, row, 4, a["path"], color=wp.MUTED, wrap=True)
            row += 1
    if not pw.get("adjustments") and not pw.get("unadjusted"):
        b.put(ws, row, 1, "없음" if pw else "전기조서 없음")
        row += 1
    row += 1
    row = _checklist(b, ws, row, "1100")
    row = b.section(ws, row, "계약 수락 · 유지 판단 (감사인)")
    b.put(ws, row, 1, "위험 요인 메모")
    b.ask(ws, row, 2, "위험 요인 메모", rule="optional")
    row += 1
    b.conclusion(ws, row, 4, label="계약 수락 · 유지 결론")
    return b


def make_2100(d: Path, data: dict, case: dict) -> wp.Book:
    b = wp.Book(d, "2100", standard="감사기준서 315 · 한공회 서식 2100")
    fy = _fy_end(case)
    ws, row = b.sheet("기업이해", [30, 44, 40, 36])
    row = b.section(ws, row, "회사 개황 (엔진)")
    row = _company_rows(b, ws, row, data, case)
    ov = data["company"].get("overview")
    if ov:
        row = b.section(ws, row, "회사의 개요 (DART 주석 1 원문 앞부분)")
        ws.merge_cells(start_row=row, start_column=1, end_row=row + 2, end_column=4)
        b.put(ws, row, 1, ov, wrap=True)
        row += 4
    row = _prior_summary_rows(b, ws, row, data)
    from . import priorwp

    was = {x["label"]: x["value"] for x in (priorwp.general_inputs(d, "2100") or {}).get("inputs", []) if x["sheet"] == "기업이해"}
    row = b.section(ws, row, "사업 이해 (감사인)" + (". 셋째 칸은 작년 조서에 적은 내용(참고)" if was else ""))
    for label in ("사업 내용 · 산업 환경", "규제 · 외부 요인", "회계정책 선택과 변경"):
        b.put(ws, row, 1, label)
        b.ask(ws, row, 2, label, rule="required")
        if was.get(label):
            b.put(ws, row, 3, was[label], wrap=True, color=wp.MUTED)
        row += 1
    row += 1
    row = _checklist(b, ws, row, "2100")
    b.conclusion(ws, row, 4, label="기업 이해 결론")

    tp = data["parties"]
    ws2, row = b.sheet("주요 거래처", [8, 28, 20, 12])
    ws2.cell(6, 1, f"출처: {tp.get('path') or '당기 분개장 없음'} (매출처는 더존 401~430 대변 순액, 매입처는 251~252 대변 합)").font = wp.font(size=9, color=wp.MUTED)
    for key, label, total in (("sales", "매출처 상위 10", "sales_total"), ("purchases", "매입처 상위 10", "purchases_total")):
        row = b.section(ws2, row, f"{label} (전체 {tp.get(key + '_count', 0)}곳)")
        row = b.head(ws2, row, ["순위", "거래처", "금액", "비중"])
        first = row
        for n, x in enumerate(tp.get(key, []), 1):
            b.put(ws2, row, 1, n)
            b.put(ws2, row, 2, x["party"])
            b.put(ws2, row, 3, x["amount"], fmt=wp.WON)
            b.put(ws2, row, 4, x["share"], fmt=wp.PCT)
            row += 1
        b.put(ws2, row, 2, f"전체 합계({label.split()[0]})", bold=True)
        b.put(ws2, row, 3, tp.get(total) or 0, fmt=wp.WON, bold=True)
        if tp.get(key):
            b.verify(f"{label} 합계 재계산", f"=SUM('주요 거래처'!C{first}:C{row - 1})", sum(x["amount"] for x in tp[key]))
        row += 2
    b.put(ws2, row, 1, "메모")
    b.ask(ws2, row, 2, "주요 거래처 메모(특수관계 · 집중도)", rule="optional")

    _carry_sheet(b, d, data)

    ch = data["changes"]
    ws3, row = b.sheet("전기 대비 변동", [30, 18, 18, 18, 10, 10, 36])
    thr = ch.get("threshold")
    ws3.cell(6, 1, ("큰 변동: |증감| ≥ " + (f"{thr:,}원(전기 수행중요성)" if thr else "기준 금액 없음") +
                    " 이고 |증감률| ≥ 10%. 전기 과목 없음: 새 과목이거나 전기와 이름이 다른 과목(매핑 확인). "
                    "당기는 회사제시 시산표(이익잉여금은 당기순이익을 더한 마감 후)")).font = wp.font(size=9, color=wp.MUTED)
    row = b.head(ws3, row, ["과목", f"전기({data['prior_end']})", f"당기({case['fiscal_year_end']}, 회사제시)", "증감", "증감률", "큰 변동", "회사 설명 · 감사인 메모"])
    for x in ch["rows"]:
        b.put(ws3, row, 1, x["name"], bold=x["total"])
        b.put(ws3, row, 2, x["prior"], fmt=wp.WON)
        b.put(ws3, row, 3, x["current"], fmt=wp.WON)
        b.put(ws3, row, 4, f"=C{row}-N(B{row})", fmt=wp.WON)
        b.put(ws3, row, 5, f'=IF(N(B{row})=0,"",D{row}/ABS(B{row}))', fmt=wp.PCT)
        mark = "큰 변동" if x["big"] else ("전기 과목 없음" if x["prior_missing"] and x["current"] else "")
        b.put(ws3, row, 6, mark, flag=bool(mark))
        if mark:
            b.ask(ws3, row, 7, f"{x['name']} 변동 설명", rule="optional")
        b.verify(f"{x['name']} 증감", f"='전기 대비 변동'!D{row}", x["diff"])
        row += 1
    row += 1
    if ch.get("unmatched_prior"):
        ws3.cell(row, 1, "전기 과목 가운데 당기 표시과목과 이름이 맞지 않은 것(계정 매핑은 분석적 검토 단계에서): " + ", ".join(ch["unmatched_prior"])).font = wp.font(size=9, color=wp.RED)
        row += 1
    if ch.get("unmatched_current"):
        ws3.cell(row, 1, "당기 표시과목 가운데 전기 과목에 없는 것: " + ", ".join(ch["unmatched_current"])).font = wp.font(size=9, color=wp.RED)
    priorwp.reference_sheet(b, d, "2100")       # 작년 2100 에 회계사가 적은 내용(참고 시트, 2026-10-12)
    return b


CARRY_SHEET = "전기에서 이어진 사항"


def _carry_sheet(b: wp.Book, d: Path, data: dict) -> None:
    """2100 「전기에서 이어진 사항」(R7). 작년 감사 폴더 · 전임 전기조서 · 전기 감사보고서에서 이어받을 사항과
    회계사 판단 기입란(당기 이슈로 볼지). 엔진은 당기 이슈로 정하지 않는다. 앞서 적은 판단은 같은 항목 이름으로 이어받는다."""
    from .report.base import prev_inputs

    keep = prev_inputs(wp.path_for(d, "2100"))
    ps = data.get("prior_source") or {}
    ws, row = b.sheet(CARRY_SHEET, [6, 22, 56, 36, 16, 40])
    ws.cell(6, 1, prior.label(ps) + ". 미수정 왜곡 · 계속기업 · 강조사항 · 의견 변형 · 열린 채 종결된 이슈를 옮긴다(감사기준서 510 문단 9 · 450 문단 11(b))"
            ).font = wp.font(size=9, color=wp.MUTED)
    row = b.head(ws, row, ["번호", "구분", "내용", "출처", "당기 이슈로 볼지", "판단 근거"])
    carry = ps.get("carry") or []
    if not carry:
        b.put(ws, row, 3, "전기 자료 없음" if not ps or ps.get("situation") == prior.SITUATIONS[2] and not ps.get("opinion")
              else "전기에서 이어진 사항 없음", color=wp.MUTED)
        return
    for k, c in enumerate(carry, 1):
        b.put(ws, row, 1, k)
        b.put(ws, row, 2, c["what"], wrap=True)
        b.put(ws, row, 3, c["text"], wrap=True)
        b.put(ws, row, 4, c["source"], wrap=True, color=wp.MUTED)
        for col, lab, rule in ((5, f"이어진 사항 {k} 당기 이슈 여부", "yesno"), (6, f"이어진 사항 {k} 판단 근거", "optional")):
            b.ask(ws, row, col, lab, rule=rule, value=keep.get((CARRY_SHEET, lab)))
        ws.row_dimensions[row].height = 30
        row += 1
    ws.cell(row + 1, 1, "엔진은 이어받은 사항으로 이슈를 만들지 않습니다. 「예」로 판단한 사항은 이슈 대장과 대응 조서에 반영해 주십시오").font = wp.font(size=9, color=wp.MUTED)


def make_pbc(d: Path, data: dict) -> tuple[wp.Book, list[dict]]:
    """요청자료 조서. 시트 네 개는 실제 초도감사 요청자료 양식(audit/pbcform.py)이다. 받음 · 빠짐은 엔진 18건(pbc_match.yaml)만 판정한다."""
    from . import pbcform

    rows = pbc_status(d)
    b = wp.Book(d, "PBC", standard="감사 시작 전 요청자료 목록 · 받음은 폴더에 파일이 있는지로 엔진이 정한다")
    pbcform.write(b, d, rows)
    ws = b.wb.worksheets[0]
    row = ws.max_row + 3
    # 이슈 대응 자료와 분석적 검토가 대사하지 못해 요청하는 자료(분석.json requests, 2026-10-18)를 함께 적는다
    issue = [m for m in data.get("missing", []) if m.get("issue") or m.get("source") == "분석" or m.get("detail")]
    ws.cell(row, 2, "이슈 대응에 필요한 추가 자료 (지휘가 이슈.json · 분석.json 에서 정함)").font = wp.font(size=11, bold=True, color=wp.NAVY)
    row = b.head(ws, row + 1, ["이슈", "구분", "요청자료명", "요청세부내역", "", "요청한 날", "상태"], col=2)
    for m in issue:
        if m.get("issue"):
            b.put(ws, row, 2, f"이슈 {m['issue']}")
            b.put(ws, row, 4, "이슈 대응 자료")
            b.put(ws, row, 5, m["item"], wrap=True)
        else:
            b.put(ws, row, 2, "분석")
            b.put(ws, row, 4, "분석적 검토 대사 자료" if m.get("source") == "분석" else m["item"], wrap=True)
            b.put(ws, row, 5, m["item"] if m.get("source") == "분석" else "; ".join(m.get("detail") or []), wrap=True)
        b.put(ws, row, 3, m.get("workpaper"))
        b.put(ws, row, 7, m.get("requested_at") or "요청 전")
        b.put(ws, row, 8, "빠짐", flag=True)
        row += 1
    if not issue:
        b.put(ws, row, 5, "없음")
    return b, rows


def pbc_status(d: Path) -> list[dict]:
    """요청자료 18건(pbc_match.yaml 번호)의 받음 · 빠짐. 판정은 지휘(director)가 빠진 자료를 셀 때와 같은 규칙이다."""
    c = director._Case(d)
    stage = director._stage_of(c)
    nobal = c.no_balance()
    out = []
    for e in c.match.get("pbc", []):
        hits = _hits(e, c.files)
        ok, lack = c.judge(e)
        due_later = bool(e.get("from_stage")) and director.STAGES.index(stage) < director.STAGES.index(e["from_stage"])
        status = "받음" if ok else (f"{e['from_stage']} 단계에 받음" if due_later else "빠짐")
        if not ok and e.get("area") and str(e["area"]) in nobal:
            status = director.NO_BALANCE      # 시산표 · 재무제표에 그 영역 잔액이 당기 · 전기 모두 없다(2026-10-18)
        note = f"빠진 것: {' · '.join(lack)}" if lack and not ok else None
        out.append({"no": e["row"], "category": PBC_CATEGORY.get(e["row"], "기타"), "item": e["item"],
                    "workpaper": str(e.get("workpaper") or ""), "status": status, "files": hits, "note": note})
    return out


def _hits(spec: dict, files: list[dict]) -> list[str]:
    if spec.get("any_of"):
        return sorted({p for s in spec["any_of"] for p in _hits(s, files)})
    kinds = spec.get("kinds") or []
    kws = spec.get("keywords") or []
    return sorted(f["path"] for f in files if (not kinds or f["kind"] in kinds) and (not kws or any(k in director._hay(f) for k in kws)))


def make_1200(d: Path, data: dict, case: dict, path: Path) -> Path:
    from docx import Document
    from docx.enum.text import WD_COLOR_INDEX
    from docx.shared import Pt

    c = data["company"]
    doc = Document()
    st = doc.styles["Normal"]
    st.font.name = "맑은 고딕"
    st.font.size = Pt(10)
    doc.core_properties.author = "audit 엔진"
    doc.core_properties.comments = "audit 엔진 초안. 노란 칸은 감사인 기입란"
    doc.core_properties.title = "1200 감사업무조건합의"

    def blank(p, text):
        r = p.add_run(f"[기입란: {text}]")
        r.font.highlight_color = WD_COLOR_INDEX.YELLOW
        return r

    doc.add_heading("1200 감사업무조건합의 (감사계약서 초안)", level=1)
    doc.add_paragraph("감사기준서 210 감사업무 조건의 합의. 엔진이 감사 폴더에서 채운 초안이며, 노란 칸은 감사인이 정해 적는다.")
    t = doc.add_table(rows=0, cols=2)
    t.style = "Table Grid"
    for k, v in (("회사", c["name"]), ("감사 대상 재무제표", f"{case['fiscal_year_end']} 로 끝나는 보고기간의 재무제표"),
                 ("적용 회계기준(전기 감사보고서 기준)", c.get("framework") or "판독 필요"),
                 ("감사 구분", case.get("engagement_kind")), ("전기 감사인", (data.get("prior_report") or {}).get("auditor") or "판독 필요")):
        row = t.add_row().cells
        row[0].text, row[1].text = k, str(v)
    doc.add_heading("1. 감사의 목적과 범위", level=2)
    doc.add_paragraph("감사인은 회계감사기준에 따라 회사의 재무제표를 감사하고, 재무제표가 중요성의 관점에서 적용 회계기준에 따라 "
                      "공정하게 표시되어 있는지에 대한 의견을 감사보고서로 표명한다.")
    doc.add_heading("2. 경영진의 책임", level=2)
    for s in ("적용 회계기준에 따라 재무제표를 작성하고 공정하게 표시할 책임",
              "부정이나 오류로 인한 중요한 왜곡표시가 없는 재무제표 작성에 필요한 내부통제를 설계하고 운영할 책임",
              "감사에 필요한 기록 · 문서와 그 밖의 자료를 제공하고, 감사인이 필요하다고 정한 사람에게 제한 없이 접근하게 할 책임",
              "감사 종료 때 서면진술서를 제공할 책임"):
        doc.add_paragraph(s, style="List Bullet")
    doc.add_heading("3. 감사인의 책임", level=2)
    doc.add_paragraph("감사인은 직업적 회의주의를 유지하며 감사를 계획하고 수행한다. 감사의 고유한 한계로 중요한 왜곡표시가 "
                      "발견되지 않을 위험이 있다. 감사인은 직무상 알게 된 회사의 비밀을 지킨다.")
    doc.add_heading("4. 보수와 일정", level=2)
    blank(doc.add_paragraph(), "감사 보수, 지급 시기, 현장 감사 일정, 감사보고서 제출 예정일")
    doc.add_heading("5. 자료 처리와 AI 도구 사용 고지", level=2)
    doc.add_paragraph("감사 자료의 처리 장소와 보존, AI 도구를 쓰는지와 그 범위는 감사인이 정해 아래에 적는다. 엔진은 문구를 쓰지 않는다.")
    blank(doc.add_paragraph(), "AI 도구 사용 고지 문구(감사인이 작성)")
    doc.add_heading("6. 그 밖의 조건", level=2)
    blank(doc.add_paragraph(), "감사 범위 제한, 다른 감사인 이용, 내부감사 활용 등")
    doc.add_heading("서명", level=2)
    s = doc.add_table(rows=2, cols=2)
    s.style = "Table Grid"
    s.cell(0, 0).text, s.cell(0, 1).text = f"회사: {c['name']} 대표이사", "감사인"
    blank(s.cell(1, 0).paragraphs[0], "서명 · 날짜")
    blank(s.cell(1, 1).paragraphs[0], "서명 · 날짜")
    path.parent.mkdir(parents=True, exist_ok=True)
    doc.save(path)
    return path


# ---------------------------------------------------------------- 요청 메일
def write_mail(d: Path, at: date | None = None) -> Path | None:
    """문서목록.missing 으로 요청 메일 초안을 쓴다. 빠진 자료가 없으면 쓰지 않는다. 보내기는 회계사가 한다."""
    d = Path(d)
    docs = _idx(d, "문서목록.json")
    case = _idx(d, "감사건.json")
    miss = docs.get("missing", [])
    if not miss:
        return None
    at = at or date.today()
    fy = case["fiscal_year_end"]
    name = case["company"]["name"]
    new = [m for m in miss if not m.get("requested_at")]
    again = [m for m in miss if m.get("requested_at")]
    # 제목 · 첫 문장은 감사 폴더 이름(「2025 기말감사」 · 「2026 중간감사」)을 따른다. 중간감사 폴더에 「기말감사」 · 「결산」 이 나갔다(2026-10-19)
    eng = d.name if re.fullmatch(r"\d{4} \S*감사|\d{4} \S*검토", d.name) else f"{fy[:4]} 기말감사"
    when = f"{fy[:4]}년 {int(fy[5:7])}월 {int(fy[8:10])}일"
    purpose = f"{when} 기준 중간감사" if "중간" in eng else (f"{when} 기준 반기검토" if "반기" in eng else f"{when} 결산 외부감사")
    lines = ["[초안] 회계사가 확인한 뒤 보냅니다. 받는 사람과 서명은 회계사가 채웁니다.", "",
             f"제목: [{name} {eng}] 감사 자료 요청 ({len(miss)}건)", "",
             f"{name} 담당자님께", "",
             f"{purpose}를 위해 아래 자료를 요청드립니다.",
             "파일로 보내 주시면 감사 폴더에 정리하겠습니다. 이미 보내신 자료가 목록에 있으면 보내신 날을 알려 주시면 확인하겠습니다.", ""]
    n = 0
    numbered = []
    for title, group in (("새로 요청드리는 자료", new), ("앞서 요청드렸으나 아직 받지 못한 자료", again)):
        if not group:
            continue
        lines.append(title)
        for m in group:
            n += 1
            numbered.append((n, m))
            tail = f" (요청한 날 {m['requested_at']})" if m.get("requested_at") else ""
            lines.append(f"{n}. {m['item']}{tail}")
            for x in m.get("detail") or []:          # 분석적 검토가 붙인 구체 문구(2026-10-18)
                lines.append(f"   - {x}")
        lines.append("")
    lines += ["자료 준비에 시간이 걸리는 항목은 예정일을 알려 주시면 일정에 반영하겠습니다.", "감사합니다.", "",
              "감사인 드림", "", f"(감사 폴더 _색인/문서목록.json 의 빠진 자료 {len(miss)}건으로 만든 초안, {at.isoformat()})"]
    # 스태프 배정이 있으면 자료를 받을 담당자별로 번호를 묶어 둔다(2026-10-12). 감사반이 보는 구역이라 보내기 전에 지운다
    from . import assign as _assign

    who = _assign.of(d)
    if who:
        by: dict[str, list] = {}
        for k, m in numbered:
            by.setdefault((who.get(str(m.get("workpaper") or "")) or {}).get("to") or "미배정", []).append((k, m))
        lines += ["", "[감사반 확인용: 담당자별 받을 자료. 보내기 전에 이 아래를 지웁니다]"]
        for name in sorted(by, key=lambda x: (x == "미배정", x)):
            lines.append(f"{name}: " + ", ".join(f"{k}번" + (f"(조서 {m['workpaper']})" if m.get("workpaper") else "") for k, m in by[name]))
    # 오늘 초안에는 시각(HHMM)을 붙여 같은 날 다시 써도 보낸 초안을 덮지 않는다(2026-10-22 화면 시험 8절 1, T3). 같은 분이면 _2 · _3
    from datetime import datetime

    stamp = f"{at.isoformat()}_{datetime.now().strftime('%H%M')}" if at == date.today() else at.isoformat()
    p = d / "1000 감사계약" / f"{MAIL_PREFIX}{stamp}.txt"
    n = 2
    while p.exists():
        p = p.with_name(f"{MAIL_PREFIX}{stamp}_{n}.txt")
        n += 1
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text("\n".join(lines) + "\n", encoding="utf-8")
    return p


def mark_requested(d: Path, at: str, now: str | None = None, by: str | None = None) -> int:
    """회계사가 요청 메일을 보낸 뒤 빠진 자료에 요청한 날을 적는다. 이미 적힌 것은 두고, 적은 수를 돌려준다.
    by(보낸 회계사)를 주면 `_기록` 에 「요청 메일 보냄」 한 줄(보낸 날 · 그때 빠진 자료 전부)을 남긴다. 다시 요청(재회신)도 이 줄로 남는다(2026-10-22)."""
    if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", at):
        raise IntakeError(f"보낸 날은 2026-01-21 꼴로 적어 주십시오: {at}")
    d = Path(d)
    docs = _idx(d, "문서목록.json")
    if by:
        from . import records

        records.add(d, by, "요청 메일 보냄", "PBC", None, {"date": at, "items": [m["item"] for m in docs.get("missing", [])]})
    n = 0
    for m in docs.get("missing", []):
        if not m.get("requested_at"):
            m["requested_at"] = at
            n += 1
    folder._write(d / "_색인" / "문서목록.json", docs)
    case = _idx(d, "감사건.json")
    case["log"].insert(0, {"at": now or _now(), "who": "시작 자료", "what": f"요청 메일을 {at} 에 보냈다고 빠진 자료 {n}건에 적었습니다",
                           "wrote": ["_색인/문서목록.json"]})
    folder._write(d / "_색인" / "감사건.json", case)
    folder.validate_index(d)
    return n


def _carry_people(d: Path, ps: dict) -> str | None:
    """작년 감사 폴더 1000 감사계약/감사반인원.xlsx 를 당기 폴더에 없을 때만 복사한다. 복사한 상대경로 또는 None."""
    from .checklists import people_path

    src = (ps or {}).get("inputs", {}).get("1300 감사반 인원")
    dst = people_path(d)
    if not src or dst.exists():
        return None
    p = (Path(d) / src).resolve()
    if not p.is_file():
        return None
    dst.parent.mkdir(parents=True, exist_ok=True)
    shutil.copyfile(p, dst)
    return _rel(d, dst)


# ---------------------------------------------------------------- 한 번에
def build(d: Path, dart_target: str | None = None, force: bool = False, now: str | None = None, reuse: bool = False) -> dict:
    """시작 자료를 읽고 색인 · 조서 · 메일 초안을 쓴다. reuse 면 받은자료를 다시 읽지 않고 시작자료.json 에서 조서만 다시 만든다."""
    d = Path(d)
    at = now or _now()
    if _idx(d, "감사건.json") is None:
        raise IntakeError(f"_색인/감사건.json 이 없습니다. 먼저 감사 폴더를 만들어 주십시오: {d}")
    old = _idx(d, START_FILE, {}) or {}
    # 전기조서의 글(메모 · 절차 · 발견사항 · 결론)을 먼저 읽어 _색인/전기조서.json 에 둔다(2026-10-12). 당기 조서가 참고로 싣고,
    # 아래 표 판독(read_prior_workpapers)이 글 블록 라벨이 있는 계정 조서를 가려내는 데 쓴다
    from . import priorwp

    pwc = priorwp.collect(d, now=at)
    if reuse and old:
        data = copy.deepcopy(old)
    else:
        g = gather(d, dart_target)
        case = _idx(d, "감사건.json")
        data = {"format_version": 1, "made_at": at, "prior_end": g["prior_end"], "company": g["company"],
                "prior_report": g["prior_report"], "dart": g["dart"], "prior_workpapers": g["prior_workpapers"],
                "prior_fs": g["prior_fs"], "need_ai": g["need_ai"], "warnings": g["warnings"], "term": g["term"],
                "ai": old.get("ai", []), "made": old.get("made", {})}
        fy = _fy_end(case)
        data["parties"] = top_parties(d, fy)
        mat = ((g["prior_workpapers"] or {}).get("materiality") or {}).get("performance")
        data["changes"] = big_changes(current_statement(d), g["prior_fs"], mat["amount"] if mat else None)
        if g["saved_dart"]:
            data["dart_saved"] = g["saved_dart"]
    # _기록 의 회사정보 확인 · 고침(사람). 시작자료.json 을 지우고 다시 읽어도 되살아난다(2026-10-22)
    from . import records

    rec = records.company_fields(d)
    if rec:
        fields = {x["field"] for x in rec}
        data["ai"] = [x for x in data.get("ai", []) if x.get("field") not in fields] + rec
    _merge_ai(data)
    data["made_at"] = at
    # 전기 자료(R7): 작년 감사 폴더 · 전임 전기조서 · 전기조서 없음을 판정하고 전기 판단 정보를 모은다
    data["prior_source"] = prior.collect(d, gathered=data)
    # 계정 조서(Lead · 절차 시트)는 중요성 · 정산표 같은 표가 없는 것이 정상이다. 영역으로 이어진 전기조서는 표 판독 필요에서 뺀다
    read_ok = {f["path"] for f in pwc["files"] if f["blocks"] or f["area"]}
    data["need_ai"] = [x for x in data.get("need_ai", []) if not x.startswith(PRIOR_TEXT_AI)
                       and not (x.startswith(PRIOR_TABLE_AI) and x.rsplit(": ", 1)[-1] in read_ok)] + \
        [f"{PRIOR_TEXT_AI}: {p}" for p in pwc["need_ai"]]
    case = _idx(d, "감사건.json")

    # 작년 감사 폴더의 감사반 인원(1300)을 당기 폴더에 없을 때만 옮긴다. 있으면 둔다
    copied = _carry_people(d, data["prior_source"])

    # 빠진 자료를 먼저 지휘 규칙으로 정한다(PBC 와 메일이 같은 목록을 쓴다)
    director.run(d, now=at)
    data["missing"] = _idx(d, "문서목록.json")["missing"]

    made = dict(data.get("made", {}))
    wrote, skipped = [], []
    for no, maker in (("PBC", None), ("1100", make_1100), ("2100", make_2100)):
        path = wp.path_for(d, no)
        if not _may_write(path, made, force):
            skipped.append(_rel(d, path))
            continue
        b = make_pbc(d, data)[0] if no == "PBC" else maker(d, data, case)
        b.save(path)
        made[path.name] = _sha(path)
        wrote.append(_rel(d, path))
    p1200 = wp.path_for(d, "1200", ext=".docx")
    if _may_write(p1200, made, force):
        make_1200(d, data, case, p1200)
        made[p1200.name] = _sha(p1200)
        wrote.append(_rel(d, p1200))
    else:
        skipped.append(_rel(d, p1200))
    data["made"] = made
    if copied:
        wrote.append(copied)
    data["pbc"] = [{k: r[k] for k in ("no", "item", "status")} for r in pbc_status(d)]
    missing = data.pop("missing")       # 빠진 자료의 정본은 문서목록.missing 이다. 여기 두지 않는다
    folder._write(d / "_색인" / START_FILE, data)
    data["missing"] = missing

    touched = _doc_facts(d, data)
    mail = write_mail(d, date.fromisoformat(at[:10]) if re.match(r"\d{4}-\d{2}-\d{2}", at) else None)
    if mail:
        wrote.append(_rel(d, mail))
    read = [x for x in ((data.get("prior_report") or {}).get("path"), (data.get("dart") or {}).get("path")) if x]
    read += list(((data.get("prior_workpapers") or {}).get("files") or {}).keys())
    _update_case(d, data, at, wrote, read)
    folder.scan(d, now=at, quiet_log=True)
    director.run(d, now=at)
    folder.validate_index(d)
    return {"wrote": wrote, "skipped": skipped, "facts_on": touched, "company": data["company"],
            "prior_report": data.get("prior_report"), "dart": data.get("dart"), "prior_workpapers": data.get("prior_workpapers"),
            "prior_fs_basis": (data.get("prior_fs") or {}).get("basis"), "need_ai": data["need_ai"], "warnings": data["warnings"],
            "missing": _idx(d, "문서목록.json")["missing"], "mail": _rel(d, mail) if mail else None,
            "big_changes": [r["name"] for r in data["changes"]["rows"] if r["big"]], "pbc": data["pbc"]}
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