feat(b09): 기계 수송비 회수(대수 × 왕복) 설계 입력 칸 — 원문에 공식이 없어 사유와 함께 엶

산림품셈 10-4 · 건설품셈 8-1-3 은 회당 단가 산출식만 주고 대수·횟수를 정하지 않음(전수 확인).
지어내지 않고 설계 입력으로 닫음.

· parse_trips — 비거나 0 이면 없음. 기본값을 두지 않음(1 회로 안 때움)
· transport_amount — 회수 × 회당 단가. 회수가 없으면 None(0 원으로 안 채움)
· TRIPS_NOTE — 「원문에 공식 없음 · 설계 입력 · 비우면 금액이 안 섬」 사유
· 도는 자리 넷 — 저장(PUT estimation/factors) · 산출 조건 ② · 산출 조건 화면(회당 N원 × M회) ·
  비면 transport_notes 에 사유가 붙어 못 채운 자리로 뜸
· 화면에 있던 「회수는 여기서 안 정합니다」 안내는 칸으로 바뀌어 걷음

잴 시험 먼저 빨강 확인한 뒤 고침. 전체 시험 1976 통과 · 28 건너뜀 · 1 xfail.

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

B05_Profile/B05_Profile_Api_Structures.ts

@@ -40,6 +40,8 @@ export interface StructureOptionField {
   warn_message?: string | null;
   /** 원단위 표가 아직 안 읽는 칸 — 칸 이름 옆 「표에 안 쓰임」 + 툴팁 사유. */
   not_in_table?: string | null;
+  /** 기본값의 뜻(도메인 확정값이 아닐 때) — 칸 밑 근거 한 줄. */
+  default_basis?: string | null;
 }
 
 /** 구조물 배치 폼을 어느 화면이 쓰는가 — B05 는 유무·종류·위치만, **B06/B07 은 상세

B05_Profile/B05_Profile_Structure_Types.json

@@ -727,7 +727,7 @@
           "input": "number",
           "unit": "m",
           "default": 2.0,
-          "default_basis": "제안값 2.0 — 관측 원단위 자료가 반중력식 H=2.0 한 벌뿐이라 그 값(2026-09-14 A4 · 옛 2.5 는 자료 없음)",
+          "default_basis": "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음",
           "required": false,
           "phase": "b05",
           "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"

B05_Profile/B05_Profile_UI_Drainage_Facility.ts

@@ -361,10 +361,17 @@ export function createFacilityOptionsForm(
     emit();
   });
 
+  // 10-A ⑲ 저장 규칙을 폼 머리에 드러냄 — 병합은 `_Drainage_Facility_Merge`(2026-09-14 브레인 판정).
+  const saveNote = document.createElement("p");
+  saveNote.className = "b05-structure__owner-note";
+  saveNote.textContent =
+    "[저장]은 이 폼에 있는 칸만 바꿈 — 폼에 없는 칸(집계표·구조물도로 적은 값)은 그대로 둠 · 시설 종류를 바꾸면 새로 씀";
+
   // 세월교·물넘이 항목은 **관종·관경 바로 다음**에 둔다(2026-08-30 사용자 지시 2) —
   // 월류 폭·높이 → 바닥 경사 → 수량 → 개략 단면 결과. 다른 시설에서는 전부 숨는다.
   root.append(
     grid(suggest),
+    saveNote,
     pipeRow,
     wingRow,
     ford.widthRow,

B05_Profile/B05_Profile_UI_Structures_Fields.ts

@@ -9,12 +9,23 @@
 
 import { chainageToStation, stationToChainage } from "./B05_Profile_Util_Station";
 
-export function field(labelText: string, input: HTMLElement): HTMLLabelElement {
+export function field(
+  labelText: string,
+  input: HTMLElement,
+  basis?: string | null,
+): HTMLLabelElement {
   const wrapper = document.createElement("label");
   wrapper.className = "b05-route__field";
   const caption = document.createElement("span");
   caption.textContent = labelText;
   wrapper.append(caption, input);
+  // 칸 밑 근거 한 줄 — 등록부 `default_basis`(기본값의 뜻 · 10-A 2026-09-14 사용자 확정).
+  if (basis) {
+    const note = document.createElement("small");
+    note.className = "b05-structure__basis";
+    note.textContent = basis;
+    wrapper.append(note);
+  }
   return wrapper;
 }
 
@@ -45,6 +56,8 @@ interface OptionShape {
   warn_message?: string | null;
   /** 원단위 표가 아직 안 읽는 칸 — 툴팁이 이 사유를 먼저 보임. */
   not_in_table?: string | null;
+  /** 기본값의 뜻 — 칸 밑 근거 한 줄. */
+  default_basis?: string | null;
 }
 
 /**

B05_Profile/B05_Profile_UI_Structures_Panel.ts

@@ -332,7 +332,7 @@ export function createStructuresSection(
         input.classList.add("is-locked");
         input.title = "지금은 고를 수 없는 항목입니다.";
       }
-      optionRow.append(field(label, input));
+      optionRow.append(field(label, input, option.default_basis));
       input.addEventListener("change", () => liveCommit());
       optionInputs.push({
         key: option.key,

B05_Profile/B05_Profile_UI_Style_Structures.css

@@ -214,6 +214,18 @@
   line-height: 1.5;
 }
 
+/* 칸 밑 근거 한 줄 — 등록부 `default_basis`(10-A). 회색 작은 글씨. */
+.b05-structure__basis {
+  color: var(--color-text-muted, #9aa1ad);
+  font-size: var(--text-caption, 12px);
+  line-height: 1.3;
+}
+
+/* 근거 줄로 옆 칸이 길어져도 [제안값 넣기]가 세로로 늘지 않게. */
+.b05-structure__suggest {
+  align-self: start;
+}
+
 /* 시작·기준·종료 측점 = 3행. 한 행은 [라벨][측점][+거리] 가로 배치
  * (2026-08-17 사용자 지시 2). */
 .b05-structure__position-row {

B08_Quantity/B08_Quantity_Engine_Formwork.py

@@ -105,15 +105,17 @@ def annotate(
                 component["reuse_note"] = NOTE_REUSE_MISSING
             continue
         count = entry.get("reuse_count")
+        # 근거 — 대개 1-7-1 분류 · 그 공종 표가 직접 적었으면 그 표(집수정 12-15 · 2026-09-14).
+        basis = str(entry.get("basis") or "품셈 1-7-1")
         for component in targets:
             component["reuse_count"] = count
             component["reuse_note"] = (
-                f"품셈 1-7-1 {count}회 — 「{entry.get('matched_example')}」"
+                f"{basis} {count}회 — 「{entry.get('matched_example')}」"
                 if count
                 else NOTE_NOT_APPLICABLE
             )
         if count:
-            notes.append(f"{structure.get('name') or type_id} 거푸집 {count}회 (품셈 1-7-1)")
+            notes.append(f"{structure.get('name') or type_id} 거푸집 {count}회 ({basis})")
         else:
             missing.append(type_id)
     return notes, sorted(set(missing))

B08_Quantity/B08_Quantity_Engine_Handoff_Boundaries.py

@@ -38,11 +38,11 @@ def _pickers(structure: dict[str, Any], mapping: WorkItemMapping) -> list[tuple[
     """이 구조물의 성분을 **이름으로 집는** 공종 줄 — (자리, 이름들). 집는 조건은 각 빌더와 같다."""
     type_id = str(structure.get("type_id") or "")
     entry = mapping.for_structure(type_id) or {}
-    composite = mapping.composite_for(type_id)
+    composite = mapping.composite_for(type_id, structure)
     found: list[tuple[str, set[str]]] = []
     if entry.get("billing_component"):
         found.append(("구조물 줄", {str(entry["billing_component"])}))
-    if composite and not entry.get("work_item_code"):
+    if composite:  # 걸린 묶음은 곧장 잇는 코드보다 위(빌더와 같은 조건)
         for part in composite.get("parts") or []:
             if isinstance(part, dict):
                 label = f"묶음 조각 「{part.get('name') or part.get('code')}」"

B08_Quantity/B08_Quantity_Engine_Handoff_Mapping.py

@@ -271,13 +271,20 @@ class WorkItemMapping:
                 return row
         return None
 
-    def composite_for(self, type_id: str) -> dict[str, Any] | None:
+    def composite_for(
+        self, type_id: str, structure: dict[str, Any] | None = None
+    ) -> dict[str, Any] | None:
         """품셈에 그 이름의 공종이 없어 **여러 공종을 묶는** 자리인가.
 
         빈 코드로 두면 「매핑을 못 찾은 줄」과 구별이 안 된다 — 묶음을 적어 구별한다.
         """
+        options = (structure or {}).get("options") or {}
         for row in self.composite.get("items") or []:
-            if row.get("type_id") == type_id:
+            # `when` — 같은 종류라도 그 제원일 때만 묶음(콘크리트 집수정만 12-15 조립 · 09-14 ⑸).
+            when = row.get("when") or {}
+            if row.get("type_id") == type_id and all(
+                str(options.get(key) or "") == str(value) for key, value in when.items()
+            ):
                 return row
         return None
 
@@ -382,6 +389,30 @@ def composite_quantities(
                 entry["not_ready"] = True
                 entry["why"] = why
                 missing.append({"code": spec.get("code"), "reason": why})
+        if suffix == "formwork_reuse":
+            # 12-4 사용횟수 갈래 — B08 이 성분에 단 횟수(`Formwork.annotate`) 그대로(한 벌 · 09-14).
+            counts = {
+                component.get("reuse_count")
+                for component in structure.get("components") or []
+                if str(component.get("name") or "").strip() in found
+            }
+            count = next(iter(counts)) if len(counts) == 1 else None
+            if isinstance(count, int) and count > 0:
+                entry["kind"] = f"{count}회"
+                entry["kind_basis"] = next(
+                    (
+                        str(component.get("reuse_note") or "")
+                        for component in structure.get("components") or []
+                        if str(component.get("name") or "").strip() in found
+                    ),
+                    "",
+                )
+                entry["code"] = f"{spec.get('code')}#{count}회"
+            elif found:
+                why = "거푸집 사용횟수가 없거나 둘 이상이라 12-4 갈래를 못 고름"
+                entry["not_ready"] = True
+                entry["why"] = why
+                missing.append({"code": spec.get("code"), "reason": why})
         if suffix == "rebar_complexity":
             # 갈래는 원문이 정한다 — 화면·인계에 이름과 근거를 함께 실어 사람이 검증하게 한다.
             complexity, why = rebar_complexity(
@@ -459,10 +490,12 @@ def rebar_complexity(
             continue
         if row.get("form") == form:
             if row.get("class"):
-                return str(row["class"]), f"품셈 12-3 [주]① 「{row.get('matched')}」"
+                basis = row.get("basis") or "품셈 12-3 [주]①"
+                return str(row["class"]), f"{basis} 「{row.get('matched')}」"
             return None, str(row.get("why") or "원문 예시에 없음")
     if fallback and fallback.get("class"):
-        return str(fallback["class"]), f"품셈 12-3 [주]① 「{fallback.get('matched')}」"
+        basis = fallback.get("basis") or "품셈 12-3 [주]①"  # 그 공종 표가 직접 적으면 그 표(12-15)
+        return str(fallback["class"]), f"{basis} 「{fallback.get('matched')}」"
     from B08_Quantity.B08_Quantity_Wording import type_label
 
     detail = f"({form})" if form else "(형식이 아직 입력되지 않음)"

B08_Quantity/B08_Quantity_Engine_Handoff_Rows.py

@@ -433,7 +433,11 @@ def _structure_rows(
         #   m 수량에 곱해 **2.6배** 금액이 섰다(2026-09-08 실증). 어느 성분으로 세는지는
         #   매핑이 말한다(`billing_component`) — 코드가 짐작하지 않는다.
         billing = _component_billing(structure, entry)
-        composite = mapping.composite_for(type_id) if code is None else None
+        composite = mapping.composite_for(type_id, structure)
+        if composite:
+            code = None  # 묶음이 걸리면 곧장 잇는 코드보다 위(콘크리트 집수정 12-15 조립 · 09-14)
+            if composite.get("outside_note"):
+                class_basis = " · ".join(p for p in (class_basis, composite["outside_note"]) if p)
         kind = structure_kind(structure) if composite else None
         parts: list[dict[str, Any]] | None = None
         parts_missing: list[dict[str, Any]] = []
@@ -600,7 +604,7 @@ def _placing_rows(
         #   2026-09-08 B09 가 「철근이 겹치나」를 물어 그 김에 드러난 자리다 —
         #   철근은 안 겹치고(자재는 재료·묶음 조각은 품, 재료 0원) **타설이 겹쳤다.**
         #   ⚠ 묶음이 아직 미확보라 지금은 값이 안 걸렸을 뿐, 묶음이 서는 날 두 번이 된다.
-        if mapping.composite_for(str(structure.get("type_id") or "")) or structure.get(
+        if mapping.composite_for(str(structure.get("type_id") or ""), structure) or structure.get(
             "unconfirmed"
         ):
             continue  # 기본값으로 선 구조물도 — 금액에 안 듦

B08_Quantity/B08_Quantity_Engine_Handoff_Trench.py

@@ -166,7 +166,7 @@ def rubble_base_rows(
     total = 0.0
     bases: list[str] = []
     for structure in unit_quantity_table.get("structures") or []:
-        if mapping.composite_for(str(structure.get("type_id") or "")) or structure.get(
+        if mapping.composite_for(str(structure.get("type_id") or ""), structure) or structure.get(
             "unconfirmed"
         ):
             continue  # 묶음 조각이 품음 · 기본값으로 선 구조물은 금액에 안 듦

B08_Quantity/B08_Quantity_Engine_StructureLibrary.py

@@ -19,8 +19,9 @@ from typing import Any
 from B08_Quantity.B08_Quantity_Engine_StructureTemplate import TEMPLATE_DIR
 from config.config_system import STORAGE_BASE_DIR
 
-#: 단 이름 — 고르개에 이 차례로 보임(가까운 것부터).
-TIERS = ("personal", "company", "program")
+#: 단 이름 — 고르개에 이 차례로 보임(가까운 것부터). `received` = 동료가 보낸 것(공유 · 개인 단을 안 덮음).
+TIERS = ("personal", "received", "company", "program")
+RECEIVED_SUBDIR = "library_received"
 #: 항목 코드 — 파일 이름이 되므로 모양을 먼저 봄(경로 벗어남 막이).
 CODE_PATTERN = re.compile(r"^AX-ST-[0-9a-f]{8}$")
 LIBRARY_SUBDIR = "library"
@@ -28,6 +29,9 @@ LIBRARY_SUBDIR = "library"
 
 #: 프로그램 기본 작업본 자리 — 회사 번호 폴더와 안 겹치게 밑줄 이름.
 PROGRAM_SUBDIR = "_program"
+#: 프로그램 기본 발행본에서 뺄 출처 칸 — 어느 공사인지(2026-09-14 브레인 판정 ②).
+ORIGIN_MASKED_KEYS = ("project", "file")
+ORIGIN_MASKED_NOTE = "원문에서 뽑음 — 공사명은 발행 시 가림"
 
 
 def program_library_dir() -> Path:
@@ -52,6 +56,7 @@ def tier_dirs(company_id: Any, user_id: Any) -> dict[str, Path]:
         company = Path(STORAGE_BASE_DIR).resolve() / str(company_id)
         if user_id is not None:
             dirs["personal"] = company / str(user_id) / LIBRARY_SUBDIR
+            dirs["received"] = company / str(user_id) / RECEIVED_SUBDIR
         dirs["company"] = company / LIBRARY_SUBDIR
     dirs["program"] = program_library_dir()
     return dirs
@@ -175,9 +180,12 @@ def save_personal(
     overrides: dict[str, Any] | None,
     unit_price_rows: list[dict[str, Any]] | None = None,
     tier: str = "personal",
+    name: str | None = None,
 ) -> str:
     """[내 라이브러리에 저장]·발행 — 양식 + 고친 식·줄 조합을 **그 단에 한 벌**로 씀. 코드.
 
+    ⚠ `name` — 이름표(화면이 「종류 + 제원 요약」을 제안 · 사용자가 고침 · 10-A ⑫). 비면 양식 이름.
+
     ⚠ 반대 방향(작업본 → 라이브러리)이라 프로젝트는 안 바꿈(브레인 판정 Ⓑ).
     ⚠ 같은 종류가 있으면 **그 코드로 덮어씀** — 지금은 종류당 하나(판정 Ⓐ).
     ⚠ `tier` — 회사(MASTER)·프로그램 기본(SYSTEM_ADMIN) 발행도 같은 모양(2026-09-14 브레인 승인).
@@ -194,6 +202,12 @@ def save_personal(
         for row in overridden_rows(template, overrides)
     ]
     item = {k: v for k, v in template.items() if k != "imported_from"}
+    if name and name.strip():
+        item["name"] = name.strip()
+    if tier == "program" and isinstance(item.get("origin"), dict):
+        # 모든 회사로 가는 발행본 — 원문 공사명·파일명은 안 실음(원본·회사 단은 그대로 · 브레인 ②③).
+        kept = {k: v for k, v in item["origin"].items() if k not in ORIGIN_MASKED_KEYS}
+        item["origin"] = {**kept, "masked": ORIGIN_MASKED_NOTE}
     if unit_price_rows is not None:
         item["unit_price"] = {**(item.get("unit_price") or {}), "rows": unit_price_rows}
     _write(folder, {**item, "code": code, "library_tier": tier, "rows": rows})
@@ -223,3 +237,13 @@ def pin_program_templates(project_root: str | Path) -> int:
             import_item(project_root, item, "program")
             count += 1
     return count
+
+
+def share_item(item: dict[str, Any], to_folder: Path, sender: dict[str, Any]) -> str:
+    """[동료에게 보내기] — 내 개인 단 항목을 동료의 **받음 단**에 복사(개인 단을 안 덮음 · 브레인 판정 ①).
+
+    코드는 그대로(다시 보내면 같은 자리를 새로 씀) · 출처 공사명도 그대로(같은 회사 · 판정 ③).
+    """
+    body = {k: v for k, v in item.items() if k != "imported_from"}
+    _write(to_folder, {**body, "library_tier": "received", "received_from": sender})
+    return str(body["code"])

B08_Quantity/B08_Quantity_Engine_StructureTemplate.py

@@ -441,6 +441,8 @@ def apply_templates(
             "name": template.get("name"),
             "code": template.get("code"),
             "imported_from": template.get("imported_from"),
+            # 발행 확인창이 「○○공사에서 뽑은 것 — 공사명은 빼고 발행」을 보이게(브레인 ②).
+            "origin_project": (template.get("origin") or {}).get("project"),
         }
         sheet["formula_sheet"] = body
         # 실무 관측값 같은 「대안 후보」 — 값을 바꾸지 않고 칸 옆에 보이기만(판정 Ⓑ).

B08_Quantity/B08_Quantity_Engine_UnitQuantity_Masonry.py

@@ -422,7 +422,7 @@ def stone_masonry(
     notes.append(
         f"막자갈 뒷채움 폭이 정본(`04.구조도(기슭막이).xls`) 값 상 {backfill_top:g} · "
         f"하 {backfill_bottom:g}m 붙박이입니다 — 구조물 제원에 뒷채움 폭 칸이 없습니다"
-        "(소광리는 같은 식에 0.30/0.60 을 씁니다)"
+        "(소광리는 같은 식에 0.30/0.60 을 씁니다) · 칸을 새로 두는 것은 B05 등록부 몫"
     )
     # ⚠ 근거 구간 밖은 **값이 서되 그 사실이 보여야 한다** — 값은 계속 나오므로 사유가
     #   없으면 아무도 못 본다(2026-09-09 그물 침).

B08_Quantity/B08_Quantity_Router_StmateLibrary.py

@@ -121,7 +121,7 @@ class LibraryCloneRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     type_id: str = Field(min_length=1, max_length=100)
-    tier: Literal["company", "program"]
+    tier: Literal["received", "company", "program"]
     code: str = Field(pattern=r"^AX-ST-[0-9a-f]{8}$")
 
 
@@ -149,3 +149,71 @@ async def clone_library_item(
     body["cloned_from"] = {"tier": payload.tier, "code": payload.code, "name": item.get("name")}
     code = await asyncio.to_thread(save_item_personal, folder, body)
     return JSONResponse(content={"status": "success", "code": code, "name": item.get("name")})
+
+
+async def _company_members(company_id: int) -> list[dict[str, Any]]:
+    """같은 회사 구성원 — B01 구성원 저장소를 읽기만(시험이 갈아 끼움)."""
+    from B01_Dashboard.B01_Dashboard_Repository_Members import list_company_members
+
+    return await list_company_members(company_id)
+
+
+@router.get("/{project_id}/quantity/structure-sheets/library/colleagues")
+async def list_library_colleagues(
+    project_id: UUID, session: dict[str, Any] = Depends(verify_session)
+) -> JSONResponse:
+    """④ 보낼 동료 — 같은 회사에서 나를 뺀 사람(이름만)."""
+    company_id = session.get("company_id")
+    if company_id is None:
+        return _error(403, "회사에 속한 사용자만 보냅니다.")
+    members = await _company_members(int(company_id))
+    colleagues = [
+        {"id": m["id"], "name": m.get("name") or m.get("email") or ""}
+        for m in members
+        if m["id"] != session.get("user_id")
+    ]
+    return JSONResponse(content={"status": "success", "colleagues": colleagues})
+
+
+class LibraryShareRequest(BaseModel):
+    """내 개인 단 항목 하나를 같은 회사 동료에게."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type_id: str = Field(min_length=1, max_length=100)
+    code: str = Field(pattern=r"^AX-ST-[0-9a-f]{8}$")
+    to_user_id: int
+
+
+@router.put("/{project_id}/quantity/structure-sheets/library/share")
+async def share_library_item(
+    project_id: UUID,
+    payload: LibraryShareRequest,
+    session: dict[str, Any] = Depends(verify_session),
+) -> JSONResponse:
+    """④ [동료에게 보내기] — 받는 쪽 「받음」 단에 복사(PLAN 4장 공유 · 브레인 판정 ①)."""
+    from B08_Quantity.B08_Quantity_Engine_StructureLibrary import (
+        RECEIVED_SUBDIR,
+        find_item,
+        share_item,
+        tier_dirs,
+    )
+
+    company_id = session.get("company_id")
+    dirs = tier_dirs(company_id, session.get("user_id"))
+    if "personal" not in dirs:
+        return _error(403, "회사에 속한 사용자만 보냅니다.")
+    if payload.to_user_id == session.get("user_id"):
+        return _error(400, "나에게는 보내지 않습니다.")
+    members = {m["id"]: m for m in await _company_members(int(company_id))}
+    target = members.get(payload.to_user_id)
+    if target is None:
+        return _error(404, "같은 회사에서 받는 사람을 찾지 못했습니다.")
+    item = await asyncio.to_thread(find_item, dirs, "personal", payload.code)
+    if item is None or item.get("type_id") != payload.type_id:
+        return _error(404, "보낼 내 항목을 찾지 못했습니다.")
+    me = members.get(session.get("user_id")) or {}
+    sender = {"user_id": session.get("user_id"), "name": me.get("name") or me.get("email") or ""}
+    to_folder = dirs["personal"].parents[1] / str(payload.to_user_id) / RECEIVED_SUBDIR
+    code = await asyncio.to_thread(share_item, item, to_folder, sender)
+    return JSONResponse(content={"status": "success", "code": code, "to": target.get("name") or ""})

B08_Quantity/B08_Quantity_Router_StructureSheet.py

@@ -327,7 +327,7 @@ class LibraryImportRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     type_id: str = Field(min_length=1, max_length=100)
-    tier: Literal["personal", "company", "program"]
+    tier: Literal["personal", "received", "company", "program"]
     code: str = Field(pattern=r"^AX-ST-[0-9a-f]{8}$")
 
 
@@ -417,6 +417,7 @@ class LibrarySaveRequest(BaseModel):
 
     sheet_key: str
     tier: Literal["personal", "company", "program"] = "personal"
+    name: str | None = Field(default=None, max_length=200)  # 이름표(10-A ⑫) · 비면 양식 이름
 
 
 @router.put("/{project_id}/quantity/structure-sheets/library/personal")
@@ -430,10 +431,7 @@ async def put_structure_library_personal(
 
     ⚠ 프로젝트 작업본은 안 바꿈 — 반대 방향(작업본 → 개인 단)이라(판정 Ⓑ).
     """
-    from B08_Quantity.B08_Quantity_Engine_StructureLibrary import (
-        project_templates,
-        save_personal,
-    )
+    from B08_Quantity.B08_Quantity_Engine_StructureLibrary import project_templates, save_personal
     from B08_Quantity.B08_Quantity_Engine_StructureTemplate import OVERRIDES_KEY, template_of
     from B08_Quantity.B08_Quantity_Engine_StructureUnitPrice import ROWS_KEY
     from common_util.common_util_project_settings import quantity_settings
@@ -461,7 +459,8 @@ async def put_structure_library_personal(
     overrides = (settings.get(OVERRIDES_KEY) or {}).get(type_id)
     # ⛔ 수동 단가(`MANUAL_KEY`)는 안 넘김 — 프로젝트의 값(브레인 판정).
     rows = (settings.get(ROWS_KEY) or {}).get(type_id)
-    code = await asyncio.to_thread(save_personal, folder, template, overrides, rows, payload.tier)
+    tier, name = payload.tier, payload.name
+    code = await asyncio.to_thread(save_personal, folder, template, overrides, rows, tier, name)
     return JSONResponse(content={"status": "success", "code": code, "edited": len(overrides or {})})
 
 

B08_Quantity/B08_Quantity_UI_EarthworkGrid.ts

@@ -100,6 +100,8 @@ export interface QuantitySettings {
   ancillary_counts?: Record<string, number | null>;
   /** 임목축적 등급 — `"소림"`·`"중림"`·`"밀림"`(품셈 9-21 [주]①). 본수가 아니라 축적이다. */
   stand_volume_class?: string | null;
+  /** 제근 굴착기 크기 — `"0.2"`·`"0.7"`(서버 선택지 안) · 비면 「안 정함」. */
+  root_removal_excavator_m3?: string | null;
   /** 면고르기 갈래(서버 선택지 안) · 면적 덮어쓰기(㎡, 없음 = 파종 면적). */
   face_dressing_cut_class?: string | null;
   face_dressing_fill_class?: string | null;
@@ -162,6 +164,11 @@ export interface EarthworkTable {
   conversion_factor_choices?: Record<string, ConversionFactorChoice>;
   /** 면고르기 갈래 선택지 — 품셈 9-19-1 원문 표 두 벌(서버 한 곳). 화면은 그대로 보임. */
   face_dressing_choices?: { cut: string[]; fill: string[] };
+  /** 제근 굴착기 크기 선택지·제안(회색 · [제안값 넣기]) — 서버 한 곳. */
+  root_removal_excavator_choices?: {
+    choices: string[];
+    suggested?: { value: string; basis: string };
+  };
   /** 품셈 암종별 범위(안내용). 정의처가 서버라 내려받아 보인다. */
   conversion_factor_pumsem_ranges?: PumsemRange[];
   /** 도쟈 한계거리 — 지금 값·기본값·근거(서버가 정본). 종무대 20 m 는 규정이라 값만 보인다. */

B08_Quantity/B08_Quantity_UI_Page.ts

@@ -42,6 +42,7 @@ import { renderStructureSheets } from "./B08_Quantity_UI_StructureSheet";
 import { renderStructureSummary } from "./B08_Quantity_UI_StructureSummary";
 import { appendTreeWasteFields } from "./B08_Quantity_UI_Side_TreeWaste";
 import { appendFaceDressingFields } from "./B08_Quantity_UI_Side_FaceDressing";
+import { appendRootRemovalFields } from "./B08_Quantity_UI_Side_RootRemoval";
 import { appendBenchCutFields } from "./B08_Quantity_UI_Side_BenchCut";
 
 /** locale 헬퍼 */
@@ -109,6 +110,7 @@ async function saveQuantitySettings(projectId: string, draft: DraftSettings): Pr
         // `""` 는 기본(노면 + 절토)으로 되돌림 — 서버가 None 으로 둔다.
         topsoil_target: draft.topsoil_target,
         stand_volume_class: draft.stand_volume_class,
+        root_removal_excavator_m3: draft.root_removal_excavator_m3,
         // 면고르기 — 갈래 `""`·면적 `null` 도 그대로(「안 정함」·「파종 면적 그대로」로 되돌리는 길).
         face_dressing_cut_class: draft.face_dressing_cut_class,
         face_dressing_fill_class: draft.face_dressing_fill_class,
@@ -307,6 +309,8 @@ interface DraftSettings {
   ancillary_counts: Record<string, number | null>;
   // 임목축적 등급 — "소림"·"중림"·"밀림". ⚠ 본수가 아니라 축적이다(품셈 9-21 [주]①).
   stand_volume_class: string;
+  // 제근 굴착기 크기 — "0.2"·"0.7"(서버 선택지) · `""` 는 「안 정함」. 칸은 `_Side_RootRemoval`.
+  root_removal_excavator_m3: string;
   // 면고르기 — 갈래 둘(서버 선택지) · 면적 덮어쓰기 둘(`null` = 파종 면적). 칸은 `_Side_FaceDressing`.
   face_dressing_cut_class: string;
   face_dressing_fill_class: string;
@@ -637,6 +641,12 @@ function buildQuantitySidePanel(
     ),
   );
   panel.append(hintRow(L("B08_Quantity_Side_StandVolume_Hint")));
+  appendRootRemovalFields(panel, draft, table?.root_removal_excavator_choices, {
+    field,
+    optionalNumberField,
+    selectField,
+    hintRow,
+  });
 
   // ── 부대시설 개소 — ⚠ **산식으로 만들지 않는다**(확정 13). 넣어야 줄이 선다 ──
   panel.append(field(L("B08_Quantity_Side_Ancillary"), ""));
@@ -1021,6 +1031,7 @@ export async function renderB08Quantity(root: HTMLElement): Promise<void> {
     topsoil_haul_distance_m: (stored.topsoil_haul_distance_m as number | null) ?? null,
     topsoil_target: (stored.topsoil_target as string) ?? "",
     stand_volume_class: (stored.stand_volume_class as string) ?? "",
+    root_removal_excavator_m3: (stored.root_removal_excavator_m3 as string) ?? "",
     face_dressing_cut_class: (stored.face_dressing_cut_class as string) ?? "",
     face_dressing_fill_class: (stored.face_dressing_fill_class as string) ?? "",
     face_dressing_fill_area_m2: (stored.face_dressing_fill_area_m2 as number | null) ?? null,

B08_Quantity/B08_Quantity_UI_Side_RootRemoval.ts

@@ -0,0 +1,59 @@
+/* =============================================================================
+ * B08_Quantity_UI_Side_RootRemoval.ts
+ * 산출 조건 「제근 굴착기 크기」 칸 — 임목축적 등급 바로 밑(PLAN 10-A · 9-21 크기 칸 서버 64a52df6).
+ *
+ * 페이지 본문(`B08_Quantity_UI_Page.ts`)이 700줄을 넘어 새 칸을 이 파일로 뺌(CLAUDE.md 4장).
+ * ⚠ 선택지·제안은 **서버가 내려준 그대로**(`root_removal_excavator_choices`) — 화면에 다시 적지 않음.
+ * ⚠ 스스로 안 고름 — 첫 보기가 「안 정함」이고 비면 뿌리뽑기 줄이 입력 사유로 섬. 제안 0.7 은
+ *   회색 근거 + [제안값 넣기]를 **누른 때만**(면고르기 성토면과 같은 모양).
+ * ========================================================================== */
+
+import { ui_locales, currentLanguageIndex } from "@ui/ui_template_locale";
+import { createButton } from "@ui/ui_template_elements";
+import type { SideFieldHelpers } from "./B08_Quantity_UI_Side_TreeWaste";
+
+function L(key: keyof typeof ui_locales): string {
+  return ui_locales[key][currentLanguageIndex];
+}
+
+export interface RootRemovalChoices {
+  choices: string[];
+  suggested?: { value: string; basis: string };
+}
+
+export function appendRootRemovalFields(
+  panel: HTMLElement,
+  draft: { root_removal_excavator_m3: string; dirty: boolean },
+  choices: RootRemovalChoices | undefined,
+  h: SideFieldHelpers,
+): void {
+  if (!choices) return;
+  const row = h.selectField(
+    L("B08_Quantity_Side_RootRemoval_Label"),
+    draft.root_removal_excavator_m3,
+    [
+      { value: "", label: L("B08_Quantity_RootRemoval_Unset") },
+      ...choices.choices.map((size) => ({ value: size, label: `${size}㎥` })),
+    ],
+    (picked) => {
+      draft.root_removal_excavator_m3 = picked;
+      draft.dirty = true;
+    },
+  );
+  panel.append(row);
+  const suggested = choices.suggested;
+  if (!suggested?.value) return;
+  panel.append(
+    h.hintRow(`${L("B08_Quantity_RootRemoval_Suggest")} ${suggested.value}㎥ — ${suggested.basis}`),
+    createButton({
+      label: L("B08_Quantity_RootRemoval_FillSuggested"),
+      variant: "ghost",
+      onClick: () => {
+        const select = row.querySelector("select");
+        if (select) select.value = suggested.value;
+        draft.root_removal_excavator_m3 = suggested.value;
+        draft.dirty = true;
+      },
+    }),
+  );
+}

B08_Quantity/B08_Quantity_UI_StructureSheet.ts

@@ -86,6 +86,8 @@ export interface StructureSheet extends StandardSheetSpec {
     name: string;
     code?: string | null;
     imported_from?: string | null;
+    /** 뽑아 온 원문 공사명(STmate 고정형) — 프로그램 기본 발행 때 가림. */
+    origin_project?: string | null;
   };
   /** 화면이 조작 중 왕복 없이 다시 풀 장 한 벌(L=1, 고친 식 얹힘). */
   formula_sheet?: FormulaSheet;
@@ -260,7 +262,14 @@ function sheetBody(
           : "양식 없음(지금 전개)"),
     ),
     // 실무 시트 머리의 「m당」·「개소당」 — 종류마다 다름(통일하지 않음).
-    el("span", "b08-grid__caption", sheet.unit_label),
+    el(
+      "span",
+      "b08-grid__caption",
+      // 10-A ⑯ 양식은 L=1 로 풂(`replace_with_templates` · m당 양식만) — 규칙을 머리에 드러냄.
+      sheet.library_item && sheet.unit_label === "m당"
+        ? `m당 — 반올림은 m당 값에 걸고 수량 = m당 × 연장`
+        : sheet.unit_label,
+    ),
   );
   // ㉱ 규격 다름 — 미확정과 같은 급(빨간 테두리 + 배지). 금액은 서고 막지 않음.
   if (sheet.spec_mismatch) {
@@ -422,6 +431,8 @@ export function renderStructureSheets(projectId: string | null): HTMLElement {
             sheetKey: sheet.key,
             typeId: sheet.library_item.type_id,
             currentCode: sheet.library_item.code ?? null,
+            originProject: sheet.library_item.origin_project,
+            defaultName: sheet.title,
             isDirty: () => dirty,
             confirmTake: () => {
               const edited = editedRows(sheet);

B08_Quantity/B08_Quantity_UI_StructureSheet_Formula.ts

@@ -171,7 +171,7 @@ export function formulaTable(
     saveButton.disabled = !dirty;
     discardButton.disabled = !dirty;
     status.textContent = dirty
-      ? "저장 안 한 식 있음 — 값은 이 화면 계산(저장하면 서버가 다시 셈 · 같은 양식의 장 모두에 걸림)"
+      ? "저장 안 한 식 있음 — 값은 이 화면 계산(저장하면 서버가 다시 셈 · 같은 양식의 장 모두에 걸림 · 고친 식은 이 양식·프로젝트에 묶여 제원(높이 등)을 바꿔도 따라감)"
       : "";
     onDirty(dirty);
   };

B08_Quantity/B08_Quantity_UI_StructureSheet_Library.ts

@@ -10,9 +10,16 @@
 import { API_BASE_URL } from "@config/config_frontend";
 import { buildStmatePanel } from "./B08_Quantity_UI_StructureSheet_Stmate";
 
-const TIER_LABELS: Record<string, string> = { personal: "개인", company: "회사", program: "기본" };
+const TIER_LABELS: Record<string, string> = {
+  personal: "개인",
+  received: "받음",
+  company: "회사",
+  program: "기본",
+};
 /** 항목 종류 배지 — 양식형 = 제원을 바꾸면 수량이 다시 남 · 고정형 = 박힌 수량(명세 13장). */
 const KIND_LABELS: Record<string, string> = { form: "양식형", fixed: "고정형" };
+/** 이름표 — 「종류 + 제원 요약」을 미리 채워 두고 고치게 함(10-A ⑫ · 코드는 난수라 이름이 흔들려도 안전). */
+const NAME_TAG_HINT = "이름표(종류 + 제원 요약 · 고칠 수 있음 · 비우면 양식 이름):";
 
 interface LibraryItem {
   tier: string;
@@ -52,6 +59,10 @@ export interface LibraryPanelOptions {
   /** 저장 안 한 식이 있으면 [내 라이브러리에 저장]을 막음 — 저장된 식만 개인 단으로 감. */
   isDirty: () => boolean;
   onImported: (notes: string[]) => Promise<void>;
+  /** 이 장 양식이 뽑아 온 원문 공사명 — 프로그램 기본 발행 확인창에 「빼고 발행」을 알림. */
+  originProject?: string | null;
+  /** 저장·발행 이름표 제안 — 장 이름(종류 + 제원 요약). */
+  defaultName: string;
 }
 
 /** 가져오기 · [내 라이브러리에 저장] · [내 것 지우기] 칸. 개인 단 두 단추는 프로젝트를 안 바꿈. */
@@ -88,10 +99,63 @@ export function buildLibraryPanel(options: LibraryPanelOptions): HTMLElement {
   clone.hidden = true;
   /** 목록을 다시 받은 뒤 보일 한 줄 — 받는 동안 상태 줄이 지워져 복제 결과가 사라지지 않게. */
   let afterLoad = "";
+  // 공유 — 내 개인 단 항목을 같은 회사 동료의 「받음」 단으로(브레인 판정 ①). 동료는 누를 때 받음.
+  const send = document.createElement("button");
+  send.type = "button";
+  send.className = "b08-quantity__tab";
+  send.textContent = "동료에게 보내기";
+  send.hidden = true;
+  const who = document.createElement("select");
+  who.className = "b08-spec__input";
+  who.hidden = true;
   const syncClone = (): void => {
     const [tier] = list.value.split("|");
     clone.disabled = tier === "personal";
+    send.disabled = tier !== "personal";
   };
+  send.addEventListener("click", () => {
+    const [tier, code] = list.value.split("|");
+    if (tier !== "personal" || !code) return;
+    void (async () => {
+      send.disabled = true;
+      try {
+        if (who.hidden) {
+          const { colleagues } = await readJson<{ colleagues: { id: number; name: string }[] }>(
+            await fetch(libraryUrl(projectId, "/colleagues"), { credentials: "include" }),
+          );
+          who.replaceChildren(...colleagues.map((c) => new Option(c.name, String(c.id))));
+          who.hidden = colleagues.length === 0;
+          status.textContent = colleagues.length
+            ? "받을 동료를 고르고 한 번 더 누를 것"
+            : "보낼 동료가 없음";
+          return;
+        }
+        const label = list.selectedOptions[0]?.textContent ?? "";
+        const name = who.selectedOptions[0]?.textContent ?? "";
+        if (
+          !window.confirm(
+            `「${label}」을 ${name}에게 보냄 — 받는 쪽 목록에 「받음」으로 뜸 · 그 사람 것은 안 덮음`,
+          )
+        ) {
+          return;
+        }
+        await readJson(
+          await fetch(libraryUrl(projectId, "/share"), {
+            method: "PUT",
+            credentials: "include",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type_id: typeId, code, to_user_id: Number(who.value) }),
+          }),
+        );
+        who.hidden = true;
+        status.textContent = `${name}에게 보냄`;
+      } catch (error) {
+        status.textContent = error instanceof Error ? error.message : "보내지 못함";
+      } finally {
+        syncClone();
+      }
+    })();
+  });
   list.addEventListener("change", syncClone);
   clone.addEventListener("click", () => {
     const [tier, code] = list.value.split("|");
@@ -147,7 +211,7 @@ export function buildLibraryPanel(options: LibraryPanelOptions): HTMLElement {
             return option;
           }),
         );
-        list.hidden = take.hidden = clone.hidden = items.length === 0;
+        list.hidden = take.hidden = clone.hidden = send.hidden = items.length === 0;
         syncClone();
         // 발행 단추 — 서버가 준 권한대로만 보임(회사 = 마스터 · 기본 = 시스템 관리자).
         toCompany.hidden = !canPublish?.company;
@@ -212,17 +276,17 @@ export function buildLibraryPanel(options: LibraryPanelOptions): HTMLElement {
   };
   const save = personal("내 라이브러리에 저장", async () => {
     if (isDirty()) return "저장 안 한 식이 있음 — [식 저장] 먼저";
-    if (
-      !window.confirm("이 장의 양식과 고친 식을 내 라이브러리에 저장 — 같은 종류가 있으면 덮어씀")
-    ) {
-      return "";
-    }
+    const tag = window.prompt(
+      `이 장의 양식과 고친 식을 내 라이브러리에 저장 — 같은 종류가 있으면 덮어씀\n${NAME_TAG_HINT}`,
+      options.defaultName,
+    );
+    if (tag === null) return "";
     const result = await readJson<{ edited: number }>(
       await fetch(libraryUrl(projectId, "/personal"), {
         method: "PUT",
         credentials: "include",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ sheet_key: sheetKey }),
+        body: JSON.stringify({ sheet_key: sheetKey, name: tag }),
       }),
     );
     return `내 라이브러리에 저장함${result.edited ? ` · 고친 식 ${result.edited}줄 포함` : ""}`;
@@ -243,15 +307,21 @@ export function buildLibraryPanel(options: LibraryPanelOptions): HTMLElement {
     const button = personal(label, async () => {
       if (isDirty()) return "저장 안 한 식이 있음 — [식 저장] 먼저";
       const whom = tier === "program" ? "모든 회사가 쓰는 프로그램 기본" : "우리 회사 라이브러리";
-      if (!window.confirm(`이 장의 양식과 고친 식을 ${whom}에 발행 — 같은 종류가 있으면 덮어씀`)) {
-        return "";
-      }
+      const masked =
+        tier === "program" && options.originProject
+          ? `\n이 항목은 「${options.originProject}」에서 뽑은 것 — 공사명은 빼고 발행됩니다`
+          : "";
+      const tag = window.prompt(
+        `이 장의 양식과 고친 식을 ${whom}에 발행 — 같은 종류가 있으면 덮어씀${masked}\n${NAME_TAG_HINT}`,
+        options.defaultName,
+      );
+      if (tag === null) return "";
       await readJson(
         await fetch(libraryUrl(projectId, "/publish"), {
           method: "PUT",
           credentials: "include",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sheet_key: sheetKey, tier }),
+          body: JSON.stringify({ sheet_key: sheetKey, tier, name: tag }),
         }),
       );
       return `${whom}에 발행함`;
@@ -265,7 +335,7 @@ export function buildLibraryPanel(options: LibraryPanelOptions): HTMLElement {
   mine.className = "b08-sheet__actions";
   mine.append(save, remove, toCompany, toProgram);
 
-  panel.append(title, scope, load, list, take, clone, mine, status);
+  panel.append(title, scope, load, list, take, clone, send, who, mine, status);
   // 고정형 항목을 만드는 둘째 길 — STmate 출력 엑셀에서 호표 하나를 뽑아 개인 단에(PLAN 4장).
   panel.append(
     buildStmatePanel({

B08_Quantity/B08_Quantity_UI_StructureSheet_Spec.ts

@@ -196,7 +196,11 @@ export function buildStandardSpecPanel(
       slope,
       judgedSlope ? `비우면 자동 — 지금 판정값 1:${judgedSlope}` : "비우면 자동으로 판정합니다.",
     ),
-    field("야면석 계수", coeff, "비우면 품셈 열을 씁니다."),
+    field(
+      "야면석 계수",
+      coeff,
+      "비우면 품셈 열을 씁니다. 계수 열을 바꿔도 돌 종류는 그대로(다른 칸)입니다.",
+    ),
     field("채움 강도 (MPa)", mpa, "비우면 210. 180 은 국가기준 하한입니다."),
     field("버림 콘크리트", blinding, "비우면 넣습니다(두께 100㎜) — 빼려면 「안 넣음」."),
   );

B08_Quantity/B08_Quantity_UI_StructureSheet_UnitPrice.ts

@@ -123,7 +123,7 @@ function render(table: UnitPriceTable): HTMLElement[] {
   const head = el(
     "p",
     "b08-sheet__head",
-    `일위대가 ${table.code} · ${table.unit}당 ${total} (미리보기 — 내역 금액은 원가계산이 셈)`,
+    `일위대가 ${table.code} · ${table.unit}당 ${total} (미리보기 — 내역 금액은 원가계산이 셈 · 하위 일위대가는 5단까지 풀고 더 깊거나 돌면 막힘)`,
   );
   if (table.unconfirmed) {
     head.append(el("span", "b08-unit__badge", `미확정 ${table.unconfirmed}건`));

B09_Estimation/B09_Estimation_BasisSheet.py

@@ -85,6 +85,7 @@ def chosen_conditions(settings: dict[str, Any] | None) -> list[dict[str, str]]:
         ("fuel_region", "유가 지역(시도코드)"),
         ("transport_distance_km", "기계 수송 거리(편도 ㎞)"),
         ("transport_road", "수송 도로 구분"),
+        ("transport_trips", "기계 수송 회수(대수 × 왕복)"),
     ):
         value = str(picked.get(key) or "").strip()
         if value:

B09_Estimation/B09_Estimation_CostSheet.py

@@ -64,7 +64,8 @@ FIELD_HINTS: dict[str, str] = {
         "자동 = 요율 데이터 적용 하한(추정금액 1억 이상)일 때 적용 · STmate 의 토목·준설·건축·기타"
         " 구분은 현행 제비율(2026-04-13)에서 율이 같아(2.3%) 칸으로 두지 않음"
     ),
-    "overhead_class": "임도가 (주)공사·전문공사 어느 쪽인지 정한 규정 없음 — 기본 (주)공사",
+    # 10-A ② 문구 못박음(2026-09-14 사용자 확정 — SW 규칙).
+    "overhead_class": "임도가 어느 쪽인지 규정이 없어 (주)공사 기본 · 칸에서 바꿀 수 있음",
     "cut_basis": (
         "기본 「총공사비 1,000원 미만 버림」 — 근거: 산림청고시 제2025-82호 「금액의 단위표준」"
         "(설계서의 총액 · 원 · 1,000 · 미만버림) · 실무 6건이 여섯 다 000 으로 끝남 ·"
@@ -99,7 +100,8 @@ FIELD_HINTS: dict[str, str] = {
     "waste_placement": (
         "법 문언(기본): 예정가격작성기준 제19조③18호 — 폐기물처리비는 경비라 일반관리비·이윤"
         " 밑수에 듦 · 실무 관행: 울진소광 원가계산서(이윤 뒤·총원가 안)·임목폐기물처리 실정보고"
-        "(공급가액 뒤)는 승률 밖 — 금액이 크게 갈려 설계자가 고름"
+        "(공급가액 뒤)는 승률 밖 — 금액이 크게 갈려 설계자가 고름 ·"
+        " 어느 자리든 법정경비 밑수(직접공사비·노무비)에는 안 넣음"
     ),
 }
 _GRADE_OPTIONS = [

B09_Estimation/B09_Estimation_Engine_Cost.py

@@ -87,7 +87,10 @@ class CostInput:
 
     #: 안전관리비 대상액에 들어가는 **도급자설치 관급금액**. None 이면 관급 전액.
     owner_supplied_for_safety_krw: Decimal | None = None
-    #: 그 금액이 부가세 포함인가 — 포함이면 1.1 로 나눈다(규정: 부가세 제외 기준).
+    #: 그 금액이 부가세 포함인가 — 포함이면 1.1 로 나눈다.
+    #: ⚠ 근거는 **실무**다 — 고시(산업안전보건관리비 계상 및 사용기준) 제4조① 단서는 「해당
+    #:   재료비를 **대상액에 포함**」까지만 적고 부가세를 말하지 않는다. ÷1.1 은 부가세 제외
+    #:   환산이며, 실무 원가계산서 **6건이 모두** 「관급재/1.1」로 적었다(2026-09-14 전수 확인).
     owner_supplied_includes_vat: bool = True
     #: 규모 구간 판정에 쓸 **추정가격**. 주면 그 값으로 한 번만 판정한다.
     #: 없으면 직접공사비를 씨앗으로 **반복 수렴**한다 (`calculate_cost` 참조).

B09_Estimation/B09_Estimation_ResourceAxis_JudgedTable.py

@@ -55,7 +55,18 @@ JUDGED_TABLES: dict[str, dict[str, Any]] = {
         "prefix": "합판거푸집",
         "why": "원문 L6187 「기준수량(1회사용) · 사용횟수별기준수량에대한 비율(%) 재료별·노무비」",
     },
+    "F0353": {
+        "code": "FP-12-15",
+        "shape": "remark_labor",
+        "prefix": "집수정",
+        # 구체콘크리트는 바로 아래 다짐기 줄과 한 갈래 — 다짐기가 안 풀리면 갈래를 안 세움(⑴).
+        "needs_machine": {"구체콘크리트": "다짐:봉상후렉시블(45mm)"},
+        "why": "원문 L6460 「구체·버림콘크리트 ㎥ — 비고 칸 콘크리트공·보통인부 인/㎥」",
+    },
 }
+#: 비고 칸 인력 — 「콘크리트공0.24인/㎥, 보통인부 0.42인/㎥」.
+_RE_REMARK_LABOR = re.compile(r"([가-힣]+)\s*(\d+(?:\.\d+)?)\s*인/㎥")
+_RE_Q = re.compile(r"Q\s*=\s*(\d+(?:\.\d+)?)")
 #: 비율 줄 — 「1회사용시 2회사용시 …」 칸.
 _RE_USE_COUNT = re.compile(r"(\d+)회사용시")
 #: 값으로 안 읽는 줄 — 사용고재 평가기준(원문이 셈을 안 줌 · 사유는 `KNOWN_GAPS`) · 비고.
@@ -117,6 +128,8 @@ def match_judged_table(
         staged = _header_row(code, table, judged, rows, catalog, basis_quantity, unit)
     elif judged["shape"] == "use_count":
         staged = _use_count(code, table, rows, catalog, basis_quantity, unit)
+    elif judged["shape"] == "remark_labor":
+        staged = _remark_labor(code, table, judged, rows, catalog)
     else:
         staged = _merged_first(code, table, judged, rows, catalog, basis_quantity, unit)
     if isinstance(staged, str):
@@ -219,3 +232,39 @@ def _use_count(code, table, rows, catalog, basis, unit) -> list | str:
             amount = base * ratio / Decimal(100) / basis
             staged.append(_row(code, table, entry, amount, unit, index, f"{count}회"))
     return staged
+
+
+def _remark_labor(code, table, judged, rows, catalog) -> list | str:
+    """㎥ 줄 비고 칸의 인력(인/㎥)으로 갈래 — 다짐기가 딸린 갈래는 그 기계가 풀려야 세움."""
+    table_id = str(table.get("pum_table_id", ""))
+    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 "")
+        if len(cells) < 3 or cells[2] != "㎥" or not labors:
+            continue
+        variant = cells[0].split("(")[0].strip()
+        pieces = []
+        for name, amount in labors:
+            entry = _entry(catalog, name, code)
+            if entry is None:
+                return f"{variant} 인력 「{name}」"
+            pieces.append((entry, Decimal(amount)))
+        machine_name = judged.get("needs_machine", {}).get(variant)
+        if machine_name:
+            machine_cells = by_name.get("".join(machine_name.split())) or []
+            found_q = _RE_Q.search(" ".join(machine_cells))
+            entry = _entry(catalog, machine_name, code) if machine_cells else None
+            if entry is None or found_q is None:
+                reason = unmatched_reason(catalog, machine_name)
+                staged.append(UnmatchedRow(code, table_id, machine_name, reason))
+                why = (
+                    f"다짐기 「{machine_name}」 가 안 풀려 갈래를 안 세움 — 인력만이면 조립 줄이"
+                    " 조용히 싸짐(2026-09-14 ㉯ ⑴)"
+                )
+                staged.append(UnmatchedRow(code, table_id, variant, why))
+                continue
+            pieces.append((entry, Decimal(1) / Decimal(found_q.group(1))))
+        for entry, amount in pieces:
+            staged.append(_row(code, table, entry, amount, "㎥", index, variant))
+    return staged

B09_Estimation/B09_Estimation_Router_Factors.py

@@ -110,7 +110,9 @@ async def get_factor_choices(project_id: UUID) -> JSONResponse:
         from B09_Estimation.B09_Estimation_Transport import BASIS_TEXT as TRANSPORT_BASIS
         from B09_Estimation.B09_Estimation_Transport import ROAD_CLASSES as TRANSPORT_ROADS
         from B09_Estimation.B09_Estimation_Transport import TRANSPORT_VARIANTS
+        from B09_Estimation.B09_Estimation_Transport import TRIPS_NOTE as TRANSPORT_TRIPS_NOTE
         from B09_Estimation.B09_Estimation_Transport import WORK_ITEM_CODE as TRANSPORT_CODE
+        from B09_Estimation.B09_Estimation_Transport import parse_trips, transport_amount
 
         # 「넣을 데가 있는가」 — 주재료비가 선 일위대가가 몇인지 세어 그대로 알린다.
         # 지금은 사급 자재 단가가 미결(확정 5차 큰 것 8)이라 0 이 정상이다.
@@ -133,10 +135,19 @@ async def get_factor_choices(project_id: UUID) -> JSONResponse:
         book = prices.book
         transport_notes = list(prices.transport_notes)
         transport_prices = {}
+        transport_amounts = {}
+        # 회수는 품셈이 안 정하는 설계 입력 — 비면 금액을 안 세우고 사유만 남긴다.
+        transport_trips = parse_trips(settings.get("transport_trips"))
         for variant in TRANSPORT_VARIANTS:
             code = f"B-{TRANSPORT_CODE}#{variant['key']}"
             if code in book.titles:
-                transport_prices[variant["key"]] = f"{book.resolve(code).total:,.0f}"
+                unit_price = book.resolve(code).total
+                transport_prices[variant["key"]] = f"{unit_price:,.0f}"
+                amount = transport_amount(unit_price, transport_trips)
+                if amount is not None:
+                    transport_amounts[variant["key"]] = f"{amount:,.0f}"
+        if transport_prices and transport_trips is None:
+            transport_notes.append(TRANSPORT_TRIPS_NOTE)
         with_material = sum(
             1
             for unit_code, unit_title in book.titles.items()
@@ -174,6 +185,8 @@ async def get_factor_choices(project_id: UUID) -> JSONResponse:
                 "transport": {
                     "distance_km": str(settings.get("transport_distance_km") or ""),
                     "road": str(settings.get("transport_road") or ""),
+                    "trips": str(settings.get("transport_trips") or ""),
+                    "trips_note": TRANSPORT_TRIPS_NOTE,
                     "roads": [
                         {"key": row["key"], "label": row["label"]} for row in TRANSPORT_ROADS
                     ],
@@ -182,6 +195,7 @@ async def get_factor_choices(project_id: UUID) -> JSONResponse:
                             "key": variant["key"],
                             "label": variant["label"],
                             "unit_price_krw": transport_prices.get(variant["key"], ""),
+                            "amount_krw": transport_amounts.get(variant["key"], ""),
                         }
                         for variant in TRANSPORT_VARIANTS
                     ],
@@ -236,6 +250,7 @@ class FactorChoiceBody(BaseModel):
     #: 기계 수송 거리(㎞)·도로 구분 — **비면 수송비 줄이 안 선다.**
     transport_distance_km: str | None = None
     transport_road: str | None = None
+    transport_trips: str | None = None
     #: 품 할인·할증(1-4) — 계열코드 → 고른 행. **빈 값이면 그 계열을 끄는 것.**
     labor_surcharge: dict[str, str] | None = None
 
@@ -312,6 +327,14 @@ async def put_factor_choices(project_id: UUID, body: FactorChoiceBody) -> JSONRe
                 content={"status": "error", "message": f"원문에 없는 도로 구분입니다: {road}"},
             )
         values["transport_road"] = road
+    if body.transport_trips is not None:
+        from B09_Estimation.B09_Estimation_Transport import parse_trips
+
+        try:
+            trips = parse_trips(body.transport_trips)
+        except ValueError as exc:
+            return JSONResponse(status_code=400, content={"status": "error", "message": str(exc)})
+        values["transport_trips"] = "" if trips is None else str(trips)
     if body.labor_surcharge is not None:
         from B09_Estimation.B09_Estimation_LaborSurcharge import parse_choices
 

B09_Estimation/B09_Estimation_Statutory.py

@@ -199,10 +199,22 @@ def safety_management_cost(
     variable = dataset.variable("rate_safety_pct")
     brackets = variable["brackets"]
 
+    # 제3조(적용범위) — 「총공사금액 2천만 원 이상인 공사에 적용」. 하한은 요율 데이터가 든다.
+    # ⚠ 견주는 값은 **규모 기준액**(설계자가 준 추정가격 · 없으면 수렴한 총원가)이다. 고시의
+    #   「총공사금액」과 딱 같은 말은 아니나(관급·부가세 자리가 다름) 계산 차례상 안전관리비
+    #   앞에 설 수 있는 값이 그것뿐이라 같은 축으로 쓴다 — 보건관리자 문턱도 같은 축이다.
+    if not _threshold_met(
+        dataset, "rate_safety_pct", "minimum_total_construction_amount_krw", ctx.scale_reference
+    ):
+        return _ZERO  # 대상 아님 — 줄 자체를 만들지 않는다(0 원으로 채우지 않음)
+
     owner_supplied = data.owner_supplied_for_safety_krw
     if owner_supplied is None:
         owner_supplied = data.owner_supplied_material_krw
     if data.owner_supplied_includes_vat:
+        # 제4조① 단서는 「해당 재료비를 **대상액에 포함**」까지만 적고 부가세를 말하지 않는다.
+        # ÷1.1 은 **부가세 제외 환산**이며 근거는 실무다 — 실무 원가계산서 **6건이 모두**
+        # 「(직노+직재+간재+관급재/1.1) × 율」로 적었다(2026-09-14 골든셋 전수 확인).
         owner_supplied = owner_supplied / _VAT_DIVISOR
 
     base_with = ctx.material_cost + ctx.direct_labor_cost + owner_supplied
@@ -255,6 +267,9 @@ def safety_management_cost(
         #   1.2배의 대상은 1·2호로 **산정이 끝난 금액**이다. 종전엔 1.2 를 곱한 뒤 한 번만 버려
         #   영월 2024 B 줄이 20,330,639 로 원본(20,330,638)보다 1원 컸다(골든셋 실증).
         #   A(배수 1)는 어느 차례로 해도 같은 값이다.
+        # ⚠ 안 고른 갈래 — 거창 2025 원본은 `버림(밑수 × 율 × 1.2)` 로 1원 위다. 그 서류는
+        #   시트 이름·줄 차례가 달라 **STmate 출력이 아니며**, 우리 기준은 STmate 재현이라
+        #   사유로만 남기고 채택하지 않는다(브레인 판정 2026-09-14).
         return floor_won(base * percent / _HUNDRED + flat) * multiplier, percent, flat
 
     raw_a, percent_a, flat_a = evaluate(base_with, Decimal(1), "안전관리비 A(관급 포함)")

B09_Estimation/B09_Estimation_Transport.py

@@ -24,8 +24,10 @@
 
 ⚠ **거리는 설계 입력이다** — 안 넣으면 **줄이 안 선다**(사토장 운반거리와 같은 자리).
   임의 거리를 넣으면 금액이 조용히 서므로 **비면 사유만 남긴다.**
-⚠ **회수(몇 대를 몇 번 나르나)는 여기서 안 정한다** — 단가는 「회당」이고, 회수는 수량 쪽
-  (설계 입력)이다. 품셈이 대수·회수를 정해 주지 않는다.
+⚠ **회수(몇 대를 몇 번 나르나)도 설계 입력이다** (2026-09-14 브레인 판정으로 닫음).
+  원문 전수 확인 — 산림품셈 10-4 · 건설품셈 8-1-3 은 **회당 단가 산출식만** 주고
+  대수·왕복 횟수를 정하는 공식이 **없다**. 그래서 `transport_trips` 칸을 두고,
+  비면 금액을 안 세우고 사유만 남긴다. **회수 × 회당 단가** 곱하기 하나뿐이다.
 """
 
 from __future__ import annotations
@@ -86,6 +88,12 @@ ASSUMPTION_TEXT = (
     "⚠ 원문이 안 정해 우리가 정한 둘 — ㉠ 운반시간의 속도는 8-1-6의 2 나 이동속도표에서 가져옴"
     "(그 표는 자주식 이동표라 쓰임이 꼭 같지는 않음) · ㉡ 운반시간을 왕복으로 봄."
 )
+#: 회수 칸 사유 — 화면이 「왜 설계자가 넣나」를 읽는 자리.
+TRIPS_NOTE = (
+    "회수(대수 × 왕복)는 **설계 입력**입니다 — 산림품셈 10-4 · 건설품셈 8-1-3 은 **회당 단가"
+    " 산출식만** 주고 대수·횟수를 정하는 공식이 원문에 없습니다(2026-09-14 전수 확인)."
+    " 비워 두면 수송비 금액이 서지 않습니다."
+)
 
 
 def parse_distance_km(raw: Any) -> Decimal | None:
@@ -102,6 +110,26 @@ def parse_distance_km(raw: Any) -> Decimal | None:
     return value
 
 
+def parse_trips(raw: Any) -> Decimal | None:
+    """설정 칸의 **회수**(대수 × 왕복). 비거나 0 이면 `None` — 금액이 안 선다.
+
+    ⚠ 품셈이 안 정하는 값이라 **우리가 기본값을 두지 않는다**(1 회로 때우지 않음).
+    """
+    text = str(raw or "").strip().rstrip("회").strip()
+    if not text:
+        return None
+    try:
+        value = Decimal(text)
+    except (ArithmeticError, ValueError):
+        raise ValueError(f"수송 회수를 숫자로 못 읽었습니다: {raw!r}") from None
+    return value if value > 0 else None
+
+
+def transport_amount(unit_price_krw: Decimal, trips: Decimal | None) -> Decimal | None:
+    """수송비 = 회당 단가 × 회수. 회수가 없으면 `None`(0 원으로 안 채운다)."""
+    return None if trips is None else unit_price_krw * trips
+
+
 def road_class(key: str | None) -> dict[str, Any] | None:
     """도로 구분. 못 고르면 `None` — **기본 도로를 우리가 정하지 않는다.**"""
     return _ROAD_BY_KEY.get(str(key or ""))

B09_Estimation/B09_Estimation_UI_Factors.ts

@@ -58,7 +58,9 @@ interface TransportRow {
   distance_km: string;
   road: string;
   roads: Array<{ key: string; label: string }>;
-  variants: Array<{ key: string; label: string; unit_price_krw: string }>;
+  trips: string;
+  trips_note: string;
+  variants: Array<{ key: string; label: string; unit_price_krw: string; amount_krw: string }>;
   basis: string[];
   notes: string[];
 }
@@ -105,6 +107,7 @@ export async function saveFactorChoices(
     fuel_region?: string;
     transport_distance_km?: string;
     transport_road?: string;
+    transport_trips?: string;
     labor_surcharge?: Record<string, string>;
   },
 ): Promise<void> {
@@ -251,22 +254,25 @@ export function drawFactorChoices(
     body.append(
       picker("수송 도로 구분", roadOptions, transport.road, (key) => save({ transport_road: key })),
     );
+    body.append(
+      percentBox("기계 수송 회수 (대수 × 왕복)", transport.trips, "비움", (text) =>
+        save({ transport_trips: text }),
+      ),
+    );
     for (const variant of transport.variants) {
       body.append(
         note(
-          variant.unit_price_krw
-            ? `${variant.label} — 회당 ${variant.unit_price_krw}원`
-            : `${variant.label} — 아직 안 섬`,
+          !variant.unit_price_krw
+            ? `${variant.label} — 아직 안 섬`
+            : variant.amount_krw
+              ? `${variant.label} — 회당 ${variant.unit_price_krw}원 × ${transport.trips}회 = ${variant.amount_krw}원`
+              : `${variant.label} — 회당 ${variant.unit_price_krw}원 (회수를 넣으면 금액이 섭니다)`,
         ),
       );
     }
     for (const line of transport.notes) body.append(note(`⚠ ${line}`));
     for (const line of transport.basis) body.append(note(line));
-    body.append(
-      note(
-        "⚠ 단가는 「회당」입니다 — 몇 대를 몇 번 나르는지(회수)는 설계 입력이라 여기서 안 정합니다.",
-      ),
-    );
+    body.append(note(transport.trips_note));
   }
 
   const surcharge = data.labor_surcharge;

B09_Estimation/B09_Estimation_UI_Tab_Bill.ts

@@ -246,6 +246,8 @@ function drawBill(ctx: B09TabContext, bill: BillDto, reload: () => void): void {
         "b09s-hint b09s-hint--warn",
         `${L("B09_Sheet_Missing")} ${bill.summary.missing.length}${L("B09_Sheet_Count")}`,
       ),
+      // 10-A ⑳ 까닭은 그대로 올림(2026-09-14 브레인 규칙) — 규칙을 목록 머리에 드러냄.
+      hint(L("B09_Sheet_Missing_Passed")),
     );
     for (const item of bill.summary.missing) {
       details.append(hint(`${item.name} — ${item.reason}`));

B09_Estimation/B09_Estimation_WorkItems_AX.py

@@ -20,9 +20,10 @@ WORK_ITEMS: dict[str, dict[str, Any]] = {
         "name": "모르타르 배합",
         "spec": "1:3",
         "unit": "㎥",
+        # 10-A ③ 문구 못박음(2026-09-14 사용자 확정 — SW 규칙) · 교차 참조 명시(지침 2장).
         "basis": (
-            "건설공사 표준품셈(2026) [건축부문] 9-1-1 모르타르 배합(㎥당)"
-            " — 산림 품셈엔 배합 절이 없음 · 배합비 1:3 은 돌쌓기 시방(시멘트:잔골재 부피비) · 실무 울진 대흥(2024)·소광(2025)"
+            "산림품셈에 배합 절이 없어 건설품셈 [건축] 9-1-1 을 씀(교차 참조)"
+            " — 건설공사 표준품셈(2026) [건축부문] 9-1-1 모르타르 배합(㎥당) · 배합비 1:3 은 돌쌓기 시방(시멘트:잔골재 부피비) · 실무 울진 대흥(2024)·소광(2025)"
             " 「모르타르배합 1:3」 과 같은 짜임"
         ),
         # (노임 코드, 수량, 칸) — 원문 [주]② 「배합이 포함된 것이며, 비빔은 제외」.

resources/data_formwork/formwork_reuse_2026-01-01.json

@@ -67,9 +67,10 @@
     },
     {
       "type_id": "pipe_inlet_basin",
-      "reuse_count": 6,
-      "matched_example": "보호공 기초",
-      "note": "관보호공 집수정 — 원문 6회 줄의 「호안 및 보호공의 기초」에 해당. ⚠ 벽체까지 6회로 볼지는 확인 필요"
+      "reuse_count": 4,
+      "matched_example": "거푸집 합판4회",
+      "note": "그 공종 표가 직접 적은 「거푸집 | 합판4회」 가 정본 — 1-7-1 분류(「호안 및 보호공의 기초」 6회)보다 위(2026-09-14 브레인 ㉯ ②). 앞서 6회로 봤음.",
+      "basis": "품셈 12-15 집수정 표"
     },
     {
       "type_id": "ford_pavement",

resources/data_rebar/rebar_complexity_2026-01-01.json

@@ -51,9 +51,10 @@
     },
     {
       "type_id": "pipe_inlet_basin",
-      "class": "간단",
-      "matched": "간단한 기초",
-      "note": "관보호공 집수정 — 원문의 「간단한 기초」에 해당. ⚠ 벽체까지 간단으로 볼지는 확인 필요"
+      "class": "보통",
+      "matched": "철근가공조립(보통)",
+      "basis": "품셈 12-15 집수정 표",
+      "note": "그 공종 표가 직접 적은 「철근 | 철근가공조립(보통)」 이 정본 — 12-3 [주]① 「간단한 기초」 추정보다 위(2026-09-14 브레인 ㉯ ⑶ · 거푸집 4회와 같은 원칙). 앞서 간단으로 봤음."
     }
   ],
   "price_hint_krw_per_ton": {

resources/data_work_item_mapping/work_item_mapping_2026-01-01.json

@@ -327,6 +327,53 @@
   "composite": {
     "note": "품셈에 **그 이름의 공종이 없어** 여러 공종을 묶어 일위대가로 세우는 자리. 코드 하나로 못 적으므로 묶음을 적어 둔다 — 빈 코드로 두면 「매핑을 못 찾은 줄」과 구별이 안 된다.",
     "items": [
+      {
+        "type_id": "pipe_inlet_basin",
+        "when": {
+          "inlet_basin_material": "콘크리트"
+        },
+        "note": "2026-09-14 브레인 ㉯ ⑴~⑸ — 원문 L6460 12-15 집수정 표는 조립형(구체·버림 인력 · 다짐기 · 거푸집 합판4회 · 철근가공조립(보통)). 콘크리트 집수정만 묶음 · 돌집수정은 종전대로 12-15 곧장(⑸).",
+        "outside_note": "ⓘ 12-15 표의 집수정 뚜껑(스틸그레이팅 개)·설치비(재료비의 5%)는 조각 모양이 달라 묶음에 안 넣음(⑷ · 2026-09-14)",
+        "parts": [
+          {
+            "code": "FP-12-15#구체콘크리트",
+            "name": "구체콘크리트",
+            "unit": "㎥",
+            "from_components": [
+              "콘크리트"
+            ]
+          },
+          {
+            "code": "FP-12-15#버림콘크리트",
+            "name": "버림콘크리트",
+            "unit": "㎥",
+            "from_components": [
+              "버림콘크리트"
+            ],
+            "why": "□형 원단위(콘크리트 2.84㎥ = 벽 + 바닥기초)에 버림 성분이 없음 — 「설계에 없음 = 0」 으로 짓지 않고 막음(⑵)"
+          },
+          {
+            "code": "FP-12-04",
+            "name": "합판거푸집",
+            "unit": "㎡",
+            "from_components": [
+              "합판거푸집"
+            ],
+            "kind_suffix": "formwork_reuse"
+          },
+          {
+            "code": "FP-12-03",
+            "name": "철근 현장가공 및 조립",
+            "unit": "ton",
+            "from_components": [
+              "이형철근 D13",
+              "이형철근 D16"
+            ],
+            "unit_from": "kg",
+            "kind_suffix": "rebar_complexity"
+          }
+        ]
+      },
       {
         "type_id": "retaining_wall",
         "parts": [
@@ -346,7 +393,8 @@
             "unit": "㎡",
             "from_components": [
               "합판거푸집"
-            ]
+            ],
+            "kind_suffix": "formwork_reuse"
           },
           {
             "code": "FP-12-38",

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-14T18:26:57+09:00",
+ "generated_at": "2026-09-14T19:15:46+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": "fa4d9bc80627d33a46b203f8910f9cc802c1249f2c6c8f09d2e818fce4332287",
-   "size_bytes": 838421
+   "sha256": "183a2933a2bf6f06fb99c0b86dc4073ec42c12a95784b3dd279f5eee50ee088f",
+   "size_bytes": 838487
   },
   {
    "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-14T18:26:57+09:00",
+ "generated_at": "2026-09-14T19:15:46+09:00",
  "dataset_version": {
   "dataset_id": "pum_forest",
   "effective_date": "2026-01-01",
@@ -33148,7 +33148,9 @@
      "formula_rows": [],
      "special_glyphs": [],
      "capacity_formula_here": false,
-     "variant_key": [],
+     "variant_key": [
+      "버림콘크리트"
+     ],
      "condition_note": [
       "구 분",
       "규 격",
@@ -33209,7 +33211,9 @@
      ]
     }
    ],
-   "variant_keys": []
+   "variant_keys": [
+    "버림콘크리트"
+   ]
   },
   {
    "work_item_code": "FP-12-16",

resources/tester/test_b08_basin_composite.py

@@ -0,0 +1,82 @@
+"""12-15 집수정 조립 — 2026-09-14 브레인 ㉯ 남은 몫 판정 ⑴~⑸.
+
+원문 L6460 12-15 표는 조립형(구체·버림 인력 비고 칸 · 다짐기 · 거푸집 합판4회 ·
+철근가공조립(보통) · 뚜껑 · 설치비 5%). B08 은 집수정을 12-15 에 곧장(개소) 이어 단가가 안 섰음.
+⑴ 다짐기(카탈로그 없음) 빠진 구체 갈래는 안 세움 — 인력만이면 조립 줄이 조용히 싸짐
+⑵ □형 원단위에 버림 성분 없음 → 「성분 미확보」 로 막음(0 은 지어냄)
+⑶ 철근 갈래는 12-15 표 「보통」(B08 추정 「간단」 걷음 · 4회와 같은 원칙)
+⑷ 뚜껑·설치비는 조각 모양이 달라 조립 밖 · 사유만
+⑸ 돌집수정은 콘크리트 집수정 표가 아니라 종전대로
+목적: 금액을 못 세워도 **조용히 사라지던 것이 사유로 드러남**.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from B08_Quantity.B08_Quantity_Engine_Handoff import build_handoff  # noqa: E402
+from B08_Quantity.B08_Quantity_Engine_UnitQuantity import build_table  # noqa: E402
+
+CONCRETE = {"structure_id": "b1", "type_id": "pipe_inlet_basin", "start_m": 50.0, "end_m": 50.0,
+            "options": {"inlet_basin_form": "□형(기본형)", "inlet_basin_material": "콘크리트",
+                        "pipe_diameter_mm": "800"}}  # fmt: skip
+STONE = {"structure_id": "b2", "type_id": "pipe_inlet_basin", "start_m": 60.0, "end_m": 60.0,
+         "options": {"inlet_basin_form": "돌집수정 ㄷ형"}}  # fmt: skip
+
+
+def _basin(structure: dict) -> dict:
+    unit = build_table([structure], {"pipe_inlet_basin": "집수정"})
+    handoff = build_handoff(unit_quantity_table=unit)
+    return next(r for r in handoff["work_items"] if r["origin"] == "structure")
+
+
+def test_버림_갈래는_서고_구체_갈래는_다짐기_없어_안_섬() -> None:
+    from B09_Estimation.B09_Estimation_UnitPrice import cached_build, detail_of
+
+    build = cached_build()
+    assert "B-FP-12-15#구체콘크리트" not in build.book.titles
+    rows = detail_of(build, "B-FP-12-15#버림콘크리트")["rows"]
+    assert {r["ref_code"]: float(r["quantity"]) for r in rows} == {"1013": 0.15, "1002": 0.27}
+    left = " ".join(build.unattached.get("FP-12-15", []))
+    assert "구체콘크리트" in left and "봉상후렉시블" in left, left
+
+
+def test_콘크리트_집수정은_조립_조각으로_가고_막힌_까닭이_드러남() -> None:
+    row = _basin(CONCRETE)
+    assert row["work_item_code"] is None, row
+    codes = {p["code"]: p for p in row["composite_parts"]}
+    assert codes["FP-12-15#구체콘크리트"]["quantity"] > 0
+    assert codes["FP-12-04#4회"]["quantity"] > 0
+    assert "FP-12-03#보통" in codes, list(codes)  # ⑶ 표가 적은 갈래
+    reasons = " ".join(str(m.get("reason")) for m in row["composite_not_ready"] or [])
+    assert "FP-12-15#버림콘크리트" in {str(m.get("code")) for m in row["composite_not_ready"]}
+    assert reasons, row
+    assert "뚜껑" in row["spec_class_basis"] and "설치비" in row["spec_class_basis"]  # ⑷
+
+
+def test_돌집수정은_종전대로_12_15_곧장() -> None:
+    row = _basin(STONE)
+    assert row["work_item_code"] == "FP-12-15" and not row["composite_parts"], row
+
+
+def test_콘크리트_집수정_콘크리트는_타설_줄이_또_세지_않음() -> None:
+    unit = build_table([CONCRETE], {"pipe_inlet_basin": "집수정"})
+    handoff = build_handoff(unit_quantity_table=unit)
+    placing = [
+        r for r in handoff["work_items"] if str(r["work_item_code"] or "").startswith("FP-12-01")
+    ]
+    assert not placing, placing  # 구체 조각이 셈 — 두 번 안 셈
+
+
+def test_내역_조립_줄은_금액_없이_사유() -> None:
+    from B09_Estimation.B09_Estimation_BillOfQuantities import build_bill
+
+    unit = build_table([CONCRETE], {"pipe_inlet_basin": "집수정"})
+    bill = build_bill(build_handoff(unit_quantity_table=unit))
+    line = next(r for r in bill.rows if r.code is None and "집수정" in r.name)
+    assert line.amount_krw is None and "묶음 조각" in line.note, line.note

resources/tester/test_b08_formwork_reuse_link.py

@@ -0,0 +1,45 @@
+"""거푸집 사용횟수 → 12-4 갈래 잇기 · 집수정 4회 — 2026-09-14 브레인 ㉯ ①②.
+
+① 옹벽 조립 조각 「FP-12-04 합판거푸집」 에 꼬리가 없어 12-4 사용횟수 갈래(#1~6회)를 못 고름 →
+   B08 이 성분에 단 사용횟수(`reuse_count`, 품셈 1-7-1 옹벽 3회)를 꼬리로 붙임(값은 한 벌).
+② 집수정은 **12-15 표가 직접 적은 「거푸집 합판4회」 가 정본** — 1-7-1 분류로 본 6회는 걷음.
+   화면(자재 표 · 인계)과 표가 같은 값이어야 함(한 벌이 두 값으로 갈리지 않게).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from B08_Quantity.B08_Quantity_Engine_Formwork import FORMWORK_NAMES  # noqa: E402
+from B08_Quantity.B08_Quantity_Engine_Handoff import build_handoff  # noqa: E402
+from B08_Quantity.B08_Quantity_Engine_UnitQuantity import build_table  # noqa: E402
+
+WALL = {"structure_id": "w1", "type_id": "retaining_wall", "start_m": 100.0, "end_m": 110.0,
+        "options": {"form": "반중력식", "height_m": 2.0, "length_m": 10.0}}  # fmt: skip
+BASIN = {"structure_id": "b1", "type_id": "pipe_inlet_basin", "start_m": 50.0, "end_m": 50.0,
+         "options": {"inlet_basin_form": "□형(기본형)", "inlet_basin_material": "콘크리트",
+                     "pipe_diameter_mm": "800"}}  # fmt: skip
+
+
+def test_옹벽_조각_합판거푸집이_사용횟수_갈래로_이어져_단가가_섬() -> None:
+    from B09_Estimation.B09_Estimation_UnitPrice import cached_build
+
+    unit = build_table([WALL], {"retaining_wall": "옹벽"})
+    row = next(
+        r for r in build_handoff(unit_quantity_table=unit)["work_items"] if r["composite_parts"]
+    )
+    part = next(p for p in row["composite_parts"] if str(p["code"]).startswith("FP-12-04"))
+    assert part["code"] == "FP-12-04#3회" and not part.get("not_ready"), part
+    assert "B-FP-12-04#3회" in cached_build().book.titles
+
+
+def test_집수정_거푸집은_12_15_표의_4회_화면과_인계가_같은_값() -> None:
+    unit = build_table([BASIN], {"pipe_inlet_basin": "집수정"})
+    forms = [c for s in unit["structures"] for c in s["components"] if c["name"] in FORMWORK_NAMES]
+    assert forms and all(c["reuse_count"] == 4 for c in forms), forms
+    assert all("12-15" in c["reuse_note"] for c in forms), forms

resources/tester/test_b08_library_name_tag.py

@@ -0,0 +1,56 @@
+"""10-A ⑫ 라이브러리 항목 이름표 = 「종류 + 제원 요약」 자동 · 사용자가 고칠 수 있음 (2026-09-14 사용자 확정).
+
+코드는 난수라 이름이 흔들려도 안전 — 이름은 고르개에 보이는 글자일 뿐.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+from pydantic import ValidationError
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+
+import B08_Quantity.B08_Quantity_Engine_StructureLibrary as library_module  # noqa: E402
+import B08_Quantity.B08_Quantity_Router_StructureSheet as router_module  # noqa: E402
+from B08_Quantity.B08_Quantity_Engine_StructureTemplate import load_template  # noqa: E402
+
+
+def _saved(folder: Path, code: str) -> dict:
+    return json.loads((folder / f"{code}.json").read_text(encoding="utf-8"))
+
+
+def test_저장_때_적은_이름표가_실린다(tmp_path: Path) -> None:
+    template = load_template("masonry_wet")
+    code = library_module.save_personal(
+        tmp_path, template, None, None, "personal", name="  돌쌓기(찰) H=2.5 1:0.3 봉화  "
+    )
+    assert _saved(tmp_path, code)["name"] == "돌쌓기(찰) H=2.5 1:0.3 봉화"
+    assert template["name"] == load_template("masonry_wet")["name"]  # 원본 안 건드림
+
+
+def test_이름표를_비우면_양식_이름_그대로(tmp_path: Path) -> None:
+    template = load_template("masonry_wet")
+    code = library_module.save_personal(tmp_path, template, None, None, "personal", name="   ")
+    assert _saved(tmp_path, code)["name"] == template["name"]
+
+
+def test_요청은_이름표를_받고_길이를_막는다() -> None:
+    request = router_module.LibrarySaveRequest.model_validate({"sheet_key": "k", "name": "가"})
+    assert request.name == "가"
+    with pytest.raises(ValidationError):
+        router_module.LibrarySaveRequest.model_validate({"sheet_key": "k", "name": "가" * 201})
+    source = (ROOT / "B08_Quantity" / "B08_Quantity_Router_StructureSheet.py").read_text("utf-8")
+    assert "payload.name" in source
+
+
+def test_저장_발행_창이_종류_제원_요약을_이름표로_제안한다() -> None:
+    ui = (ROOT / "B08_Quantity" / "B08_Quantity_UI_StructureSheet_Library.ts").read_text("utf-8")
+    assert ui.count("window.prompt(") == 2  # [내 라이브러리에 저장] · [발행]
+    assert "options.defaultName" in ui and "name: tag" in ui
+    sheet_ui = (ROOT / "B08_Quantity" / "B08_Quantity_UI_StructureSheet.ts").read_text("utf-8")
+    assert "defaultName: sheet.title" in sheet_ui

resources/tester/test_b08_library_share.py

@@ -0,0 +1,108 @@
+"""라이브러리 공유 — 같은 회사 동료에게 내 항목을 복사해 보냄 (PLAN 4장 · 2026-09-14 브레인 판정 ①).
+
+⚠ 받는 쪽이 모르게 들어가지 않음 — 받은 항목은 그 사람 개인 단을 덮지 않고 **「받음」 단**에 따로 섬
+  (개인 단은 종류당 하나라 그대로 넣으면 동료가 고친 내 것이 조용히 덮임). 받은 뒤 가져오기·복제는 받는 사람 몫.
+⚠ 같은 회사 안만 · 출처 공사명은 그대로(같은 회사라 그 공사를 앎 · 판정 ③).
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import B08_Quantity.B08_Quantity_Engine_StructureLibrary as library_module  # noqa: E402
+import B08_Quantity.B08_Quantity_Router_StmateLibrary as router_module  # noqa: E402
+from B08_Quantity.B08_Quantity_Engine_StructureTemplate import load_template  # noqa: E402
+from common_util.common_util_auth import verify_session  # noqa: E402
+
+LIB = "/api/projects/33333333-3333-3333-3333-333333333333/quantity/structure-sheets/library"
+MINE = "AX-ST-0000aaaa"
+
+
+@pytest.fixture()
+def client(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> TestClient:
+    monkeypatch.setattr(library_module, "STORAGE_BASE_DIR", str(tmp_path / "storage"))
+    item = {
+        **load_template("masonry_wet"),
+        "code": MINE,
+        "library_tier": "personal",
+        "name": "내 돌쌓기",
+        "origin": {"project": "봉화 임도"},
+    }
+    folder = tmp_path / "storage" / "7" / "42" / "library"
+    folder.mkdir(parents=True)
+    (folder / f"{MINE}.json").write_text(json.dumps(item), encoding="utf-8")
+    # 받는 사람(43)도 같은 종류 내 것이 있음 — 덮이면 안 됨
+    theirs = tmp_path / "storage" / "7" / "43" / "library"
+    theirs.mkdir(parents=True)
+    (theirs / "AX-ST-0000bbbb.json").write_text(
+        json.dumps({**item, "code": "AX-ST-0000bbbb", "name": "동료 것"}), encoding="utf-8"
+    )
+
+    async def members(company_id: int) -> list[dict]:
+        assert company_id == 7
+        return [
+            {"id": 42, "name": "나", "email": "me@x"},
+            {"id": 43, "name": "동료", "email": "you@x"},
+        ]
+
+    monkeypatch.setattr(router_module, "_company_members", members)
+    app = FastAPI()
+    app.include_router(router_module.router)
+    app.dependency_overrides[verify_session] = lambda: {"company_id": 7, "user_id": 42}
+    return TestClient(app)
+
+
+def test_동료_목록은_같은_회사에서_나를_뺀다(client: TestClient) -> None:
+    body = client.get(f"{LIB}/colleagues").json()
+    assert body["colleagues"] == [{"id": 43, "name": "동료"}]
+
+
+def test_보내면_받는_쪽_받음_단에_서고_그_사람_개인_단은_안_덮인다(
+    client: TestClient, tmp_path: Path
+) -> None:
+    sent = client.put(
+        f"{LIB}/share", json={"type_id": "masonry_wet", "code": MINE, "to_user_id": 43}
+    )
+    assert sent.status_code == 200, sent.text
+    received = tmp_path / "storage" / "7" / "43" / "library_received" / f"{MINE}.json"
+    saved = json.loads(received.read_text(encoding="utf-8"))
+    assert saved["library_tier"] == "received"
+    assert saved["received_from"]["name"] == "나" and saved["origin"]["project"] == "봉화 임도"
+    theirs = tmp_path / "storage" / "7" / "43" / "library" / "AX-ST-0000bbbb.json"
+    assert json.loads(theirs.read_text(encoding="utf-8"))["name"] == "동료 것"
+    dirs = library_module.tier_dirs(7, 43)
+    listed = library_module.list_items(dirs, "masonry_wet")
+    assert [i["tier"] for i in listed][:2] == ["personal", "received"]
+
+
+def test_회사_밖이나_내_것_아닌_항목은_못_보낸다(client: TestClient) -> None:
+    stranger = client.put(
+        f"{LIB}/share", json={"type_id": "masonry_wet", "code": MINE, "to_user_id": 99}
+    )
+    assert stranger.status_code == 404
+    missing = client.put(
+        f"{LIB}/share", json={"type_id": "masonry_wet", "code": "AX-ST-0000cccc", "to_user_id": 43}
+    )
+    assert missing.status_code == 404
+    myself = client.put(
+        f"{LIB}/share", json={"type_id": "masonry_wet", "code": MINE, "to_user_id": 42}
+    )
+    assert myself.status_code == 400
+
+
+def test_화면에_보내기_단추와_받음_표시() -> None:
+    ui = (ROOT / "B08_Quantity" / "B08_Quantity_UI_StructureSheet_Library.ts").read_text(
+        encoding="utf-8"
+    )
+    assert "/share" in ui and "/colleagues" in ui and "동료에게 보내기" in ui
+    assert 'received: "받음"' in ui

resources/tester/test_b08_structure_library.py

@@ -261,6 +261,41 @@ def test_발행은_권한대로_회사_기본_단에_같은_모양으로(client:
     ]
 
 
+def test_프로그램_기본_발행본엔_원문_공사명_파일명을_안_싣는다(tmp_path: Path) -> None:
+    """2026-09-14 브레인 ② — 모든 회사로 가는 발행본에서만 가림 · 원본·회사 단은 그대로(③)."""
+    origin = {
+        "kind": "stmate_xlsx",
+        "file": "봉화.xlsx",
+        "project": "2024년 봉화 임도",
+        "hopyo_no": 6,
+    }
+    template = {**load_template("masonry_wet"), "origin": origin}
+    program = library_module.save_personal(tmp_path / "program", template, None, None, "program")
+    company = library_module.save_personal(tmp_path / "company", template, None, None, "company")
+    published = json.loads((tmp_path / "program" / f"{program}.json").read_text(encoding="utf-8"))
+    kept = json.loads((tmp_path / "company" / f"{company}.json").read_text(encoding="utf-8"))
+    assert "project" not in published["origin"] and "file" not in published["origin"]
+    assert published["origin"]["masked"] == "원문에서 뽑음 — 공사명은 발행 시 가림"
+    assert published["origin"]["kind"] == "stmate_xlsx"
+    assert kept["origin"] == origin
+    assert template["origin"] == origin  # 원본은 안 건드림
+
+
+def test_발행_확인창이_가릴_공사명을_보인다() -> None:
+    ui = (ROOT / "B08_Quantity" / "B08_Quantity_UI_StructureSheet_Library.ts").read_text(
+        encoding="utf-8"
+    )
+    assert "originProject" in ui and "공사명은 빼고 발행됩니다" in ui
+    sheet_ui = (ROOT / "B08_Quantity" / "B08_Quantity_UI_StructureSheet.ts").read_text(
+        encoding="utf-8"
+    )
+    assert "originProject: sheet.library_item.origin_project" in sheet_ui
+    template_py = (ROOT / "B08_Quantity" / "B08_Quantity_Engine_StructureTemplate.py").read_text(
+        encoding="utf-8"
+    )
+    assert '"origin_project"' in template_py
+
+
 def test_회사_없는_사람은_개인_단을_못_쓴다(client: TestClient) -> None:
     client.app.dependency_overrides[verify_session] = lambda: {"company_id": None, "user_id": 1}
     sheet = _sheet(client)

resources/tester/test_b09_safety_notice.py

@@ -172,3 +172,35 @@ def test_대상액은_직재_간재_직노_그리고_발주자_제공_재료다(
     assert owner.line("safety_management_cost_a").base_amount_krw == base + 30_000_000
     # 관급 제외 밑수(B)는 관급이 들어도 안 움직임.
     assert owner.line("safety_management_cost_b").base_amount_krw == base
+
+
+def _scaled(estimated_price: Decimal) -> object:
+    """총공사금액(규모 기준액)만 갈아 끼워 돌림 — 대상액은 구간이 안 갈리게 작게 둠."""
+    return calculate_cost(
+        CostInput(
+            direct_material_krw=Decimal(5_000_000),
+            direct_labor_krw=Decimal(5_000_000),
+            direct_expense_krw=Decimal(0),
+            enabled_items=("safety_management_cost",),
+            estimated_price_krw=estimated_price,
+            cut_basis="none",
+        )
+    )
+
+
+def test_제3조_총공사금액_2천만원_미만이면_줄이_안_선다() -> None:
+    """제3조 — 「총공사금액 2천만 원 이상인 공사에 적용」. 하한은 요율 데이터가 들고 있음.
+
+    ⚠ 우리가 견주는 값은 **규모 기준액**(설계자가 준 추정가격 · 없으면 수렴한 총원가)임.
+      고시의 「총공사금액」과 딱 같은 말은 아니나(관급·부가세 자리가 다름) 계산 차례상
+      안전관리비 앞에 설 수 있는 값이 그것뿐이라 같은 축으로 씀 — 보건관리자 문턱도 같은 축.
+    """
+    minimum = json.load(io.open(RATES, encoding="utf-8"))["variables"]["rate_safety_pct"].get(
+        "minimum_total_construction_amount_krw"
+    )
+    assert minimum == 20_000_000, minimum
+    assert not _scaled(Decimal(minimum) - 1).has("safety_management_cost")
+    assert _scaled(Decimal(minimum)).has("safety_management_cost")
+    # 안 서면 A·B 곁줄도 안 선다 — 0 원으로 채우지 않음.
+    below = _scaled(Decimal(minimum) - 1)
+    assert not below.has("safety_management_cost_a") and not below.has("safety_management_cost_b")

resources/tester/test_b09_transport.py

@@ -29,10 +29,13 @@ from B09_Estimation.B09_Estimation_MachineOperating import (  # noqa: E402
 )
 from B09_Estimation.B09_Estimation_Transport import (  # noqa: E402
     TRANSPORT_VARIANTS,
+    TRIPS_NOTE,
     cycle_minutes,
     hours_per_trip,
     parse_distance_km,
+    parse_trips,
     road_class,
+    transport_amount,
 )
 from B09_Estimation.B09_Estimation_UnitPrice import build_unit_prices  # noqa: E402
 
@@ -114,3 +117,30 @@ def test_앞자리_이어받기는_이어받을_것이_있을_때만() -> None:
     assert expand_codes(["0080", "0100"]) == []
     assert expand_codes(["0080", "0100"], "2101") == ["2101-0080", "2101-0100"]
     assert expand_codes(["2101-0010", "0015"]) == ["2101-0010", "2101-0015"]
+
+
+# ── 회수(대수 × 왕복) — 품셈이 안 정하는 자리 (2026-09-14 브레인 판정) ──
+
+
+def test_회수는_설계_입력_칸이고_비우면_없음이다() -> None:
+    """품셈 원문에 **회수 공식이 없음** — 산림품셈 10-4·건설품셈 8-1-3 은 회당 단가 산출식뿐.
+
+    ⇒ 대수·왕복은 **설계자가 넣는 값**이다. 비면 `None` 이고 금액이 안 선다(지어내지 않음).
+    """
+    assert parse_trips("") is None and parse_trips(None) is None
+    assert parse_trips("0") is None  # 0 회는 「안 나른다」 — 줄이 안 섬
+    assert parse_trips("3") == Decimal(3)
+    assert parse_trips(" 2.5 ") == Decimal("2.5")  # 반 회(편도 한 번)도 설계자가 넣을 수 있음
+    with pytest.raises(ValueError):
+        parse_trips("두 번")
+
+
+def test_회수를_넣으면_회당_단가에_곱해진다() -> None:
+    """회수 × 회당 단가 = 수송비. **곱하기 하나뿐** — 품셈이 안 준 규칙을 끼워 넣지 않는다."""
+    assert transport_amount(Decimal(12_345), None) is None
+    assert transport_amount(Decimal(12_345), Decimal(3)) == Decimal(37_035)
+
+
+def test_회수_사유가_늘_붙는다() -> None:
+    """화면이 「왜 설계자가 넣나」를 읽을 수 있어야 함 — 근거 문구에 원문 없음이 적혀 있음."""
+    assert "회수" in TRIPS_NOTE and "설계" in TRIPS_NOTE

resources/tester/test_b10a_rules_visible_b05_b09.py

@@ -0,0 +1,59 @@
+"""10-A — 우리가 정한 SW 규칙을 화면에 드러내기(B05·B09 몫) · 2026-09-14 사용자 확정 · PLAN 12장.
+
+번호는 PLAN 10장 「✅ 사용자 확정 — SW 규칙」 줄 차례. 문구 못박을 셋(①②③)은 글자 그대로 봄.
+"""
+
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def _read(path: str) -> str:
+    return (ROOT / path).read_text(encoding="utf-8")
+
+
+def test_11_일반관리비_문구_못박음() -> None:
+    from B09_Estimation.B09_Estimation_CostSheet import FIELD_HINTS
+
+    assert FIELD_HINTS["overhead_class"] == (
+        "임도가 어느 쪽인지 규정이 없어 (주)공사 기본 · 칸에서 바꿀 수 있음"
+    )
+
+
+def test_13_모르타르_배합_교차_참조_문구() -> None:
+    from B09_Estimation.B09_Estimation_WorkItems_AX import MORTAR_MIX, WORK_ITEMS
+
+    assert WORK_ITEMS[MORTAR_MIX]["basis"].startswith(
+        "산림품셈에 배합 절이 없어 건설품셈 [건축] 9-1-1 을 씀(교차 참조)"
+    )
+
+
+def test_15_폐기물처리비는_법정경비_밑수에_안_넣음() -> None:
+    from B09_Estimation.B09_Estimation_CostSheet import FIELD_HINTS
+
+    assert "법정경비 밑수(직접공사비·노무비)에는 안 넣음" in FIELD_HINTS["waste_placement"]
+
+
+def test_17_옹벽_높이_기본값_문구와_칸_밑_근거() -> None:
+    types = json.loads(_read("B05_Profile/B05_Profile_Structure_Types.json"))
+    wall = next(t for t in types["types"] if t["type_id"] == "retaining_wall")
+    height = next(o for o in wall["options"] if o["key"] == "height_m")
+    assert height["default_basis"] == "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음"
+    # 칸 밑 근거 한 줄 — 등록부 폼이 `default_basis` 를 칸 밑에 그림
+    assert "field(label, input, option.default_basis)" in _read(
+        "B05_Profile/B05_Profile_UI_Structures_Panel.ts"
+    )
+
+
+def test_19_시설_저장은_폼에_없는_칸을_그대로_둠() -> None:
+    assert "폼에 없는 칸(집계표·구조물도로 적은 값)은 그대로 둠" in _read(
+        "B05_Profile/B05_Profile_UI_Drainage_Facility.ts"
+    )
+
+
+def test_20_막힌_사유는_아래_단계_것을_그대로() -> None:
+    assert 'hint(L("B09_Sheet_Missing_Passed"))' in _read(
+        "B09_Estimation/B09_Estimation_UI_Tab_Bill.ts"
+    )
+    assert "그대로 옮김 — 여기서 새로 짓지 않음" in _read("ui_template/ui_template_locale_b3.ts")

resources/tester/test_b10a_rules_visible_b08.py

@@ -0,0 +1,46 @@
+"""10-A — 우리가 정한 SW 규칙을 화면에 드러내기(B08 몫) · 2026-09-14 사용자 확정 · PLAN 12장.
+
+훑기(21건) 결과 안 보이거나 반만 보이던 자리만 채움 — 칸 밑 근거 한 줄 · 사유 문구 · 제안 회색.
+번호는 PLAN 10장 「✅ 사용자 확정 — SW 규칙」 줄 차례(PLAN 4장 10-A 절에 목록).
+"""
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+B08 = ROOT / "B08_Quantity"
+
+
+def _read(name: str) -> str:
+    return (B08 / name).read_text(encoding="utf-8")
+
+
+def test_3_뒷채움_폭_칸_신설은_B05_등록부_몫() -> None:
+    assert "칸을 새로 두는 것은 B05 등록부 몫" in _read(
+        "B08_Quantity_Engine_UnitQuantity_Masonry.py"
+    )
+
+
+def test_4_하위_일위대가_깊이_한도를_미리_보인다() -> None:
+    assert "하위 일위대가는 5단까지" in _read("B08_Quantity_UI_StructureSheet_UnitPrice.ts")
+
+
+def test_5_계수_열과_돌_종류는_다른_축() -> None:
+    assert "돌 종류는 그대로" in _read("B08_Quantity_UI_StructureSheet_Spec.ts")
+
+
+def test_9_고친_식은_양식과_프로젝트에_묶임() -> None:
+    assert "제원(높이 등)을 바꿔도 따라감" in _read("B08_Quantity_UI_StructureSheet_Formula.ts")
+
+
+def test_16_양식_반올림은_m당_값에() -> None:
+    assert "반올림은 m당 값에 걸고" in _read("B08_Quantity_UI_StructureSheet.ts")
+
+
+def test_22_제근_굴착기_크기_칸() -> None:
+    page = _read("B08_Quantity_UI_Page.ts")
+    side = _read("B08_Quantity_UI_Side_RootRemoval.ts")
+    assert "root_removal_excavator_m3: draft.root_removal_excavator_m3" in page
+    assert "root_removal_excavator_m3: (stored.root_removal_excavator_m3" in page
+    assert "appendRootRemovalFields(" in page
+    assert "choices.suggested" in side and "createButton(" in side
+    assert side.count("= suggested.value") == 2  # 단추 안에서만 넣음(비우면 「안 정함」)

ui_template/ui_template_locale_b2.ts

@@ -693,6 +693,10 @@ export const ui_locales_b2 = {
     "⚠ 「육상」은 통상값이고 사용자 확정이 아닙니다(확정 3차 ④) — 품셈 9-13 의 18구분이 이 값으로 갈립니다",
     "⚠ “Dry” is a customary default, not a user decision — it selects one of the 18 sub-items",
   ],
+  B08_Quantity_Side_RootRemoval_Label: ["제근 굴착기 크기", "Root removal excavator size"],
+  B08_Quantity_RootRemoval_Unset: ["안 정함(금액 안 섬)", "Not set (no amount)"],
+  B08_Quantity_RootRemoval_Suggest: ["제안(비우면 안 정함):", "Suggested (blank = not set):"],
+  B08_Quantity_RootRemoval_FillSuggested: ["제안값 넣기", "Fill suggested"],
   B08_Quantity_Side_StandVolume_Label: ["임목축적 등급", "Stand volume class"],
   B08_Quantity_StandVolume_Unset: ["안 정함(줄이 막힘)", "Not set (row blocked)"],
   B08_Quantity_StandVolume_Low: ["소림(30~60㎥/㏊)", "Low (30–60 ㎥/ha)"],

ui_template/ui_template_locale_b3.ts

@@ -28,6 +28,10 @@ export const ui_locales_b3 = {
   B09_Sheet_Unconfirmed: ["미확정", "Unconfirmed"],
   B09_Sheet_Unpriced: ["금액에 안 들어감", "not in the amount"],
   B09_Sheet_Missing: ["금액을 못 세운 줄", "Rows without a price"],
+  B09_Sheet_Missing_Passed: [
+    "사유는 아래 단계(수량·단가)가 낸 것을 그대로 옮김 — 여기서 새로 짓지 않음",
+    "Reasons are passed through from the quantity/price step as-is",
+  ],
   B09_Sheet_Reload: ["다시 불러오기", "Reload"],
   B09_Sheet_Level: ["보이는 레벨", "Show levels"],
   B09_Sheet_Level_All: ["모두", "All"],