Merge remote-tracking branch 'origin/dev' into main_laptop_1

· 계수표(T·L·E·q0·e·f·V1·V2·t) 칸을 기호로 읽어 불도저 식(8-2-1 · dozer_hourly_output) 그대로 Q1 47.92 ㎥/hr · Q = Q1 ÷ T 0.2 = 239.60 ㎡/hr
· 기종은 q0 3.2 · V1 40 · V2 46(1단)로 8-2-1 표에서 되짚음 → 무한궤도 19ton([주]① 과 맞음) · D 줄 1/Q hr/㎡
· 원문 대 실무 어긋남 기록 — 영월 호표 Q=576.95 는 E 자리에 e(0.96)를 넣은 값으로 정확히 역산됨 · 다른 실무엔 이 호표 없음 → 원문이 또렷해 원문 E=0.4 로 셈(공종 사유 한 줄)

새 제목 B·D 618원/㎡ · 바뀐 제목 0 · 프로젝트 내역 표토제거 9,954.32㎡ 가 금액으로 섬(+6,151,768) · 잴 시험 둘 빨강→초록 · 끄기 셋 빨강 · 전체 시험 1703 + 364 통과

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BW6Jdsh18WPtYUR6THZJqn

B08_Quantity/B08_Quantity_Build_WorkItemMaster_Forms.py

@@ -110,6 +110,11 @@ FORM_JUDGMENTS: dict[str, tuple[str, str, str]] = {
     #   절 제목으로 읽어 12-2 에 붙어 있던 표(빌더가 앞 절 이어받기로 고침). 형태 판정은 그대로.
     "F0358": ("12-17-1", "reference", "시설유형 Type-Ⅰ~Ⅳ 적용 기준 설명"),
     "F0360": ("12-17-1", "reference", "현장조건 Type-Ⅰ~Ⅲ 적용 기준 설명"),
+    "F0385": (
+        "12-34-1",
+        "requirement",
+        "인력(인)·기계(대, Q=5.4㎥/hr) 소요량 표 — 「별도계상」 은 레미콘 자재 줄 비고일 뿐",
+    ),
     "F0388": ("12-34-4", "reference", "「재료비 JOINT FILLER」 항목만 — 값이 없는 구성 안내"),
     "F0390": ("12-36", "reference", "제작비·운송비·설치비 「견적처리」"),
     "F0392": ("12-38-1", "coefficient", "사용횟수별 잔존율(12회 25%·25회 10%)"),

B09_Estimation/B09_Estimation_KnownGaps.py

@@ -55,6 +55,21 @@ KNOWN_GAPS: dict[str, tuple[str, str]] = {
         "(제안 무한궤도 — 영월 실무 「06M3 B/H」 · 2026-09-14 브레인 ②).",
     ),
     # 2026-09-14 ㉮ — 사용횟수 갈래로 푼 뒤 남는 원문 몫. 값을 짓지 않고 말만.
+    # 봉상후렉시블 셋의 표 나머지 줄은 판정표 자동 목록(`_unread_rows`)이 맡음 — 줄이 아닌 [주] 만 여기.
+    "FP-12-12": ("원문 [주]", "ⓘ [주] 「성토부 날개벽 설치시 인건비 30% 할증」 은 안 걺(선택)."),
+    # 원문 대 실무 어긋남 기록(2026-09-15 브레인 규칙 — 원문이 또렷하면 원문 · 어긋남은 늘 기록).
+    "FP-09-15-02": (
+        "실무 어긋남",
+        "ⓘ 실무 영월 「표토제거 답외구간」 호표 Q=576.95 는 E 자리에 e(0.96)를 넣은 값으로 역산됨"
+        "(60×3.07×0.77×0.96÷(1.18×0.2)) — 원문 9-15-2 가 E=0.4 로 또렷해 원문으로 셈 · 다른 실무(봉화·대흥·"
+        "소광·거창)엔 이 호표 없음.",
+    ),
+    "FP-12-34-01": (
+        "원문 머리",
+        "ⓘ 원문 머리 「(단위: 개소당)」 ↔ 인력 콘크리트공 0.17·보통인부 0.29 가 12-16 맨홀 ㎥당(0.17인/㎥"
+        " · 0.29인/㎥)과 같고 기계도 Q=5.4㎥/hr ⇒ ㎥당으로 읽음(고른 쪽 ㎥당 · 버린 쪽 개소당) ·"
+        " 봉상후렉시블(45mm) 대 2 는 엔진식 진동기의 봉이라 두 번 안 셈(2026-09-14 브레인).",
+    ),
     "FP-12-04": (
         "원문 [주]",
         "ⓘ 「사용고재 평가기준 23%(합판과 각재의 설계단가 기준)」 은 원문이 셈을 안 줘 값으로 안 씀"

B09_Estimation/B09_Estimation_ResourceAxis_JudgedTable.py

@@ -63,7 +63,82 @@ JUDGED_TABLES: dict[str, dict[str, Any]] = {
         "needs_machine": {"구체콘크리트": "다짐:봉상후렉시블(45mm)"},
         "why": "원문 L6460 「구체·버림콘크리트 ㎥ — 비고 칸 콘크리트공·보통인부 인/㎥」",
     },
+    # 12-15 와 같은 모양 셋 — 같은 봉상후렉시블 줄 하나가 셋을 막고 있었음(2026-09-14 브레인 · 672 다음).
+    "F0350": {
+        "code": "FP-12-12",
+        "shape": "remark_labor",
+        "prefix": "날개벽",
+        "needs_machine": {"콘크리트": "다짐:봉상후렉시블(45mm)"},
+        "why": "원문 L6419 12-12 「콘크리트(레미콘) ㎥ — 비고 칸 콘크리트공·보통인부 인/㎥」",
+    },
+    "F0351": {
+        "code": "FP-12-13",
+        "shape": "remark_labor",
+        "prefix": "면벽",
+        "needs_machine": {"콘크리트": "다짐:봉상후렉시블(45mm)"},
+        "why": "원문 L6436 12-13 「콘크리트(레미콘) ㎥ — 비고 칸 콘크리트공·보통인부 인/㎥」",
+    },
+    "F0354": {
+        "code": "FP-12-16",
+        "shape": "remark_labor",
+        "prefix": "맨홀",
+        # 칸이 하나 밀려 비고가 끝 칸이 아님(「구체콘크리트 | 철근 | ㎥ | | 비고 | 」).
+        "needs_machine": {"구체콘크리트": "봉상후렉시블(45mm)"},
+        "why": "원문 L6474 12-16 「구체·버림콘크리트 ㎥ — 비고 칸 콘크리트공·보통인부 인/㎥」",
+    },
+    # 12-34-1 — 머리 「(단위: 개소당)」 이나 인력 0.17·0.29 가 12-16 맨홀 ㎥당과 같고 기계가 Q ㎥/hr
+    #   ⇒ ㎥당으로 읽음 · 「봉상후렉시블 대 2」 는 엔진식 진동기(엔진+플렉시블 한 대)의 봉(2026-09-14 브레인).
+    "F0385": {
+        "code": "FP-12-34-01",
+        "shape": "per_m3_rows",
+        "prefix": "콘크리트 타설",
+        # 엔진식 진동기(건설품셈 8-3 (4611) 엔진+플렉시블 한 대)의 봉 — 「진동기(3.5HP) 대 2」 로 셈.
+        "same_machine": ("봉상후렉시블(45mm)",),
+        "why": "원문 L6839 12-34-1 「인력 콘크리트공·보통인부 인 · 기계 대 (Q=5.4㎥/hr)」",
+    },
 }
+#: 줄 첫 칸이 분류 딱지인 표(12-34-1 「자재 | 콘크리트(레미콘)」) — 이름은 다음 칸.
+_ROW_CATEGORIES = ("자재", "인력", "기계")
+#: 자원이 아닌 머리 줄(12-04 「횟수별 | 재료별(%) | 노무비(%)」).
+_HEADER_ROWS = ("횟수별", "구분")
+UNREAD_REASON = "판정표가 안 읽은 줄 — 이 일위대가에 안 넣음(자동 · 2026-09-14)"
+
+
+def _loose(text: str) -> str:
+    """겹침 비교용 — 빈칸·괄호·가운뎃점·쉼표를 뺌(「적사(굴착기 0.7㎥)」 ↔ 「적사 굴착기 0.7㎥」)."""
+    return re.sub(r"[\s()·,:]", "", str(text))
+
+
+def _unread_rows(code, table_id, judged, rows, staged) -> list:
+    """읽힌 줄 밖의 줄을 「못 붙은 줄」 로 — 표를 넣을 때마다 손으로 사유를 안 달아도 안 샘.
+
+    ㉠ 빼는 것: 읽힌 줄(`raw_row_index`) · 이미 못 맞춤으로 선 이름 · 다른 갈래가 쓴 기계 줄
+       (`needs_machine`·`same_machine`) · 자원 머리(`header_row` 첫 줄 · 「횟수별」) · 빈 줄
+    ㉡ 손 사유(`known_gap_note`)가 이미 적은 이름은 안 올림 — 같은 말이 두 번 안 뜨게
+    """
+    from B09_Estimation.B09_Estimation_KnownGaps import known_gap_note
+
+    read = {item.raw_row_index for item in staged if isinstance(item, ResourceRow)}
+    taken = {_loose(item.cell) for item in staged if isinstance(item, UnmatchedRow)}
+    taken |= {_loose(name) for name in judged.get("needs_machine", {}).values()}
+    taken |= {_loose(name) for name in judged.get("same_machine", ())}
+    hand = _loose(known_gap_note(code))
+    unread: list = []
+    for index, cells in enumerate(rows):
+        cells = [c for c in cells]
+        if index in read or not any(cells) or (judged["shape"] == "header_row" and index == 0):
+            continue
+        name = cells[1] if cells[0] in _ROW_CATEGORIES and len(cells) > 1 else cells[0]
+        key = _loose(name)
+        if not key or key in _HEADER_ROWS or key in taken or key in hand:
+            continue
+        if key == "비고":
+            name = f"비고 — {' '.join(' '.join(cells[1:]).split())[:40]}…"
+        unread.append(UnmatchedRow(code, table_id, " ".join(name.split()), UNREAD_REASON))
+        taken.add(key)
+    return unread
+
+
 #: 비고 칸 인력 — 「콘크리트공0.24인/㎥, 보통인부 0.42인/㎥」.
 _RE_REMARK_LABOR = re.compile(r"([가-힣]+)\s*(\d+(?:\.\d+)?)\s*인/㎥")
 _RE_Q = re.compile(r"Q\s*=\s*(\d+(?:\.\d+)?)")
@@ -122,7 +197,8 @@ def match_judged_table(
         result.partial_items[code] = why
         return True
 
-    if basis_quantity in (None, 0):
+    # 비고·Q 가 ㎥당을 적는 모양은 표 머리 밑수를 안 씀(12-12 날개벽은 「개소당」 머리조차 없음).
+    if basis_quantity in (None, 0) and judged["shape"] not in ("remark_labor", "per_m3_rows"):
         return block("판정 표에 밑수가 없습니다")
     if judged["shape"] == "header_row":
         staged = _header_row(code, table, judged, rows, catalog, basis_quantity, unit)
@@ -130,10 +206,13 @@ def match_judged_table(
         staged = _use_count(code, table, rows, catalog, basis_quantity, unit)
     elif judged["shape"] == "remark_labor":
         staged = _remark_labor(code, table, judged, rows, catalog)
+    elif judged["shape"] == "per_m3_rows":
+        staged = _per_m3_rows(code, table, judged, rows, catalog)
     else:
         staged = _merged_first(code, table, judged, rows, catalog, basis_quantity, unit)
     if isinstance(staged, str):
         return block(f"{staged} — 판정({judged['why']})과 칸이 달라 안 읽음")
+    staged = [*staged, *_unread_rows(code, table_id, judged, rows, staged)]
     for item in staged:
         if isinstance(item, UnmatchedRow):
             result.unmatched.append(item)
@@ -240,7 +319,7 @@ def _remark_labor(code, table, judged, rows, catalog) -> list | str:
     by_name = {"".join(cells[0].split()): cells for cells in rows if cells}
     staged: list = []
     for index, cells in enumerate(rows):
-        labors = _RE_REMARK_LABOR.findall(cells[-1] if cells else "")
+        labors = _RE_REMARK_LABOR.findall(" ".join(cells[3:]))  # 비고가 끝 칸이 아닌 표(12-16)
         if len(cells) < 3 or cells[2] != "㎥" or not labors:
             continue
         variant = cells[0].split("(")[0].strip()
@@ -268,3 +347,26 @@ def _remark_labor(code, table, judged, rows, catalog) -> list | str:
         for entry, amount in pieces:
             staged.append(_row(code, table, entry, amount, "㎥", index, variant))
     return staged
+
+
+def _per_m3_rows(code, table, judged, rows, catalog) -> list | str:
+    """「인」 칸 앞 이름 · 뒤 수(인/㎥) · 「대」 칸 앞 이름 · 뒤 대수 ÷ Q — 칸이 밀린 줄도 단위 칸으로 찾음."""
+    staged: list = []
+    for index, cells in enumerate(rows):
+        unit = next((i for i, c in enumerate(cells) if c in ("인", "대") and i > 0), None)
+        if unit is None:
+            continue
+        name = cells[unit - 1]
+        if "".join(name.split()) in judged.get("same_machine", {}):
+            continue  # 같은 기계 두 번 안 셈 — 까닭은 공종 사유 한 줄(`KnownGaps`)이 화면에 보임
+        amount = next((parse_amount(c) for c in cells[unit + 1 :] if parse_amount(c)), None)
+        entry = _entry(catalog, name, code)
+        if amount is None or entry is None:
+            return f"{name} 줄"
+        if cells[unit] == "대":
+            found_q = _RE_Q.search(" ".join(cells))
+            if found_q is None:
+                return f"{name} Q"
+            amount = amount / Decimal(found_q.group(1))
+        staged.append(_row(code, table, entry, amount, "㎥", index, ""))
+    return staged

B09_Estimation/B09_Estimation_TopsoilRemoval.py

@@ -0,0 +1,112 @@
+"""B09 원가계산 — **표토제거 답외구간** 9-15-2 (2026-09-14 브레인 ㉰ 첫째).
+
+B08 준비공 「표토제거」 줄이 부르는 코드인데 표가 계수표(T·L·E·q0·e·f·V1·V2·t)라 일위대가가 안 섰음.
+
+    q = q0 × e · ㎝ = L/V1 + L/V2 + t · Q1 = 60 × q × f × E / ㎝ (㎥/hr) · Q = Q1 / T (㎡/hr)
+    [주]① 무한궤도 불도저(19ton) · ③ 건설품셈 8-2-1 불도저 참조 → 불도저 식(`dozer_hourly_output`) 그대로 + T 로 나눔
+    기종은 표의 q0·V1·V2(1단)로 8-2-1 표에서 되짚음(`resolve_dozer`) — [주]① 19ton 과 맞는지 시험이 봄
+
+⚠ 실무 영월 호표 Q=576.95 는 E 자리에 e(0.96)를 넣은 값 — 원문이 또렷해 원문 E 로 셈(까닭은 `KnownGaps`).
+"""
+
+from __future__ import annotations
+
+import re
+from decimal import Decimal
+from typing import Any
+
+CODE = "FP-09-15-02"
+TABLE = "F0282"
+_RE_SYMBOL = re.compile(r"^([A-Za-z]\d?)\s*\(")
+_RE_GEAR = re.compile(r"(\d+)\s*단")
+
+
+def _factors(node: dict[str, Any]):
+    """(불도저 계수, T) — 칸이 모자라거나 기종이 안 좁혀지면 까닭 글."""
+    from B09_Estimation.B09_Estimation_MachineProductivity import parse_measure
+    from B09_Estimation.B09_Estimation_MachineProductivity_Dozer import DozerFactors, resolve_dozer
+
+    table = next((t for t in node.get("tables") or [] if t.get("pum_table_id") == TABLE), {})
+    values: dict[str, Decimal] = {}
+    gear = 1
+    for row in table.get("raw_row") or []:
+        found = _RE_SYMBOL.match(str(row[0]).strip()) if row else None
+        value = parse_measure(str(row[1])) if found and len(row) > 1 else None
+        if value is not None:
+            values[found.group(1)] = value
+            shift = _RE_GEAR.search(str(row[1]))
+            gear = int(shift.group(1)) if shift else gear
+    missing = [k for k in ("T", "L", "E", "q0", "e", "f", "V1", "V2") if k not in values]
+    if missing:
+        return f"9-15-2 표 칸 없음: {', '.join(missing)}"
+    machine = resolve_dozer(values["q0"], values["V1"], values["V2"], gear)
+    if machine is None:
+        return f"삽날 {values['q0']}㎥ · {values['V1']}/{values['V2']}m/분({gear}단) 으로 불도저가 안 좁혀짐"
+    factors = DozerFactors(
+        work_item_code=CODE,
+        blade_capacity_m3=values["q0"],
+        distance_factor=values["e"],
+        volume_factor=values["f"],
+        efficiency=values["E"],
+        haul_distance_m=values["L"],
+        forward_speed_m_min=values["V1"],
+        reverse_speed_m_min=values["V2"],
+        machine_code=machine[0],
+        machine_name=machine[1],
+    )
+    return factors, values["T"]
+
+
+def topsoil_output(node: dict[str, Any] | None = None) -> tuple[Decimal, Decimal]:
+    """(Q1 ㎥/hr, Q ㎡/hr) — 둘 다 소수 2자리로 확정한 뒤 씀(명세 7장)."""
+    from B09_Estimation.B09_Estimation_MachineProductivity import fix2
+    from B09_Estimation.B09_Estimation_MachineProductivity_Dozer import dozer_hourly_output
+    from B09_Estimation.B09_Estimation_ResourceAxis import load_work_item_master
+
+    if node is None:
+        node = next(n for n in load_work_item_master()["work_items"] if n["work_item_code"] == CODE)
+    found = _factors(node)
+    if isinstance(found, str):
+        raise ValueError(found)
+    factors, thickness = found
+    q1 = dozer_hourly_output(factors)
+    return q1, fix2(q1 / thickness)
+
+
+def attach_topsoil_removal(build: Any, nodes_by_code: dict[str, dict[str, Any]]) -> None:
+    """`B-FP-09-15-02` — 불도저 1/Q hr/㎡ 한 줄(D). 기계 층이 없거나 표가 달라지면 까닭만."""
+    from B09_Estimation.B09_Estimation_PriceBook import PriceKind, PriceTitle
+
+    node = nodes_by_code.get(CODE)
+    title_code = f"B-{CODE}"
+    if node is None or title_code in build.book.titles:
+        return
+    found = _factors(node)
+    if isinstance(found, str):
+        build.component_gaps[CODE] = found
+        return
+    factors, thickness = found
+    hourly = f"X-{factors.machine_code}"
+    if hourly not in build.book.titles:
+        build.component_gaps[CODE] = f"{factors.machine_name} 시간당 사용료가 안 섬"
+        return
+    q1, q = topsoil_output(node)
+    build.book.add_title(
+        PriceTitle(
+            code=title_code,
+            kind=PriceKind.UNIT_PRICE,
+            name=str(node.get("name") or CODE),
+            spec="표토제거",
+            unit="㎡",
+        )
+    )
+    build.book.add_output_detail(
+        title_code,
+        hourly,
+        Decimal(1) / q,
+        f"{factors.formula_text} → Q = Q1 {q1} ÷ T {thickness}m = {q} ㎡/hr"
+        " (산림품셈 9-15-2 [주]②③ · 건설 8-2-1)",
+        output=q,
+    )
+    if CODE in build.skipped:
+        build.skipped.remove(CODE)

B09_Estimation/B09_Estimation_UnitPrice.py

@@ -899,9 +899,13 @@ def build_unit_prices(
         #   예외 = 사용자가 다른 품셈 밑수를 확정한 자리(9-21 「1,000㎡당」 · ÷ 는 ChooseOne 이 검) —
         #   마스터 목록은 원문 사실이라 그대로 두고 여기서만 걷음(2026-09-14 브레인 · 사유는 비고).
         borrowed = work_item_code.startswith(tuple(BORROWED_BASIS_PER))
+        from B09_Estimation.B09_Estimation_ResourceAxis_JudgedTable import JUDGED_TABLES
+
         for row in rows:
             section = missing_basis.get(str(row.pum_table_id))
-            if section and not borrowed:
+            # 비고가 「인/㎥」 로 밑수를 적은 판정표(12-12 날개벽 「개소당」 머리 없음)는 밑수가 ㎥ 로 섬.
+            per_remark = JUDGED_TABLES.get(str(row.pum_table_id), {}).get("shape") == "remark_labor"
+            if section and not borrowed and not per_remark:
                 build.basis_missing[work_item_code] = section
                 break
 
@@ -1091,6 +1095,10 @@ def build_unit_prices(
     from B09_Estimation.B09_Estimation_Explosives import attach_explosives
 
     attach_explosives(build, nodes_by_code)
+    # 표토제거 답외구간(9-15-2) — 계수표를 불도저 식 + T 로(2026-09-14 ㉰).
+    from B09_Estimation.B09_Estimation_TopsoilRemoval import attach_topsoil_removal
+
+    attach_topsoil_removal(build, nodes_by_code)
     # ⚠ **마지막에 한 번** — 조합 사용 공종의 본체 기계를 잡재료 16% 층으로 바꿔 단다
     # (품셈 제8장 [주]⑤). 조립 도중에 바꾸면 어느 공종이 조합인지 아직 모른다.
     build.combined_swapped = _apply_combined_misc_rate(

resources/data_aliases/aliases_2026-01-01.json

@@ -51,6 +51,38 @@
    "pum_edition": "2026-01-01",
    "basis": "12-15 집수정 표(원문 L6460)는 「봉상후렉시블(45mm) Q=5.4㎥/hr」 만 적고 전기·엔진을 안 적음 — 건설품셈 8-3 (4611) 은 전기식 플렉시블형 ø45(0.75㎾)·엔진식 플렉시블형 ø45(2.6㎾) 둘 · 12-34-1 「콘크리트 진동기(3.5HP)」 = 2.6㎾ 엔진식 · 운전경비표(8-4)에 엔진식 4611-0350(휘발유 1.0L)만 있음 → 엔진식. 전기식이 필요하면 그때 엶. 2026-09-14 브레인 승인(661 뒤 ①)"
   },
+  {
+   "axis": "resource",
+   "from": "다짐:봉상후렉시블(45mm)",
+   "to": "4611-0350",
+   "scope": "FP-12-12",
+   "pum_edition": "2026-01-01",
+   "basis": "12-12 날개벽(원문 L6419) 표는 「봉상후렉시블(45mm) Q=5.4㎥/hr」 만 적고 전기·엔진을 안 적음 — 12-15 집수정과 같은 줄 · 같은 근거(건설품셈 8-3 (4611) 전기식·엔진식 둘 · 12-34-1 「콘크리트 진동기(3.5HP)」 = 2.6㎾ 엔진식 · 운전경비표에 엔진식 4611-0350 만) → 엔진식. 2026-09-14 브레인(672 다음 · 봉상후렉시블 셋)"
+  },
+  {
+   "axis": "resource",
+   "from": "다짐:봉상후렉시블(45mm)",
+   "to": "4611-0350",
+   "scope": "FP-12-13",
+   "pum_edition": "2026-01-01",
+   "basis": "12-13 면벽(원문 L6436) 표는 「봉상후렉시블(45mm) Q=5.4㎥/hr」 만 적고 전기·엔진을 안 적음 — 12-15 집수정과 같은 줄 · 같은 근거(건설품셈 8-3 (4611) 전기식·엔진식 둘 · 12-34-1 「콘크리트 진동기(3.5HP)」 = 2.6㎾ 엔진식 · 운전경비표에 엔진식 4611-0350 만) → 엔진식. 2026-09-14 브레인(672 다음 · 봉상후렉시블 셋)"
+  },
+  {
+   "axis": "resource",
+   "from": "봉상후렉시블(45mm)",
+   "to": "4611-0350",
+   "scope": "FP-12-16",
+   "pum_edition": "2026-01-01",
+   "basis": "12-16 맨홀(원문 L6474) 표는 「봉상후렉시블(45mm) Q=5.4㎥/hr」 만 적고 전기·엔진을 안 적음 — 12-15 집수정과 같은 줄 · 같은 근거(건설품셈 8-3 (4611) 전기식·엔진식 둘 · 12-34-1 「콘크리트 진동기(3.5HP)」 = 2.6㎾ 엔진식 · 운전경비표에 엔진식 4611-0350 만) → 엔진식. 2026-09-14 브레인(672 다음 · 봉상후렉시블 셋)"
+  },
+  {
+   "axis": "resource",
+   "from": "콘크리트 진동기(3.5HP)",
+   "to": "4611-0350",
+   "scope": "FP-12-34-01",
+   "pum_edition": "2026-01-01",
+   "basis": "12-34-1 「콘크리트 진동기(3.5HP)」 — 3.5HP = 2.6㎾ · 건설품셈 8-3 (4611) 엔진식 플렉시블형 ø45(2.6㎾) · 운전경비표에 엔진식만 · 실무 영월 중기목록 「콘크리트 진동기 45φ(2.6㎾)엔진식플렉시블형」. 2026-09-14 브레인"
+  },
   {
    "axis": "variant",
    "from": "0.2·소림",

resources/data_work_item_master/_manifest.json

@@ -1,7 +1,7 @@
 {
  "schema_version": "1.0",
  "dataset_id": "data_work_item_master_manifest",
- "generated_at": "2026-09-14T22:25:14+09:00",
+ "generated_at": "2026-09-14T23:14:39+09:00",
  "built_by": "B08_Quantity/B08_Quantity_Build_WorkItemMaster.py",
  "source": {
   "dataset_id": "pum_forest",
@@ -12,8 +12,8 @@
  "files": [
   {
    "file": "work_item_master_2026-01-01.json",
-   "sha256": "2f0d8bfb3836597ee6f2fd755e2f2e172cb33df1e1e9061af81982a43497f9b2",
-   "size_bytes": 838655
+   "sha256": "708a6a80d016c42d3402bd2a6cb5266fa18e1e2b5301bac823e6ff79d17fb2b6",
+   "size_bytes": 838969
   },
   {
    "file": "form_undetermined_2026-01-01.json",

resources/data_work_item_master/work_item_master_2026-01-01.json

@@ -3,7 +3,7 @@
  "dataset_id": "work_item_master_forest",
  "effective_date": "2026-01-01",
  "pum_edition": "2026-01-01",
- "generated_at": "2026-09-14T22:25:14+09:00",
+ "generated_at": "2026-09-14T23:14:39+09:00",
  "dataset_version": {
   "dataset_id": "pum_forest",
   "effective_date": "2026-01-01",
@@ -32888,7 +32888,9 @@
      "formula_rows": [],
      "special_glyphs": [],
      "capacity_formula_here": false,
-     "variant_key": [],
+     "variant_key": [
+      "콘크리트"
+     ],
      "condition_note": [
       "구 분",
       "규 격",
@@ -32970,7 +32972,9 @@
      ]
     }
    ],
-   "variant_keys": []
+   "variant_keys": [
+    "콘크리트"
+   ]
   },
   {
    "work_item_code": "FP-12-13",
@@ -32997,7 +33001,9 @@
      "formula_rows": [],
      "special_glyphs": [],
      "capacity_formula_here": false,
-     "variant_key": [],
+     "variant_key": [
+      "콘크리트"
+     ],
      "condition_note": [
       "구 분",
       "규 격",
@@ -33065,7 +33071,9 @@
      ]
     }
    ],
-   "variant_keys": []
+   "variant_keys": [
+    "콘크리트"
+   ]
   },
   {
    "work_item_code": "FP-12-14",
@@ -33242,7 +33250,10 @@
      "formula_rows": [],
      "special_glyphs": [],
      "capacity_formula_here": false,
-     "variant_key": [],
+     "variant_key": [
+      "구체콘크리트",
+      "버림콘크리트"
+     ],
      "condition_note": [
       "구 분",
       "단위",
@@ -33349,7 +33360,10 @@
      ]
     }
    ],
-   "variant_keys": []
+   "variant_keys": [
+    "구체콘크리트",
+    "버림콘크리트"
+   ]
   },
   {
    "work_item_code": "FP-12-17",
@@ -35258,8 +35272,8 @@
      "pum_table_id": "F0385",
      "section": "12-34-1. 콘크리트 타설(철근 진동기포함)",
      "source_line": 6843,
-     "pum_form": "reference",
-     "form_basis": "'별도계상' — 값이 아니라 참조 지시",
+     "pum_form": "requirement",
+     "form_basis": "사람 판정 — 인력(인)·기계(대, Q=5.4㎥/hr) 소요량 표 — 「별도계상」 은 레미콘 자재 줄 비고일 뿐",
      "basis_quantity": 1.0,
      "basis_unit": "개소",
      "basis_source": "본문",

resources/tester/test_b09_flexible_vibrator_tables.py

@@ -0,0 +1,83 @@
+"""봉상후렉시블 셋 + 12-34-1 — 2026-09-14 브레인(672 다음).
+
+같은 「봉상후렉시블(45mm) Q=5.4㎥/hr」 줄 하나가 12-12 날개벽 · 12-13 면벽 · 12-16 맨홀을 막고 있었음.
+세 표는 12-15 집수정과 같은 모양(㎥ 줄 비고 인력 + 다짐기 줄) — 판정표 한 벌에 더하고 엔진식 4611-0350 로 이음.
+실무 영월 「콘크리트타설(임도품셈 5-5)」 호표가 같은 모양: 콘크리트공 0.15·보통인부 0.27 인/㎥ + 진동기 1/Q(5.4)
+· 진동기 45φ(2.6㎾)엔진식플렉시블형 손료 252천원 × 0.5101 · 노무 0 — 엔진식·계수·조종원 없음이 실무 실증.
+
+12-34-1 콘크리트 타설(철근 진동기 포함) — 실무 호표 없음 → 브레인 판정
+  ① 「콘크리트 진동기(3.5HP) 대 2」 만 4611-0350 × 2대 · 「봉상후렉시블(45mm) 대 2」 는 같은 기계의 봉이라 안 셈
+  ② 머리 「(단위: 개소당)」 ↔ 인력 0.17·0.29 가 12-16 맨홀 ㎥당과 같고 기계도 Q ㎥/hr ⇒ ㎥당으로 읽고 사유에 나란히
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+from B09_Estimation.B09_Estimation_UnitPrice import cached_build, detail_of
+
+VIBRATOR = "X-4611-0350"
+PER_Q = Decimal(1) / Decimal("5.4")
+
+
+def _rows(build, code: str) -> dict[str, Decimal]:
+    return {
+        r["ref_code"]: Decimal(r["quantity"])
+        for r in detail_of(build, code)["rows"]
+        if r.get("ref_code")
+    }
+
+
+def test_날개벽_면벽은_콘크리트_갈래가_진동기와_함께_섬() -> None:
+    build = cached_build()
+    for code in ("B-FP-12-12#콘크리트", "B-FP-12-13#콘크리트"):
+        rows = _rows(build, code)
+        assert rows[VIBRATOR] == PER_Q and rows["1013"] == Decimal("0.15"), (code, rows)
+        assert rows["1002"] == Decimal("0.27"), (code, rows)
+        assert build.book.titles[code].unit == "㎥"
+    assert (
+        "FP-12-12" not in build.basis_missing
+    )  # 비고가 인/㎥ — 「개소당」 머리가 없어도 밑수는 ㎥
+
+
+def test_맨홀은_비고가_끝_칸이_아니어도_구체_버림_갈래() -> None:
+    build = cached_build()
+    body = _rows(build, "B-FP-12-16#구체콘크리트")
+    assert (
+        body[VIBRATOR] == PER_Q
+        and body["1013"] == Decimal("0.17")
+        and body["1002"] == Decimal("0.29")
+    )
+    lean = _rows(build, "B-FP-12-16#버림콘크리트")
+    assert lean == {"1013": Decimal("0.15"), "1002": Decimal("0.27")}, lean
+    for code in ("FP-12-12", "FP-12-13", "FP-12-16"):
+        assert "봉상후렉시블" not in " ".join(build.unattached.get(code, [])), code
+
+
+def test_12_34_1_진동기_두_대만_세고_봉은_두_번_안_셈() -> None:
+    build = cached_build()
+    rows = _rows(build, "B-FP-12-34-01")
+    assert rows[VIBRATOR] == 2 * PER_Q, rows
+    assert rows["1013"] == Decimal("0.17") and rows["1002"] == Decimal("0.29"), rows
+    from B09_Estimation.B09_Estimation_KnownGaps import known_gap_note
+
+    assert "봉상후렉시블" in known_gap_note("FP-12-34-01") and "두 번 안 셈" in known_gap_note(
+        "FP-12-34-01"
+    )
+    refs = [r.get("ref_code") for r in detail_of(build, "B-FP-12-34-01")["rows"]]
+    assert refs.count(VIBRATOR) == 1, refs  # 봉 줄이 기계로 또 안 섬(한 줄 · 2대 몫)
+
+
+def test_12_34_1_은_개소당_머리를_세제곱미터당으로_읽은_까닭을_보임() -> None:
+    from B09_Estimation.B09_Estimation_KnownGaps import known_gap_note
+
+    build = cached_build()
+    assert build.book.titles["B-FP-12-34-01"].unit == "㎥"
+    note = known_gap_note("FP-12-34-01")
+    assert "개소당" in note and "㎥당" in note and "12-16" in note, note
+
+
+def test_표의_나머지_줄은_조용히_안_사라지고_사유에_원문_그대로() -> None:
+    """손 사유로 달던 줄 목록은 판정표 자동 목록(`_unread_rows`)으로 옮김 — `test_b09_judged_unread_rows`."""
+    left = " ".join(cached_build().unattached.get("FP-12-16", []))
+    assert "원형거푸집" in left and "설치비" in left, left

resources/tester/test_b09_judged_unread_rows.py

@@ -0,0 +1,50 @@
+"""판정표가 안 읽은 줄 — 자동으로 「못 붙은 줄」 목록에 (2026-09-14 브레인 · ㉰ 앞 뿌리 고침).
+
+판정표는 적어 둔 줄만 읽음 → 나머지 줄(거푸집·철근·뚜껑·설치비·비고 …)이 사유 없이 사라지고 있었음
+(12-15 · 12-04 비고 · 12-34-1 레미콘). 표를 넣을 때마다 손으로 사유를 달면 다음 표가 또 샘.
+⇒ 판정표 공통 한 곳에서 「읽힌 줄 밖의 줄」 을 올림.
+  ㉠ 넘치지 않게 — 자원 머리(첫 줄 머리 모양) · 빈 줄 · 다짐기처럼 다른 줄이 쓴 줄은 뺌
+  ㉡ 손 사유와 안 겹치게 — 공종 사유 한 줄(`known_gap_note`)이 이미 적은 이름은 안 올림
+"""
+
+from __future__ import annotations
+
+from B09_Estimation.B09_Estimation_KnownGaps import known_gap_note
+from B09_Estimation.B09_Estimation_UnitPrice import cached_build
+
+
+def _left(build, code: str) -> str:
+    return " / ".join(build.unattached.get(code, []))
+
+
+def test_집수정_표의_거푸집_철근_뚜껑_설치비가_목록에_뜸() -> None:
+    left = _left(cached_build(), "FP-12-15")
+    for name in ("거 푸 집", "철근", "집수정 뚜껑", "설치비"):
+        assert name in left, (name, left)
+    assert "봉상후렉시블" not in left, left  # 구체 갈래가 쓴 다짐기 줄은 안 올림(㉠)
+
+
+def test_합판거푸집_비고는_글과_함께_뜨고_손_사유에_있는_사용고재는_안_겹침() -> None:
+    left = _left(cached_build(), "FP-12-04")
+    assert "비고" in left and "7m" in left, left
+    assert "사용고재" in known_gap_note("FP-12-04") and "사용고재" not in left, left  # ㉡
+    assert "횟수별" not in left, left  # 머리 줄(㉠)
+
+
+def test_토사면_고르기_자원_머리_줄은_안_뜸() -> None:
+    left = _left(cached_build(), "FP-09-19-01")
+    assert "보통인부 (인)" not in left and "공기압축기 (시간)" not in left, left
+
+
+def test_12_34_1_레미콘_별도계상_줄은_이름으로_뜸() -> None:
+    left = _left(cached_build(), "FP-12-34-01")
+    assert "콘크리트(레미콘)" in left and "자재" not in left.split(" / "), left
+
+
+def test_날개벽_면벽_맨홀은_자동_목록이_맡고_손_사유는_줄_목록을_안_되풀이() -> None:
+    build = cached_build()
+    assert "원형거푸집" in _left(build, "FP-12-16") and "기초잡석" in _left(build, "FP-12-12")
+    assert "기초잡석" in _left(build, "FP-12-13")
+    for code in ("FP-12-12", "FP-12-13", "FP-12-16"):
+        assert "거푸집" not in known_gap_note(code), code
+    assert "30%" in known_gap_note("FP-12-12")  # 줄이 아닌 [주] 는 손 사유로 남음

resources/tester/test_b09_topsoil_removal.py

@@ -0,0 +1,44 @@
+"""표토제거 답외구간 9-15-2 — 2026-09-14 브레인 ㉰ 첫째(B08 준비공 표토제거 줄이 부르는 코드).
+
+원문 L5288: T 0.2m · L 20m · E 0.4 · q0 3.2㎥ · e 0.96 · f 1/1.3 · V1 40m/분(1단) · V2 46m/분(1단) · t 0.25분
+  [주]① 무한궤도 불도저(19ton) ② q = 3.2 × e · ㎝ = L/V1 + L/V2 + 0.25 · Q1 = 60 × q × f × E / ㎝ ㎥/시간 · Q = Q1/T ㎡/시간
+  ③ 건설품셈 8-2-1 불도저 참조 → 불도저 식(`dozer_hourly_output`)을 그대로 쓰고 T 로 나눔
+⚠ 실무 영월 「표토제거 답외구간」 호표 Q=576.95 는 **E 자리에 e(0.96)를 넣은 값**으로 정확히 역산됨
+  (60 × 3.07 × 0.77 × 0.96 ÷ (1.18 × 0.2) = 576.95) · 다른 실무(봉화·대흥·소광·거창)엔 이 호표 없음 →
+  그 현장 실수 · 원문이 또렷하므로 원문 E=0.4 로 셈(2026-09-15 브레인 규칙 · 어긋남 기록)
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+from B09_Estimation.B09_Estimation_UnitPrice import cached_build
+
+
+def test_표토제거_답외구간_일위대가가_불도저_19톤_1_Q_로_섬() -> None:
+    from B09_Estimation.B09_Estimation_TopsoilRemoval import topsoil_output
+
+    q1, q = topsoil_output()
+    assert q1 == Decimal("47.92") and q == Decimal("239.60"), (q1, q)
+    book = cached_build().book
+    title = book.titles["B-FP-09-15-02"]
+    assert title.unit == "㎡"
+    rows = [
+        r for d in book.details["B-FP-09-15-02"] for r in [d, *book.details.get(d.ref_code, [])]
+    ]
+    dozer = next(r for r in rows if r.ref_code == "X-0101-0019")
+    assert dozer.quantity == Decimal(1) / q and dozer.output == q, dozer
+
+
+def test_식_줄에_T_로_나눈_것과_실무_어긋남이_적힘() -> None:
+    book = cached_build().book
+    notes = " ".join(
+        r.note
+        for d in book.details["B-FP-09-15-02"]
+        for r in [d, *book.details.get(d.ref_code, [])]
+    )
+    assert "T" in notes and "9-15-2" in notes, notes
+    from B09_Estimation.B09_Estimation_KnownGaps import known_gap_note
+
+    note = known_gap_note("FP-09-15-02")
+    assert "576.95" in note and "0.96" in note and "E=0.4" in note, note