diff --git a/B09_Estimation/B09_Estimation_Calc_Labor.py b/B09_Estimation/B09_Estimation_Calc_Labor.py
index f5e4cf273..3b0d2c951 100644
--- a/B09_Estimation/B09_Estimation_Calc_Labor.py
+++ b/B09_Estimation/B09_Estimation_Calc_Labor.py
@@ -9,6 +9,7 @@
     노무 줄 = 노무비목록표 단가 · 재료 줄 = 재료비목록표 단가 ·
     중기 줄 = 중기목록표(노무 · 재료 · 경비)
     대가 줄 = 부른 블록 합계(노무 · 재료 · 경비) · 산근 줄 = 145-1 산근 단가(`sangeun` {키: 값})
+    비고 = 대가 줄 「대가n」 · 산근 줄 「산근 n호표」(산근 목록 번호)
     % 줄 = 밑수(그 블록 노무 줄 금액 합) × % / 100
 끝수 = 엑셀 자리 그대로 — 줄 금액 = ROUNDDOWN(단가 × 수량, 1) ·
     % 줄 = ROUNDDOWN(밑수 × % / 100, 1) · 관급 · 별도계상 자재 = 대가 안 0원 ·
@@ -159,6 +160,9 @@ def compute_labor(
         for line in got["lines"]:
             if line["kind"] == "daega" and line.get("key") in no:
                 line["ref_no"] = f"대가{no[line['key']]}"
+            sg_no = (books["sangeun"].get(line.get("key")) or {}).get("no")
+            if line["kind"] == "sangeun" and sg_no is not None:
+                line["ref_no"] = f"산근 {sg_no}호표"  # 155-3 비고(엑셀 꼴)
         out_blocks.append(got)
     listing = [
         {
diff --git a/B09_Estimation/B09_Estimation_Calc_Labor.ts b/B09_Estimation/B09_Estimation_Calc_Labor.ts
index 5a1044be5..48cf7835f 100644
--- a/B09_Estimation/B09_Estimation_Calc_Labor.ts
+++ b/B09_Estimation/B09_Estimation_Calc_Labor.ts
@@ -8,6 +8,7 @@
  *
  *   노무 줄 = 노무비목록표 · 재료 줄 = 재료비목록표 · 중기 줄 = 중기목록표 · 대가 줄 = 부른 블록 합계 ·
  *   산근 줄 = 145-1 산근 단가 · % 줄 = 밑수(노무 줄 금액 합) × % / 100
+ *   비고 = 대가 줄 「대가n」 · 산근 줄 「산근 n호표」(산근 목록 번호)
  *   줄 금액 ROUNDDOWN(단가 × 수량, 1) · 블록 비목 합 ROUNDDOWN(Σ, 0) · 합계 = 세 비목 합
  *   관급 · 별도계상 자재 = 대가 안 0원(자재대 · 관급 단락에서 셈)
  *   빈칸 = 원천이 없으면 null · 그 칸을 쓰는 합도 null · 「연결 없음」 목록(gaps)
@@ -147,6 +148,10 @@ export function computeLabor(daega: Row | null | undefined, sheets: Row, sangeun
     const got: Row = { ...done[b.id], no: no[b.id] };
     for (const line of got.lines)
       if (line.kind === "daega" && line.key in no) line.ref_no = `대가${no[line.key]}`;
+    for (const line of got.lines) {
+      const sgNo = (books.sangeun[line.key] || {}).no;
+      if (line.kind === "sangeun" && sgNo != null) line.ref_no = `산근 ${sgNo}호표`; // 155-3 비고
+    }
     return got;
   });
   const listing = outBlocks.map((b) => ({
diff --git a/B09_Estimation/B09_Estimation_Labor_Source.py b/B09_Estimation/B09_Estimation_Labor_Source.py
index d79c9a1e6..72a9ad8ef 100644
--- a/B09_Estimation/B09_Estimation_Labor_Source.py
+++ b/B09_Estimation/B09_Estimation_Labor_Source.py
@@ -5,11 +5,14 @@
 
     조합      구조물 조합 사본 하나 = 블록(엑셀 「조합」 꼴) · 줄 = 담은 로직 줄 · 자재 줄
     사전조합  참조 SC = 겹 대가(굳힌 `참조사본`) · 줄 = 그 안 로직 · 참조 줄(수량 = 손)
-    품셈      승격 아닌 로직 줄 = 로직마다 따로(노무 · 재료 · 중기 · % 줄) — 조합이 수량만큼 부름
-    산근      승격 줄 · 옛 참조 SP = 산근 호표 참조(키 = 145-1 `sangeun_key` · 없으면 자리만)
+    품셈      일위대가화(승격) 줄 · 옛 참조 SP = 로직마다 따로(노무 · 재료 · 중기 · 산근 · % 줄)
+              — 조합이 수량만큼 부름 · 기계 = 기계경비 로직 줄 · 다른 돈 로직 줄 = 하위 산근
+    산근      단가산출 줄(일위대가화 아닌 로직 줄) = 산근 호표 참조(키 = 145-1 `sangeun_key`)
+              (155-3 · 사용자 뜻 = 일위대가화 줄 = 대가 · 단가산출 줄 = 산근 · 145 정함 뒤집음)
 
 같은 블록 = 같은 꼴 → 한 호표(id = 내용 해시 · 같은 원본 + 같은 셈 단가 = 하나) ·
-줄 수량 = 사본 셈 수량(손 · 면적 알약 칸) ÷ 배 = 부르는 호표 1 단위 몫.
+줄 수량 = 사본 셈 수량(손 · 면적 알약 칸) — 대가 줄만 ÷ 배(부르는 호표 1 단위 몫 ·
+산근 단가는 이미 1 단위).
 단가 · 금액 · 끝수는 셈 짝(`B09_Estimation_Calc_Labor`)이 B09 프로젝트 한 벌 단가로 냄.
 """
 
@@ -22,6 +25,7 @@ from decimal import Decimal
 from pathlib import Path
 from typing import Any
 
+from B09_Estimation import B09_Estimation_Sangeun as sg
 from M02_MasterTemplete import M02_Item_Prices as item_prices
 from M02_MasterTemplete import M02_Labor_Doc as labor_doc
 from M02_MasterTemplete import M02_Labor_Ref as refs
@@ -38,8 +42,6 @@ mf = item_prices.mf
 
 #: 엔진 비목 → 블록 비목
 PART = {"노무비": "labor", "재료비": "material", "경비": "expense"}
-#: 기계 로직 줄 요소 — `로직(GC…, 기계='0201-0070', …)` 의 원문번호
-MACHINE = re.compile(r"기계\s*=\s*['\"]([^'\"]+)['\"]")
 #: % 덧줄 밑수 — `노무비 * …` · `줄.'이름' * …` · `(석공 * LB… + …) * …`(인력 줄)
 BASE_PART = re.compile(r"^\s*(노무비|재료비|경비)\s*\*")
 BASE_LINE = re.compile(r"^\s*줄\.'([^']+)'\s*\*")
@@ -62,12 +64,8 @@ def _digest(value: Any) -> str:
 
 
 def sangeun_ref(code: str, given: Any, rate: Any, picks: Any) -> str:
-    """산근 호표 키 — 145-1(`B09_Estimation_Sangeun.sangeun_key`)이 들어오면 그 키 · 전엔 자리만."""
-    try:
-        from B09_Estimation.B09_Estimation_Sangeun import sangeun_key
-    except ImportError:
-        return f"SG:{code}:{_digest([given or {}, rate, picks or {}])}"
-    return sangeun_key(code, given or {}, rate, picks or {})
+    """산근 호표 키 — 145-1 `B09_Estimation_Sangeun.sangeun_key`."""
+    return sg.sangeun_key(code, given or {}, rate, picks or {})
 
 
 class Builder:
@@ -84,7 +82,7 @@ class Builder:
         return bid
 
     # ── 품셈(로직 하나) ─────────────────────────────────────────────────
-    def poomsem(self, whole: Any, one: dict[str, Any]) -> str | None:
+    def poomsem(self, whole: Any, one: dict[str, Any], title: str = "") -> str | None:
         code = str(one.get("로직") or "")
         given, rate, picks = one.get("입력값") or {}, one.get("켜쌓기율"), one.get("고름")
         try:
@@ -98,15 +96,20 @@ class Builder:
         lines = []
         engine = got.get("줄") or []
         bases = _engine_bases(engine[: len(items)], items)
+        calls = sg.line_calls(whole, code, given, picks)
         for n, x in enumerate(engine):
             item = items[n] if n < len(items) else None
-            lines.append(self._engine_line(whole, item, x, logic, n - len(items), bases))
+            lines.append(self._engine_line(item, x, logic, n - len(items), bases, calls.get(n)))
+        eq = {str(r.get("키")): r for r in (whole.numbers.get("EQ") or {}).values()}
+        for line in lines:
+            if line["kind"] == "machine":
+                line["spec"] = (eq.get(line["key"]) or {}).get("규격") or ""
         unit = str(logic.get("결과단위") or "").replace("원/", "")
         spec = " · ".join(f"{k} {v}" for k, v in sorted(given.items()))
         return self.put(
             {
                 "kind": "품셈",
-                "name": logic.get("이름") or code,
+                "name": title or logic.get("이름") or code,
                 "spec": spec,
                 "unit": unit,
                 "cite": logic.get("출처") or "",
@@ -116,7 +119,7 @@ class Builder:
         )
 
     def _engine_line(
-        self, whole: Any, item: dict | None, x: dict, logic: dict, extra: int, bases: dict
+        self, item: dict | None, x: dict, logic: dict, extra: int, bases: dict, call: dict | None
     ) -> dict[str, Any]:
         head = {"name": x.get("이름") or "", "spec": "", "unit": x.get("단위") or ""}
         qty = _f(x.get("수량"))
@@ -140,24 +143,20 @@ class Builder:
                 return {**head, "kind": "blank", "qty": qty, "why": x.get("까닭") or "품목 없음"}
             return {**head, "kind": "material", "key": goods["키"], "spec": goods.get("규격") or "",
                     "qty": qty}  # fmt: skip
-        hit = MACHINE.search(str(item.get("요소") or ""))
-        row = whole.numbers.get("EQ", {}).get(hit.group(1)) if hit else None
-        if row is None:
-            # ponytail: 기계 아닌 하위 로직 줄은 B09 단가로 못 펼침 — 줄만 두고 빈칸
-            return {
-                **head,
-                "kind": "blank",
-                "qty": qty,
-                "why": "하위 로직 줄 — 대가 단가로 못 펼침",
-            }
-        return {**head, "kind": "machine", "key": row["키"], "spec": row.get("규격") or "",
-                "qty": qty}  # fmt: skip
+        # 로직 줄 — `Sangeun.call_of` 판정: 기계경비 로직 = 중기 · 그 밖 = 하위 산근
+        if call and call.get("machine"):
+            return {**head, "kind": "machine", "key": call["machine"], "qty": qty}
+        if call and call.get("code"):
+            key = sg.sangeun_key(call["code"], call["given"])
+            return {**head, "kind": "sangeun", "key": key, "qty": qty}
+        return {**head, "kind": "blank", "qty": qty, "why": "하위 로직 줄 — 못 펼침"}
 
     # ── 조합 · 사전조합 줄 ──────────────────────────────────────────────
     def line_of(
         self, whole: Any, one: dict, qty: Any, times: Any, name: str, copies: dict, depth: int = 0
     ) -> dict[str, Any]:
-        """담은 로직 줄 하나 → 블록 줄 — 수량 = 수량 ÷ 배(부르는 호표 1 단위 몫)."""
+        """담은 로직 줄 하나 → 블록 줄 — 대가 줄 수량 = 수량 ÷ 배(부르는 호표 1 단위 몫) ·
+        산근 줄 수량 = 수량 그대로(산근 단가 = 결과단위 1 단위)."""
         q = _f(qty)
         t = _f(times) or 1.0
         each = None if q is None else q / t
@@ -171,20 +170,24 @@ class Builder:
                     "qty": each,
                     "why": f"없는 참조 「{ref.get('키')}」",
                 }
-            if refs.kind_of(ref.get("키")) == "promote":  # 옛 단가승격 참조 = 산근
+            if refs.kind_of(ref.get("키")) == "promote":  # 옛 단가승격 참조 = 일위대가화 = 대가
                 first = (doc.get("담은로직") or [{}])[0]
-                key = sangeun_ref(str(first.get("로직") or ""), first.get("입력값"),
-                                  first.get("켜쌓기율"), first.get("고름"))  # fmt: skip
-                return {"kind": "sangeun", "key": key, "name": doc.get("이름") or name,
+                bid = self.poomsem(whole, first, doc.get("이름") or name)
+                if bid is None:
+                    return {"kind": "blank", "name": name, "qty": each, "why": "돈 아닌 로직"}
+                return {"kind": "daega", "key": bid, "name": self.blocks[bid]["name"],
                         "unit": doc.get("단위") or "", "qty": each}  # fmt: skip
             bid = self.precombo(whole, ref, doc, copies, depth + 1)
             return {"kind": "daega", "key": bid, "name": doc.get("이름") or name,
                     "unit": doc.get("단위") or "", "qty": each}  # fmt: skip
         code = str(one.get("로직") or "")
-        if one.get("승격") is True:
+        if one.get("승격") is not True:  # 단가산출 줄 = 산근
+            if not sg.is_money(whole, code):
+                return {"kind": "blank", "name": name or code, "qty": q, "why": "돈 아닌 로직"}
             key = sangeun_ref(code, one.get("입력값"), one.get("켜쌓기율"), one.get("고름"))
-            return {"kind": "sangeun", "key": key, "name": name, "qty": each}
-        bid = self.poomsem(whole, one)
+            return {"kind": "sangeun", "key": key, "name": name or code,
+                    "unit": sg.unit_of(code), "qty": q}  # fmt: skip
+        bid = self.poomsem(whole, one, str(one.get("별칭") or "") or name)
         if bid is None:
             return {
                 "kind": "blank",
@@ -312,7 +315,7 @@ def _plain(value: Any) -> Any:
 def daega_inputs(project_root: str | Path) -> dict[str, Any]:
     """대가 셈 입력 — `{blocks: [...], owners: {구조물 id: 블록 id}}` · 사본 없으면 빈 것.
 
-    차례 = 조합(구조물 id 차례) → 사전조합 → 품셈(처음 본 차례) — 호표 번호 = 이 차례.
+    차례 = 조합(구조물 id 차례) → 사전조합 → 일위대가화(품셈 · 처음 본 차례) — 호표 번호 = 이 차례.
     """
     base = structures_dir(project_root)
     build = Builder()
diff --git a/B09_Estimation/B09_Estimation_Sangeun.py b/B09_Estimation/B09_Estimation_Sangeun.py
index 3fcfd78d0..4be914331 100644
--- a/B09_Estimation/B09_Estimation_Sangeun.py
+++ b/B09_Estimation/B09_Estimation_Sangeun.py
@@ -1,8 +1,10 @@
 """B09 단가산출근거 · 단가산출근거목록표(PLAN 145-1) — 서버 단독(③ · 화면 짝 없음 · 저장 안 함).
 
-산근 호표 = 연결된 사본(`linked_snapshots` · 143-1)의 일위대가 로직 줄 중
-    `승격: true` 인 줄(134-1 · 입력값 = 사본 `입력값.json` · 빈 입력 = 자동값) +
-    옛 단가승격 참조 줄(134-2 ③ 로 남은 SP · 입력값 = 굳힌 `참조사본`)
+산근 호표(155-4 · 엑셀 꼴 · 145 정함 뒤집음) = 연결된 사본(`linked_snapshots` · 143-1)의
+    단가산출 줄(일위대가화 아닌 돈 로직 줄 · 입력값 = 사본 `입력값.json` · 빈 입력 = 자동값) +
+    사전조합(SC 참조 · 굳힌 `참조사본`) 안 단가산출 줄(입력값 = 그 문서 값) +
+    일위대가화 줄(승격 · 옛 SP)의 하위 로직 줄(기계경비 밖 · 입력 = 부르는 식 값)
+    — 노무 · 자재 · 중기 줄은 각 목록표(산근 아님) · 일위대가화 줄 자체 = 대가(145-2 블록)
     같은 로직 + 같은 입력값(+ 켜쌓기율 · 고른 자재) = 산근 하나(`sangeun_key`) ·
     번호 = 첫 등장 차례 ·
     로직 줄이 부르는 다른 돈 로직(기계경비 밖) = 하위 산근(그 산근도 목록에 · 산근 → 산근).
@@ -18,6 +20,9 @@
     + 「연결 없음」.
 조합 밖 토공 · 운반 · 사토 산근 · 준비공 = 원천 없음(만들지 않음 · 목록 안내 한 줄).
 대가(145-2) · 내역서(145-3)가 읽는 길 = `sangeun_key` + `price_of`.
+텍스트 수식(155-5) = `B09_Estimation_Sangeun_Text`(같은 B09 단가) — `head`(머리 · 입력 · 중간) ·
+    줄 `text`(줄마다 · 중기 = 노 · 재 · 경 세 줄) · `foot`(계) · % 덧줄 = 규격 「노무비의 %」 ·
+    수량 = 율 · 단위 %(149-4 `pct_extras`).
 """
 
 from __future__ import annotations
@@ -33,6 +38,7 @@ from B09_Estimation.B09_Estimation_Calc_Base import gap, num, round_half, roundd
 from M01_MasterData import M01_MasterData_Store as m01
 from M01_MasterData import M01_MasterData_Store_Combo as combo_store
 from M02_MasterTemplete import M02_Item_Prices as item_prices
+from M02_MasterTemplete import M02_Labor_Doc as labor_doc
 from M02_MasterTemplete.M02_Item_Snapshot import (
     PICKS_FILE,
     VALUES_FILE,
@@ -47,7 +53,7 @@ COST_PART = {"노무비": "labor", "재료비": "material", "경비": "expense"}
 DEPTH = 4  # 하위 산근 깊이 상한
 _Q = re.compile(r"Q\d*")  # 작업량 중간값 이름(산림품셈 09장 토공 · 07장 집재 …)
 NO_SOURCE = "조합 밖 토공 · 운반 · 사토 산근 · 준비공 = 원천 없음(연결 없음 · 만들지 않음)"
-EMPTY = "연결된 구조물 조합 사본에 단가승격 줄 없음 — 연결 없음"
+EMPTY = "연결된 구조물 조합 사본에 단가산출 줄 없음 — 연결 없음"
 
 
 # ── 산근 정체 ─────────────────────────────────────────────────────────
@@ -81,42 +87,57 @@ def _values(values: dict[str, Any], code: str) -> dict[str, Any]:
     return {name: (one or {}).get("값") for name, one in (values.get(code) or {}).items()}
 
 
-def rows_of(folder: Path) -> list[dict[str, Any]]:
-    """사본 하나의 산근 원천 줄 — 승격 로직 줄 · 옛 SP 참조 줄(차례대로)."""
+def rows_of(folder: Path, whole: Any = None) -> list[dict[str, Any]]:
+    """사본 하나의 산근 원천 줄(차례대로) — 단가산출 줄 · 사전조합 안 단가산출 줄 ·
+    일위대가화 줄(승격 · 옛 SP)의 하위 로직 줄. 키 = 대가 블록 산근 줄 키(`Labor_Source`)와 같음."""
     from M02_MasterTemplete import M02_Labor_Ref as refs
 
     labor = read_json(folder / LABOR_FILE)
     if not isinstance(labor, dict):
         return []
+    if whole is None:
+        whole = item_prices.load_prices(read_json(folder / PRICE_FILE) or {})
     values = read_json(folder / VALUES_FILE) or {}
     picks = read_json(folder / PICKS_FILE) or {}
     copies = labor.get("참조사본") or {}
-    out = []
-    for one in (labor.get("줄") or {}).get("담은로직") or []:
-        if not isinstance(one, dict):
-            continue
-        ref = one.get("참조")
-        if one.get("승격") is True and one.get("로직"):
-            code = str(one["로직"])
-            got = {
-                "code": code,
-                "given": _values(values, code),
-                "rate": one.get("켜쌓기율"),
-                "picks": picks.get(code) or one.get("고름"),
-            }
-        elif isinstance(ref, dict) and refs.kind_of(ref.get("키")) == "promote":
-            line = ((copies.get(refs.ref_id(ref)) or {}).get("담은로직") or [None])[0]
-            if not isinstance(line, dict) or not line.get("로직"):
+    out: list[dict[str, Any]] = []
+
+    def logic_line(code: str, given: Any, rate: Any, chosen: Any, promoted: bool) -> None:
+        if not is_money(whole, code):
+            return
+        if not promoted:
+            out.append({"code": code, "given": _clean_given(given), "rate": rate, "picks": chosen})
+            return
+        for call in line_calls(whole, code, given, chosen).values():
+            if call and call.get("code"):
+                out.append({"code": call["code"], "given": call["given"], "rate": None,
+                            "picks": None})  # fmt: skip
+
+    def walk(lines: list, inner: bool, depth: int) -> None:
+        for one in lines:
+            if not isinstance(one, dict):
                 continue
-            got = {
-                "code": str(line["로직"]),
-                "given": line.get("입력값") or {},
-                "rate": line.get("켜쌓기율"),
-                "picks": line.get("고름"),
-            }
-        else:
-            continue
-        out.append({**got, "given": _clean_given(got["given"])})
+            ref = one.get("참조")
+            if isinstance(ref, dict):
+                doc = copies.get(refs.ref_id(ref))
+                if not isinstance(doc, dict) or depth >= refs.DEPTH:
+                    continue
+                if refs.kind_of(ref.get("키")) == "promote":  # 옛 SP = 일위대가화
+                    first = (doc.get("담은로직") or [None])[0]
+                    if isinstance(first, dict) and first.get("로직"):
+                        logic_line(str(first["로직"]), first.get("입력값"),
+                                   first.get("켜쌓기율"), first.get("고름"), True)  # fmt: skip
+                    continue
+                walk(doc.get("담은로직") or [], True, depth + 1)  # 사전조합 = 굳힌 값
+                continue
+            if not one.get("로직"):
+                continue
+            code = str(one["로직"])
+            given = one.get("입력값") if inner else _values(values, code)
+            chosen = one.get("고름") if inner else (picks.get(code) or one.get("고름"))
+            logic_line(code, given, one.get("켜쌓기율"), chosen, one.get("승격") is True)
+
+    walk((labor.get("줄") or {}).get("담은로직") or [], False, 0)
     return out
 
 
@@ -136,6 +157,11 @@ def _unit(code: str) -> tuple[str, Decimal]:
     return str(pill.get("단위") or ""), Decimal(str(pill.get("배") or 1))
 
 
+def unit_of(code: str) -> str:
+    """산근 1 단위 이름(「원/10㎡」 = ㎡)."""
+    return _unit(code)[0]
+
+
 def _env(whole: Any, row: dict, given: dict) -> dict:
     """입력(빈 입력 = 자동값) + 중간값 · 작업량 Q = ROUND(식, 2)(엑셀 자리)."""
     auto = {k: v for k, v in m01.mau.values(whole, row).items() if v is not None}
@@ -152,6 +178,53 @@ def _env(whole: Any, row: dict, given: dict) -> dict:
     return env
 
 
+def is_money(whole: Any, code: str) -> bool:
+    """돈 로직(호표 줄 꼴)인지 — 없는 로직 · 흐름 · 결과 로직 = 아님."""
+    try:
+        row = whole.logic(code)
+    except mf.FormulaError:
+        return False
+    return not (isinstance(row.get("흐름"), dict) or "결과" in row)
+
+
+def call_of(whole: Any, item: dict, env: dict) -> dict[str, Any] | None:
+    """로직 호표 줄(종류 로직) → 부른 것 — 기계경비 로직 `{machine: EQ 키 | None}` ·
+    다른 돈 로직 `{code, given}`(하위 산근) · 못 펼치면 None.
+    대가 품셈 줄(`B09_Estimation_Labor_Source`)과 산근 풀이가 같은 판정을 씀."""
+    node = mf.parse(item["요소"])
+    called = node[1] if node and node[0] == "logic" else None
+    try:
+        target = whole.logic(called) if called else None
+    except mf.FormulaError:
+        target = None
+    if not target:
+        return None
+    if any(s.get("이름") == "기계" for s in target.get("입력", [])):
+        keys = _captured(whole, node, env)
+        return {"machine": keys[0] if keys else None}
+    given = {name: mf.evaluate(expr, env, whole, 1) for name, expr in node[2]}
+    return {"code": called, "given": _clean_given(given)}
+
+
+def line_calls(whole: Any, code: str, given: Any, picks: Any = None) -> dict[int, dict | None]:
+    """로직 하나의 로직 호표 줄마다 `call_of`(호표 차례 n → 부른 것) — 못 셈 줄 = None."""
+    try:
+        row = whole.logic(code)
+        env = _env(whole, row, _clean_given(given))
+    except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
+        return {}
+    out: dict[int, dict | None] = {}
+    with mf.mp.choosing(picks):
+        for n, item in enumerate(row.get("호표", [])):
+            if item.get("종류") != "로직":
+                continue
+            try:
+                out[n] = call_of(whole, item, env)
+            except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
+                out[n] = None
+    return out
+
+
 def _captured(whole: Any, node: Any, env: dict) -> list[str]:
     """식을 돌리며 부른 기계 키(EQ) — 기계경비 로직 줄의 기계."""
     seen: list[str] = []
@@ -228,6 +301,7 @@ class Solver:
             return self._stop(code, name, str(e) or type(e).__name__)
         sums = block_totals(lines)
         why = next((ln["why"] for ln in lines if ln.get("why")), None)
+        head, foot = self._text(whole, src, times, lines)
         return {
             "logic": code,
             "name": name,
@@ -237,12 +311,47 @@ class Solver:
             "lines": lines,
             **sums,
             "why": why,
+            "head": head,
+            "foot": foot,
         }
 
     @staticmethod
     def _stop(code: str, name: str, why: str) -> dict[str, Any]:
         return {"logic": code, "name": name, "spec": "", "unit": "", "source": "", "lines": [],
-                **dict.fromkeys(PARTS), "sum": None, "why": why}  # fmt: skip
+                **dict.fromkeys(PARTS), "sum": None, "why": why,
+                "head": [], "foot": ""}  # fmt: skip
+
+    def price_of(self, key: str) -> Any:
+        """글 짓기 단가(`Sangeun_Text` 꼴) — 노무 · 자재 = 수 · 중기 · 산근 = 비목 단가 묶음."""
+        if key in self.prices.labor:
+            return self.prices.labor[key]
+        if key in self.prices.material:
+            return self.prices.material[key]
+        if key in self.prices.machine:
+            return {p: num(self.prices.machine[key].get(p)) for p in PARTS}
+        block = self.blocks.get(key)
+        return {k: block.get(k) for k in (*PARTS, "sum", "no")} if block else None
+
+    def _text(self, whole, src, times, lines) -> tuple[list[str], str]:
+        """텍스트 수식(155-5) → (머리 줄들, 계) · 줄마다 `text` 를 얹음(중기 = 세 줄 · 그 밖 한 줄).
+        줄 수가 안 맞으면 모두 머리에(값 칸과 어긋나게 얹지 않음)."""
+        from B09_Estimation.B09_Estimation_Sangeun_Text import render_sangeun_text
+
+        try:
+            text = render_sangeun_text(whole, src["code"], src["given"], self.price_of,
+                                       times=times, rate=src.get("rate"),
+                                       picks=src.get("picks"))  # fmt: skip
+        except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
+            return [], ""
+        counts = [3 if ln["kind"] == "machine" and not ln.get("why") else 1 for ln in lines]
+        start = len(text) - 1 - sum(counts)
+        if start < 1:
+            return text, ""
+        at = start
+        for ln, n in zip(lines, counts):
+            ln["text"] = text[at : at + n]
+            at += n
+        return text[:start], text[-1]
 
     def _blank(self, item: dict, why: str) -> dict[str, Any]:
         part = COST_PART.get(item.get("비목"), "material")
@@ -278,6 +387,11 @@ class Solver:
         key = str(
             goods.get("키") or (source or "").split(".")[0] or (ref if isinstance(ref, str) else "")
         )
+        if key not in self.prices.material:  # 자리표시 글(「MO:경유:전국평균」) = 대비표 키로
+            try:
+                key = str((whole.get(key) or {}).get("키") or key)
+            except (mf.FormulaError, KeyError, TypeError, ValueError):
+                pass
         part = COST_PART.get(item.get("비목"), "material")
         price = self.prices.material.get(key)
         if q == 0:
@@ -289,14 +403,9 @@ class Solver:
                 "price": {part: price}, part: _money(price, q), "why": why}  # fmt: skip
 
     def _logic_line(self, whole, item, env, q, base, zero, depth) -> dict[str, Any]:
-        node = mf.parse(item["요소"])
-        called = node[1] if node and node[0] == "logic" else None
-        try:
-            target = whole.logic(called) if called else None
-        except mf.FormulaError:
-            target = None
-        if target and any(s.get("이름") == "기계" for s in target.get("입력", [])):
-            keys = _captured(whole, node, env)
+        call = call_of(whole, item, env)
+        if call and "machine" in call:
+            keys = [call["machine"]] if call["machine"] else []
             m = self.prices.machine.get(keys[0]) if keys else None
             price = {p: num((m or {}).get(p)) for p in PARTS}
             why = None if m else f"중기목록표에 없음 「{keys[0] if keys else item.get('이름')}」"
@@ -304,22 +413,28 @@ class Solver:
             ref = {"tab": "machine", "key": keys[0] if keys else ""}
             return {**base, "kind": "machine", "ref": ref,
                     "price": price, **amounts, "why": why}  # fmt: skip
-        if not target or depth >= DEPTH:
+        if not call or depth >= DEPTH:
             return {**self._blank(item, "하위 로직을 못 펼침"), **base}
-        given = {name: mf.evaluate(expr, env, whole, 1) for name, expr in node[2]}
-        sub = self.add(whole, {"code": called, "given": _clean_given(given)}, None, depth + 1)
+        sub = self.add(whole, {"code": call["code"], "given": call["given"]}, None, depth + 1)
         price = {p: sub.get(p) for p in PARTS}
         why = None if sub.get("sum") is not None else f"하위 산근 {sub['no']} 빈칸"
         return {**base, "kind": "sangeun", "ref": {"tab": "sg", "key": sub["key"]},
                 "price": price, **{p: _money(price[p], q) for p in PARTS}, "why": why}  # fmt: skip
 
     def _extras(self, whole, row, env, lines) -> None:
-        """% 줄(덧줄) — 엔진 식 그대로 · 밑수 = 그때까지 B09 비목 합 · 줄 금액 = 이름별."""
-        for extra in row.get("덧줄", []):
+        """% 줄(덧줄) — 엔진 식 그대로 · 밑수 = 그때까지 B09 비목 합 · 줄 금액 = 이름별 ·
+        「X * Y / 100」 덧줄 = 규격 「노무비의 %」 · 수량 = 율 · 단위 %(149-4 `pct_extras`)."""
+        heads = [{} for _ in row.get("호표", [])]
+        pcts = labor_doc.pct_extras(
+            whole, row, heads + [{} for _ in row.get("덧줄", [])], dict(env)
+        )
+        for extra, pct in zip(row.get("덧줄", []), pcts[len(heads) :]):
             sums = {name: total([ln[p] for ln in lines]) for name, p in COST_PART.items()}
             part = COST_PART.get(extra.get("비목"), "material")
             line = {"kind": "extra", "name": extra["이름"], "spec": extra["식"], "qty": 1.0,
                     "unit": "식", "ref": None, **dict.fromkeys(PARTS, 0.0)}  # fmt: skip
+            if "율" in pct:
+                line.update(spec=pct.get("규격") or extra["식"], qty=float(pct["율"]), unit="%")
             if any(v is None for v in sums.values()):
                 lines.append({**line, part: None, "price": {}, "why": "밑수 빈칸"})
                 continue
@@ -342,11 +457,8 @@ def collect(entries: list[tuple[str, Path]], sheets: dict[str, Any]) -> dict[str
     """`entries` = [(구조물 id, 사본 폴더)] → 블록 · 목록 · 「연결 없음」."""
     solver = Solver(sheets)
     for owner, folder in entries:
-        rows = rows_of(folder)
-        if not rows:
-            continue
         whole = item_prices.load_prices(read_json(folder / PRICE_FILE) or {})
-        for src in rows:
+        for src in rows_of(folder, whole):
             solver.add(whole, src, owner)
     blocks = sorted(solver.blocks.values(), key=lambda b: b["no"])
     listing = [
diff --git a/B09_Estimation/B09_Estimation_Sangeun_Text.py b/B09_Estimation/B09_Estimation_Sangeun_Text.py
new file mode 100644
index 000000000..cd2deffa1
--- /dev/null
+++ b/B09_Estimation/B09_Estimation_Sangeun_Text.py
@@ -0,0 +1,253 @@
+"""B09 산근 한 항목 → 엑셀 단가산출근거 꼴 텍스트 수식 줄들(PLAN 155-5) — 서버 단독(③ · 순수 함수).
+
+꼴 = 엑셀 단가산출근거 탭 산출내역 한 칸 글:
+    머리 「이름 / 단위」 · 출처 「… 적용」 · 입력 「이름 : 값 단위」 ·
+    중간 「Q = 이름식 = 값」(작업량 Q = ROUND 2 — `Sangeun._env`) ·
+    줄 「보통인부 : 172,068 * 0.022 = 3,785.4」(단가 * 수량식 값 꼴[ / 배][ * 율 %] = 금액) ·
+    중기 = 노무비 · 재료비 · 경비 세 줄 · 하위 산근 = 「산근 n호표 단가 * 수량」 ·
+    % 덧줄 = 「이름 (노무비의 %) : 밑수 * n % = 금액」(규격 = 149-4 `pct_extras`) ·
+    끝 = 「계 : 노무비 + 재료비 + 경비 = 합」.
+식 풀이 = 엔진 `master_text` 낮은 부품(render · _names · fmt) · 단가 = 인자 `price_of(key)`(B09 굳힌
+    단가 · 엔진 단가 글은 안 씀) · 단가 없음 = 「단가 없음」 글.
+끝수 = 엑셀 자리 — 줄 ROUNDDOWN 1 · 계 비목마다 ROUNDDOWN 0(`Sangeun._money` · `block_totals`).
+`price_of(key)` — 인력 · 자재 키 → 수 | None · 기계(EQ) · 하위 산근(SG:) → {labor, material, expense
+    [, sum, no]} | None.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any
+
+from B09_Estimation import B09_Estimation_Sangeun as sg
+from M01_MasterData import M01_MasterData_Store as m01
+from M02_MasterTemplete import M02_Labor_Doc as labor_doc
+
+mf = sg.mf
+mtx = m01.mtx
+PART_NAME = {"labor": "노무비", "material": "재료비", "expense": "경비"}
+_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
+NO_PRICE = "단가 없음"
+
+PriceOf = Callable[[str], Any]
+
+
+def _money(value: float | None) -> str:
+    return "빈칸" if value is None else f"{value:,.1f}"
+
+
+def _price(value: Any) -> str:
+    return NO_PRICE if value is None else mtx.fmt_price(Decimal(str(value)))
+
+
+def _qty_text(item: dict, env: dict, whole: Any, times: Decimal, rate: Decimal | None) -> str:
+    """수량식 값 꼴 — 덧셈 묶음이면 괄호 · 결과단위 배 「/ 배」 · 켜쌓기율 「* 율 %」."""
+    text = mtx._times(mtx.render(mf.parse(item["수량"]), env, whole), item, env, whole)
+    if times != 1:
+        text += f" / {mtx.fmt(times)}"
+    if rate is not None:
+        text += f" * {mtx.fmt(rate * 100)} %"
+    return text
+
+
+def _line(name: str, price: Any, qty_text: str, q: float) -> tuple[str, float | None]:
+    money = None if price is None else sg._money(float(price), q)
+    return f"{name} : {_price(price)} * {qty_text} = {_money(money)}", money
+
+
+def _head(row: dict, env: dict, whole: Any, times: Decimal) -> list[str]:
+    unit = str(row.get("결과단위") or "").removeprefix("원/")
+    if times != 1:
+        unit = unit.removeprefix(mtx.fmt(times))
+    out = [f"{row.get('이름') or row.get('키')} / {unit}"]
+    if row.get("출처"):
+        out.append(f"{row['출처']} 적용")
+    for spec in row.get("입력", []):
+        value = env.get(spec["이름"])
+        if value is None:
+            continue
+        shown = mtx.fmt(value) if isinstance(value, Decimal) else str(value)
+        tail = f" {spec['단위']}" if spec.get("단위") else ""
+        out.append(f"{spec['이름']} : {shown}{tail}")
+    name_of = mf_names(row, whole)
+    for step in row.get("중간", []):
+        value = env.get(step["이름"])
+        if value is None or isinstance(value, mf.Blank):
+            out.append(f"{step['이름']} = 값 없음")
+            continue
+        shown = mtx.fmt(value)
+        try:
+            named = mtx._names(step["식"], env, whole, name_of)
+        except _ERRORS:
+            named = shown
+        out.append(
+            f"{step['이름']} = {shown}" if named == shown else f"{step['이름']} = {named} = {shown}"
+        )
+    return out
+
+
+def mf_names(row: dict, whole: Any) -> dict:
+    """별칭 이름표(표 찾기 · 로직 부르기 → 짧은 이름) — 못 지으면 빈 표(값 꼴로 물러남)."""
+    try:
+        return mtx.mc.names(mtx.mc.aliases(row, whole))
+    except _ERRORS:
+        return {}
+
+
+def _material_key(whole: Any, item: dict, ref: Any, env: dict, n: int) -> tuple[str, str]:
+    """자재 줄 (대비표 키, 규격) — 자리표시 글(「MO:경유:전국평균」)은 그 요소의 실제 키로."""
+    _p, source, _w, extra = mf.mp.priced(whole, item, ref, env, n)
+    goods = (extra or {}).get("품목") or {}
+    key = str(
+        goods.get("키") or (source or "").split(".")[0] or (ref if isinstance(ref, str) else "")
+    )
+    if ":" in key:
+        try:
+            key = str(whole.get(key).get("키") or key)
+        except _ERRORS:
+            pass
+    return key, str(goods.get("규격") or "")
+
+
+def _logic_lines(whole, item, env, qty_text, q, price_of) -> list[tuple[str, dict]]:
+    """로직 부르기 줄 — 기계경비 = 중기 노 · 재 · 경 세 줄 · 그 밖 = 하위 산근 한 줄."""
+    node = mf.parse(item["요소"])
+    called = node[1] if node and node[0] == "logic" else None
+    try:
+        target = whole.logic(called) if called else None
+    except mf.FormulaError:
+        target = None
+    name = item.get("이름", "")
+    if target and any(s.get("이름") == "기계" for s in target.get("입력", [])):
+        keys = sg._captured(whole, node, env)
+        got = price_of(keys[0]) if keys else None
+        if not got:
+            return [(f"{name} : {NO_PRICE} * {qty_text}", dict.fromkeys(sg.PARTS))]
+        out = []
+        for part in sg.PARTS:
+            text, money = _line(f"{name} {PART_NAME[part]}", got.get(part), qty_text, q)
+            out.append((text, {part: money}))
+        return out
+    if not target:
+        return [(f"{name} : 하위 로직을 못 펼침", dict.fromkeys(sg.PARTS))]
+    given = {k: mf.evaluate(expr, env, whole, 1) for k, expr in node[2]}
+    got = price_of(sg.sangeun_key(called, sg._clean_given(given))) or {}
+    parts = {p: got.get(p) for p in sg.PARTS}
+    if any(v is None for v in parts.values()):
+        return [(f"{name} : {NO_PRICE} * {qty_text}", dict.fromkeys(sg.PARTS))]
+    amounts = {p: sg._money(float(v), q) for p, v in parts.items()}
+    head = f"산근 {got['no']}호표 " if got.get("no") else ""
+    unit = sum(float(v) for v in parts.values())
+    text = f"{name} : {head}{_price(unit)} * {qty_text} = {_money(sum(amounts.values()))}"
+    return [(text, amounts)]
+
+
+def _pct_specs(whole, row, env) -> list[str]:
+    """% 덧줄마다 규격(「노무비의 %」 · 149-4 `M02_Labor_Doc.pct_extras`) · % 아닌 덧줄 = 빈 글."""
+    head = [{} for _ in row.get("호표", [])]
+    tail = [{} for _ in row.get("덧줄", [])]
+    got = labor_doc.pct_extras(whole, row, head + tail, dict(env))[len(head) :]
+    return [str(one.get("규격") or "") for one in got]
+
+
+def _extra_lines(whole, row, env, amounts: list[dict]) -> list[tuple[str, dict]]:
+    """% 줄(덧줄) — 밑수 = 그때까지 B09 비목 합(`Sangeun._extras` 와 같음) · 금액 ROUNDDOWN 1."""
+    out: list[tuple[str, dict]] = []
+    specs = _pct_specs(whole, row, env)
+    for extra, spec in zip(row.get("덧줄", []), specs):
+        part = sg.COST_PART.get(extra.get("비목"), "material")
+        sums = {
+            name: sg.total([a.get(p, 0.0) for a in amounts]) for name, p in sg.COST_PART.items()
+        }
+        head = f"{extra['이름']}{f' ({spec})' if spec else ''} : "
+        if any(v is None for v in sums.values()):
+            out.append((f"{head}밑수 빈칸", {part: None}))
+            amounts.append({part: None})
+            continue
+        env.update({k: Decimal(str(v)) for k, v in sums.items()})
+        try:
+            node = mf.parse(extra["식"])
+            value = float(mf.evaluate(node, env, whole, 0))
+            shown = mtx.render(node, env, whole)
+        except _ERRORS as e:
+            out.append((f"{head}계산 못 함 — {e}", {part: None}))
+            amounts.append({part: None})
+            continue
+        money = sg.rounddown(value, 1)
+        out.append((f"{head}{shown} = {_money(money)}", {part: money}))
+        amounts.append({part: money})
+    return out
+
+
+def render_sangeun_text(
+    whole: Any,
+    logic_id: str,
+    inputs: dict | None,
+    price_of: PriceOf,
+    *,
+    times: Any = 1,
+    rate: Any = None,
+    picks: dict | None = None,
+) -> list[str]:
+    """산근 한 항목(로직 + 입력값 + 단가) → 엑셀 꼴 글 줄들.
+
+    whole = 사본 단가 묶음(`item_prices.load_prices`) · inputs = 입력값(빈 칸 = 자동값) ·
+    price_of = B09 단가 조회 · times = 결과단위 배(「원/10㎡」 = 10) ·
+    rate = 켜쌓기율 %(100 · None = 없음) · picks = 고른 자재."""
+    try:
+        row = whole.logic(logic_id)
+    except mf.FormulaError as e:
+        return [f"{logic_id} : 로직 없음 — {e}"]
+    times = Decimal(str(times or 1))
+    scale = Decimal(str(rate)) / 100 if rate not in (None, 100) else None
+    try:
+        env = sg._env(whole, row, sg._clean_given(inputs))
+    except _ERRORS as e:
+        return [f"{row.get('이름') or logic_id} : 입력을 못 읽음 — {e}"]
+    out = _head(row, env, whole, times)
+    amounts: list[dict] = []
+    with mf.mp.choosing(picks):
+        for n, item in enumerate(row.get("호표", [])):
+            name = item.get("이름", "")
+            try:
+                raw = mf.evaluate(mf.parse(item["수량"]), env, whole, 0)
+                qty_text = _qty_text(item, env, whole, times, scale)
+            except mf.EmptyInput as e:
+                out.append(f"{name} : 수량 없음 — {e}")
+                amounts.append({sg.COST_PART.get(item.get("비목"), "material"): None})
+                continue
+            q = float(Decimal(str(raw)) / times * (scale or 1))
+            kind = item.get("종류")
+            if kind == "로직":
+                for text, money in _logic_lines(whole, item, env, qty_text, q, price_of):
+                    out.append(text)
+                    amounts.append(money)
+                continue
+            if kind == "인력":
+                key = mf.fill(item["요소"], env) if isinstance(item["요소"], str) else ""
+                text, money = _line(name, price_of(key), qty_text, q)
+                out.append(text)
+                amounts.append({"labor": money})
+                continue
+            ref = (
+                {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()}
+                if isinstance(item["요소"], dict)
+                else mf.fill(item["요소"], env)
+            )
+            key, spec = _material_key(whole, item, ref, env, n)
+            price = price_of(key)
+            if q == 0 and price is None:
+                price = 0.0  # 안 쓰는 재료 줄 — 금액 0(`Sangeun._line` 과 같음)
+            label = f"{name}({spec})" if spec else name
+            text, money = _line(label, price, qty_text, q)
+            out.append(text)
+            amounts.append({sg.COST_PART.get(item.get("비목"), "material"): money})
+        for text, _money_part in _extra_lines(whole, row, env, amounts):
+            out.append(text)
+    sums = sg.block_totals([{**dict.fromkeys(sg.PARTS, 0.0), **a} for a in amounts])
+    parts = " + ".join(
+        f"{PART_NAME[p]} {'빈칸' if sums[p] is None else f'{sums[p]:,.0f}'}" for p in sg.PARTS
+    )
+    out.append(f"계 : {parts} = {'빈칸' if sums['sum'] is None else f'{sums["sum"]:,.0f}'}")
+    return out
diff --git a/B09_Estimation/B09_Estimation_UI_Shell.ts b/B09_Estimation/B09_Estimation_UI_Shell.ts
index 21808d2bf..aa1687d73 100644
--- a/B09_Estimation/B09_Estimation_UI_Shell.ts
+++ b/B09_Estimation/B09_Estimation_UI_Shell.ts
@@ -199,6 +199,7 @@ export function renderB09Estimation(root: HTMLElement): void {
       caption: TABS.find(([id]) => id === tab)?.[1],
       editable: spec.editable,
       onEdit: spec.onEdit,
+      rowClass: spec.rowClass,
       onCellClick: (i, key) => {
         if (spec.onCell) spec.onCell(i, key);
         if (spec.link && !spec.editable?.(i, key)) goto(spec.link(i, key));
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs.ts b/B09_Estimation/B09_Estimation_UI_Tabs.ts
index 8ffb8f9c9..ee28a789e 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs.ts
@@ -85,6 +85,8 @@ export interface TabTable {
   onEdit?: (index: number, key: string, text: string) => void;
   /** 칸 누름 → 그 자리 동작(예 관급 · 별도 표시 바꿈) */
   onCell?: (index: number, key: string) => void;
+  /** 줄 꼴 class(공용 표 `rowClass` · 예 제목 줄 굵게) */
+  rowClass?: (index: number) => string | null | undefined;
 }
 
 export type TabBuild = (ctx: TabContext) => TabTable | string;
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts
index 8114f1b5e..94d8e491f 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts
@@ -4,6 +4,7 @@
  *
  *   목록표 = 호표 한 줄(합계 · 노무비 · 재료비 · 경비) · 줄 누름 = 그 블록으로
  *   일위대가표 = 블록(머리 · [품셈 인용] · 줄 · 합계) · 줄 누름 = 단가를 낸 탭 · 줄(대가 줄 = 그 블록)
+ *   줄 꼴(155-2) = 머리 · 합계 굵게(`is-title`) · 인용 · 줄 = 들여쓰기 「ㄴ」(2단 · 겹 대가는 안 펼침)
  *   연결된 구조물 조합 사본이 없으면 빈 표 「연결 없음」
  * ========================================================================== */
 
@@ -21,6 +22,8 @@ import {
 
 const EMPTY =
   "연결 없음 — 연결된 구조물 조합 사본(일위대가)이 없음 · B05 · B06 에서 조합을 고르고 [저장]";
+/** 하위 줄 앞 — 들여쓰기 + 「ㄴ」(공용 표가 앞 빈칸을 접지 않음) */
+const CHILD = "  ㄴ ";
 const ROUNDS = "줄 금액 ROUNDDOWN(단가 × 수량, 1) · % 줄 = 밑수 × % / 100 · 합계 ROUNDDOWN 0";
 
 /** 블록 줄 → 단가를 낸 탭 */
@@ -29,7 +32,7 @@ const LINE_TAB: Record<string, TabId> = {
   material: "material",
   machine: "machine",
   daega: "dg",
-  sangeun: "sg_list",
+  sangeun: "sg",
 };
 
 export const buildDaegaList: TabBuild = ({ sheets }): TabTable | string => {
@@ -59,7 +62,9 @@ export const buildDaegaBlocks: TabBuild = ({ sheets }): TabTable | string => {
   if (!blocks.length) return EMPTY;
   const rows: DataRow[] = [];
   const links: Array<Link | null> = [];
+  const titles = new Set<number>();
   for (const b of blocks) {
+    titles.add(rows.length);
     rows.push({
       key: b.id,
       name: `제 ${b.no} 호표  ${b.name}`,
@@ -69,13 +74,13 @@ export const buildDaegaBlocks: TabBuild = ({ sheets }): TabTable | string => {
     });
     links.push(null);
     if (b.cite) {
-      rows.push({ key: `${b.id}|cite`, name: `  ${b.cite}`, note: "품셈 인용" });
+      rows.push({ key: `${b.id}|cite`, name: `${CHILD}${b.cite}`, note: "품셈 인용" });
       links.push(null);
     }
     b.lines.forEach((ln: Row, n: number) => {
       rows.push({
         key: `${b.id}|${n}`,
-        name: `  ${ln.name || ""}`,
+        name: `${CHILD}${ln.name || ""}`,
         spec: ln.spec || "",
         qty: ln.qty,
         unit: ln.unit || "",
@@ -92,6 +97,7 @@ export const buildDaegaBlocks: TabBuild = ({ sheets }): TabTable | string => {
       const tab = LINE_TAB[ln.kind];
       links.push(tab && ln.key ? { tab, key: String(ln.key) } : null);
     });
+    titles.add(rows.length);
     rows.push({
       key: `${b.id}|합계`,
       name: "  합  계",
@@ -122,5 +128,6 @@ export const buildDaegaBlocks: TabBuild = ({ sheets }): TabTable | string => {
     frozen: 1,
     hint: `단가 = B09 프로젝트 한 벌 굳힌 단가 · ${ROUNDS} · 줄 누름 = 단가를 낸 탭(대가 줄 = 그 블록)`,
     link: (i: number) => links[i] ?? null,
+    rowClass: (i: number) => (titles.has(i) ? "is-title" : null),
   };
 };
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts
index 57d6d8848..2b269a626 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts
@@ -4,8 +4,10 @@
  * (서버 단독 · 이 탭엔 조작 없음 · [저장] · [단가 갱신] 때 서버가 다시 셈).
  *
  *   목록표 = 산근 호표 한 줄(합계 · 노무비 · 재료비 · 경비 · 1 단위) · 줄 누름 = 그 블록
- *   풀이표 = 블록 머리(제 n 호표) · 줄(노무 · 중기 노 · 재 · 경 · 자재 · 하위 산근 · % 줄) · 총계
- *            줄 누름 = 단가를 낸 탭 · 줄(노무비목록표 · 중기목록표 · 자재단가대비표 · 하위 산근)
+ *   풀이표(155-5 · 엑셀 단가산출근거 꼴) = 공종 · 산출내역(서버가 지은 텍스트 수식 한 칸) · 합계 ·
+ *            노무비 · 재료비 · 경비 — 머리(제 n 호표 · 출처 · 입력 · 중간 Q) → 줄(중기 = 노 · 재 · 경
+ *            세 줄) → 총계(계) · 줄 누름 = 단가를 낸 탭 · 줄(노무비목록표 · 중기목록표 · 자재단가대비표 ·
+ *            하위 산근)
  * ========================================================================== */
 
 import type { DataRow } from "@ui/ui_template_data_table";
@@ -50,7 +52,7 @@ export const buildSgList: TabBuild = ({ sheets }): TabTable => {
     rows,
     frozen: 2,
     hint:
-      "산근 = 연결된 구조물 조합 사본의 「단가승격」 로직 줄 · 같은 로직 + 같은 입력값 = 한 호표 · 합계 = 블록 총계 · 줄 누름 = 그 블록" +
+      "산근 = 연결된 구조물 조합 사본의 단가산출 로직 줄 · 사전조합 안 줄 · 일위대가화 줄의 하위 로직(노무 · 자재 · 중기 줄은 각 목록표) · 같은 로직 + 같은 입력값 = 한 호표 · 합계 = 블록 총계 · 줄 누름 = 그 블록" +
       notes(sheets),
     link: (i) => (rows[i] ? { tab: "sg", key: String(rows[i].key) } : null),
   };
@@ -63,79 +65,85 @@ const LINE_TAB: Record<string, TabId> = {
   sg: "sg",
 };
 
+/** 공종 칸(엑셀 A 열) — 줄 꼴 이름 · 하위 산근 = 「산근 n호표」 */
+const KIND_NAME: Record<string, string> = { labor: "노무", machine: "중기", material: "자재" };
+
 export const buildSg: TabBuild = ({ sheets }): TabTable | string => {
   const rows: DataRow[] = [];
   const links: Array<Link | null> = [];
-  const push = (row: DataRow, link: Link | null = null): void => {
+  const titles = new Set<number>();
+  const push = (row: DataRow, link: Link | null = null, title = false): void => {
+    if (title) titles.add(rows.length);
     rows.push(row);
     links.push(link);
   };
-  for (const b of (sheets.sg as Row[]) || []) {
-    push({
-      key: b.key,
-      name: `제 ${b.no} 호표  ${b.name}`,
-      spec: b.spec,
-      unit: b.unit,
-      sum: b.sum,
-      labor: b.labor,
-      material: b.material,
-      expense: b.expense,
-    });
-    if (b.source) push({ key: `${b.key}|출처`, name: `  ${b.source}` });
+  const blocks = (sheets.sg as Row[]) || [];
+  const noOf: Record<string, number> = Object.fromEntries(blocks.map((b) => [b.key, b.no]));
+  for (const b of blocks) {
+    const head: string[] = b.head?.length ? b.head : [`${b.name} / ${b.unit}`];
+    push({ key: b.key, kind: `제 ${b.no} 호표`, text: head[0], note: b.spec }, null, true);
+    head.slice(1).forEach((line, n) => push({ key: `${b.key}|머리${n}`, text: `  ${line}` }));
     (b.lines as Row[]).forEach((ln, n) => {
       const link = ln.ref?.key ? { tab: LINE_TAB[ln.ref.tab] ?? "compare", key: ln.ref.key } : null;
-      // 중기 = 노 · 재 · 경 세 줄(엑셀 꼴) · 그 밖 = 한 줄
-      const parts = ln.kind === "machine" ? PARTS.filter((p) => ln.price?.[p] !== 0) : [null];
-      for (const part of parts) {
+      const kind =
+        ln.kind === "sangeun" && noOf[ln.ref?.key]
+          ? `산근 ${noOf[ln.ref.key]}호표`
+          : (KIND_NAME[ln.kind] ?? "");
+      // 중기 = 노 · 재 · 경 세 줄(엑셀 꼴 · 서버 글 줄과 같은 수) · 그 밖 = 한 줄
+      const parts = ln.kind === "machine" && !ln.why ? PARTS : [null];
+      const texts: string[] = ln.text || [];
+      parts.forEach((part, k) => {
         const at = (p: string): number | null => (part === null || part === p ? ln[p] : 0);
-        const price = part ? ln.price?.[part] : (Object.values(ln.price || {})[0] ?? null);
+        const fallback = `${ln.name}${part ? ` ${PART_NAME[part]}` : ""} · ${ln.qty ?? ""} ${ln.unit ?? ""}`;
         push(
           {
             key: `${b.key}|${n}${part ? `|${part}` : ""}`,
-            name: `  ${ln.name}${part ? ` ${PART_NAME[part]}` : ""}`,
-            spec: ln.why ? `${ln.spec ? `${ln.spec} · ` : ""}${ln.why}` : ln.spec,
-            qty: ln.qty,
-            unit: ln.unit,
-            price: price as number | null,
+            kind: k === 0 ? kind : "",
+            text: `  ${texts[k] ?? fallback}`,
             sum: PARTS.some((p) => at(p) === null)
               ? null
               : PARTS.reduce((s, p) => s + (at(p) as number), 0),
             labor: at("labor"),
             material: at("material"),
             expense: at("expense"),
+            note: ln.why ?? "",
           },
           link,
         );
-      }
-    });
-    push({
-      key: `${b.key}|총계`,
-      name: "  총  계",
-      spec: b.why ?? "",
-      sum: b.sum,
-      labor: b.labor,
-      material: b.material,
-      expense: b.expense,
+      });
     });
+    push(
+      {
+        key: `${b.key}|총계`,
+        kind: "총  계",
+        text: b.foot || "",
+        sum: b.sum,
+        labor: b.labor,
+        material: b.material,
+        expense: b.expense,
+        note: b.why ?? "",
+      },
+      null,
+      true,
+    );
   }
   if (!rows.length) return ((sheets.sg_notes as string[]) || []).join(" · ") || "산근 없음";
   return {
     columns: [
-      text("name", "공종 · 산출내역", 260),
-      text("spec", "규격 · 까닭", 180),
-      qty("qty", "수량"),
-      text("unit", "단위", 56),
-      money("price", "단가", undefined, 1),
+      text("kind", "공종", 90),
+      text("text", "산출내역", 520),
       money("sum", "합계", undefined, 1),
       money("labor", "노무비", undefined, 1),
       money("material", "재료비", undefined, 1),
       money("expense", "경비", undefined, 1),
+      text("note", "비고 · 까닭", 180),
     ],
     rows,
     frozen: 1,
     hint:
-      "수량 = 로직 품(1 단위 · 작업량 Q = ROUND 2) · 단가 = 굳힌 B09 단가 · 줄 ROUNDDOWN 1 · 총계 비목마다 ROUNDDOWN 0 · 자재 적용 단가를 고치면 [저장] 뒤 반영 · 줄 누름 = 단가를 낸 탭" +
+      "산출내역 = 값이 든 식(B09 굳힌 단가 * 수량 = 금액 · 작업량 Q = ROUND 2) · 줄 ROUNDDOWN 1 · 총계 비목마다 ROUNDDOWN 0 · 자재 적용 단가를 고치면 [저장] 뒤 반영 · 줄 누름 = 단가를 낸 탭" +
       notes(sheets),
     link: (i: number) => links[i] ?? null,
+    rowClass: (i: number) => (titles.has(i) ? "is-title" : null),
   };
 };
diff --git a/resources/tester/helper_ui_data_table.cjs b/resources/tester/helper_ui_data_table.cjs
index 3dad134c2..65a334c15 100644
--- a/resources/tester/helper_ui_data_table.cjs
+++ b/resources/tester/helper_ui_data_table.cjs
@@ -90,5 +90,25 @@ console.log(
     }),
     escaped: m.renderDataTableHtml({ columns: [{ key: "x", label: "<b>" }], rows: [{ x: "a&<" }] }),
     noTotal: m.renderDataTableHtml({ columns: [tc], rows: [] }).includes("<tfoot>"),
+    rowClass: m.renderDataTableHtml({
+      columns: [{ key: "x", label: "X" }],
+      rows: [{ x: "제 1 호표" }, { x: "  ㄴ 석공" }],
+      total: { x: 3 },
+      rowClass: (i) => (i === 0 ? "is-title" : null),
+    }),
+    scale: m.SCALE,
+    widths: m.renderDataTableHtml({
+      columns: [
+        { key: "a", label: "A" },
+        { key: "b", label: "B", kind: "number" },
+        { key: "c", label: "C", width: 120 },
+      ],
+      rows: [{ a: 1 }],
+      frozen: 2,
+    }),
+    css: fs.readFileSync(
+      path.join(__dirname, "..", "..", "ui_template", "ui_template_data_table.css"),
+      "utf8",
+    ),
   }),
 );
diff --git a/resources/tester/test_145_1_b09_sangeun.py b/resources/tester/test_145_1_b09_sangeun.py
index a1d99c70f..3c1af96ab 100644
--- a/resources/tester/test_145_1_b09_sangeun.py
+++ b/resources/tester/test_145_1_b09_sangeun.py
@@ -1,6 +1,7 @@
-"""145-1 B09 단가산출근거 · 목록표 — 승격 줄 → 산근 블록 · 엑셀 검산 · 같은 산근 하나 · 빈 표.
+"""145-1 B09 단가산출근거 · 목록표 — 단가산출 줄 → 산근 블록 · 엑셀 검산 · 같은 산근 하나 · 빈 표.
 
-- 산근 = 연결된 사본 일위대가 로직 줄 중 `승격: true` + 옛 SP 참조 줄(134-2 ③) · 승격 아닌 줄은 안 담음
+- 산근 = 155-4 갈래(사용자 뜻 · 145 정함 뒤집음) — 일위대가 로직 줄 중 단가산출 줄(승격 아님) +
+  사전조합 안 단가산출 줄 · 일위대가화(승격 · 옛 SP) 줄 자체는 산근 아님(대가 블록)
 - 줄 금액 = ROUNDDOWN(B09 굳힌 단가 × 1 단위 수량, 1) · 총계 = 비목마다 ROUNDDOWN 0 — 엑셀
   단가산출근거 제 6호표(뒷채움) 줄 값 · 총계 8,328(6,878 · 538 · 912)과 같음
 - 같은 로직 + 같은 입력값 = 산근 하나(쓰는 구조물이 늘어남) · 입력이 다르면 둘 · 번호 = 첫 등장
@@ -29,6 +30,7 @@ STONE = "GF000219"  # 돌쌓기 메쌓기(인력) — 석공 0.195 · 보통인
 NET = "GC000337"  # 낙석방지망 — 노무 · 크레인(중기) · 자재 셋
 NET_IN = {"구분": "기계식", "방지망": "포켓식", "지역": "전국평균", "크레인": "2104-0010"}
 SP_REF = {"층": "system", "주인": None, "키": "SP-000001"}
+SC_REF = {"층": "system", "주인": None, "키": "SC-000001"}
 
 
 def _snapshot(folder: Path, rows, values=None, copies=None) -> Path:
@@ -52,8 +54,8 @@ def _sheets(*folders: Path) -> dict:
     return compute_base(prices.build_inputs(None, list(dict.fromkeys(keys))), {})
 
 
-def test_승격_줄만_산근_블록_단가는_B09_표(tmp_path):
-    a = _snapshot(tmp_path / "a", [{"로직": STONE, "승격": True}, {"로직": NET}], {NET: NET_IN})
+def test_단가산출_줄만_산근_블록_단가는_B09_표(tmp_path):
+    a = _snapshot(tmp_path / "a", [{"로직": STONE}, {"로직": NET, "승격": True}], {NET: NET_IN})
     sheets = _sheets(a)
     got = sg.collect([("s1", a)], sheets)
     (block,) = got["sg"]
@@ -75,7 +77,7 @@ def test_승격_줄만_산근_블록_단가는_B09_표(tmp_path):
 
 
 def test_중기는_중기목록표_노_재_경_자재는_적용_단가(tmp_path):
-    a = _snapshot(tmp_path / "a", [{"로직": NET, "승격": True}], {NET: NET_IN})
+    a = _snapshot(tmp_path / "a", [{"로직": NET}], {NET: NET_IN})
     sheets = _sheets(a)
     (block,) = sg.collect([("s1", a)], sheets)["sg"]
     kinds = [ln["kind"] for ln in block["lines"]]
@@ -104,21 +106,26 @@ def test_엑셀_6호표_뒷채움_검산():
     assert sg.block_totals([labor, {**machine, "material": None}])["sum"] is None  # 빈칸 = 빈칸
 
 
-def test_같은_로직_같은_입력은_하나_다르면_둘_옛_SP_도_같은_산근(tmp_path):
-    a = _snapshot(tmp_path / "a", [{"로직": NET, "승격": True}], {NET: NET_IN})
-    b = _snapshot(tmp_path / "b", [{"로직": NET, "승격": True}], {NET: {**NET_IN, "": ""}})
+def test_같은_로직_같은_입력은_하나_다르면_둘_사전조합_안_줄도_같은_산근(tmp_path):
+    a = _snapshot(tmp_path / "a", [{"로직": NET}], {NET: NET_IN})
+    b = _snapshot(tmp_path / "b", [{"로직": NET}], {NET: {**NET_IN, "": ""}})
     other = {**NET_IN, "방지망": "비포켓식"}
-    c = _snapshot(tmp_path / "c", [{"로직": NET, "승격": True}], {NET: other})
-    sp = {"담은로직": [{"로직": NET, "입력값": NET_IN}], "배": 1}
+    c = _snapshot(tmp_path / "c", [{"로직": NET}], {NET: other})
+    sc = {"이름": "사전조합", "담은로직": [{"로직": NET, "입력값": NET_IN}]}
+    sp = {"담은로직": [{"로직": NET, "입력값": other}], "배": 1}  # 옛 SP = 일위대가화 = 산근 아님
     d = _snapshot(
         tmp_path / "d",
-        [{"로직": "", "참조": SP_REF}, {"로직": STONE, "승격": True}],
-        copies={"참조|system||SP-000001": sp},
+        [{"로직": "", "참조": SC_REF}, {"로직": "", "참조": SP_REF}, {"로직": STONE}],
+        copies={"참조|system||SC-000001": sc, "참조|system||SP-000001": sp},
     )
     got = sg.collect([("s1", a), ("s2", b), ("s3", c), ("s4", d)], _sheets(a, c, d))
     blocks = got["sg"]
     assert [(x["no"], x["logic"], x["uses"]) for x in blocks] == [
-        (1, NET, ["s1", "s2", "s4"]),  # 빈 입력 칸은 무시 · 옛 SP(같은 로직 · 입력) = 같은 산근
+        (
+            1,
+            NET,
+            ["s1", "s2", "s4"],
+        ),  # 빈 입력 칸은 무시 · 사전조합 안 줄(같은 로직 · 입력) = 같은 산근
         (2, NET, ["s3"]),
         (3, STONE, ["s4"]),
     ]
@@ -130,7 +137,7 @@ def test_사본_없으면_빈_표_연결_없음(tmp_path, monkeypatch):
     got = sg.collect([("s1", tmp_path / "없음")], {})
     assert got["sg"] == [] and got["sg_list"] == [] and got["sg_gaps"] == []
     assert got["sg_notes"] == [sg.NO_SOURCE, sg.EMPTY]
-    plain = _snapshot(tmp_path / "p", [{"로직": STONE}])  # 승격 없는 사본도 빈 표
+    plain = _snapshot(tmp_path / "p", [{"로직": STONE, "승격": True}])  # 일위대가화만 = 빈 표
     assert sg.collect([("s1", plain)], {})["sg"] == []
 
     async def fake_materials(_project_id):
@@ -143,7 +150,7 @@ def test_사본_없으면_빈_표_연결_없음(tmp_path, monkeypatch):
 
 
 def test_단가_없으면_빈칸과_연결_없음(tmp_path):
-    a = _snapshot(tmp_path / "a", [{"로직": STONE, "승격": True}])
+    a = _snapshot(tmp_path / "a", [{"로직": STONE}])
     got = sg.collect([("s1", a)], {"labor": [], "machine": [], "compare": []})
     (block,) = got["sg"]
     assert block["labor"] is None and block["sum"] is None
@@ -176,4 +183,5 @@ def test_화면_탭_둘_서버_산근_그대로():
     assert "gaps: [...base.gaps, ...(server.sg_gaps || [])" in shell  # 뒤에 대가(145-2) gaps 이음
     tabs = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Tabs_Sangeun.ts").read_text("utf-8")
     assert 'link: (i) => (rows[i] ? { tab: "sg", key: String(rows[i].key) } : null),' in tabs
-    assert "PARTS.filter((p) => ln.price?.[p] !== 0)" in tabs  # 중기 = 노 · 재 · 경 세 줄
+    # 155-5 — 중기 = 노 · 재 · 경 세 줄(서버 글 줄 수와 같게 · 값 0 줄도 둠)
+    assert 'const parts = ln.kind === "machine" && !ln.why ? PARTS : [null];' in tabs
diff --git a/resources/tester/test_145_2_b09_labor_calc.py b/resources/tester/test_145_2_b09_labor_calc.py
index 78e877bbf..10c566831 100644
--- a/resources/tester/test_145_2_b09_labor_calc.py
+++ b/resources/tester/test_145_2_b09_labor_calc.py
@@ -1,6 +1,8 @@
 """145-2 B09 일위대가표 · 일위대가목록표 — 엑셀 검산 대조 ·
 거울(`B09_Estimation_Calc_Labor.py` ↔ `.ts`) ·
 견본 사본 → 대가 블록(`B09_Estimation_Labor_Source`).
+견본 사본 단정 = 155-3 갈래(사용자 뜻 · 145 정함 뒤집음) — 일위대가화(승격) 줄 = 대가(품셈) 블록 ·
+단가산출 줄 = 산근 줄(수량 그대로) · 사전조합 = 겹 대가 · 비고 「산근 n호표」.
 
 엑셀 견본 = 기번3 공통 xlsx 「일위대가표」 같은 입력:
     대가1 모르터바르기 109,259 · 대가2 파형강관부설 D800 16,001(15,002 · 584 · 415 · 공구손료 2 %) ·
@@ -22,6 +24,7 @@ if str(ROOT) not in sys.path:
     sys.path.insert(0, str(ROOT))
 
 from B09_Estimation import B09_Estimation_Prices as prices  # noqa: E402
+from B09_Estimation import B09_Estimation_Sangeun as sangeun  # noqa: E402
 from B09_Estimation.B09_Estimation_Calc_Base import compute_base  # noqa: E402
 from B09_Estimation.B09_Estimation_Calc_Labor import compute_labor, daega_price  # noqa: E402
 from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs  # noqa: E402
@@ -257,8 +260,10 @@ def project(tmp_path_factory) -> Path:
     _snap(root, "pipe@100.0", "SS000901", LINES, _values(STONE))
     _snap(root, "pipe@200.0", "SS000901", LINES, _values(STONE))  # 같은 원본 + 같은 입력값
     _snap(root, "pipe@300.0", "SS000901", LINES, _values({**STONE, "높이": 5}))  # 입력값 다름
-    promoted = [
+    promoted = [  # 일위대가화 줄 셋(인력 · 중기 · 재료 + % 줄) + 사전조합
         {"로직": "GF000219", "승격": True, "수량": {"손": 1}},
+        {"로직": "GF000119", "승격": True, "수량": {"손": 1}},
+        {"로직": "GF000143", "승격": True, "수량": {"손": 1}},
         {"참조": {"층": "system", "주인": None, "키": "SC-T"}, "수량": {"손": 4}},
     ]
     _snap(root, "pipe@400.0", "SS000902", promoted, _values(STONE), SC)
@@ -274,14 +279,18 @@ def test_견본_사본_대가_블록(project):
         owners["pipe@100.0"] == owners["pipe@200.0"] != owners["pipe@300.0"]
     )  # 같은 원본+입력 = 한 호표
     blocks = {b["id"]: b for b in got["blocks"]}
-    assert [b["kind"] for b in got["blocks"]] == ["조합"] * 3 + ["사전조합"] + ["품셈"] * 4
+    # 단가산출 줄은 대가 항목 아님 → 품셈 블록 = 일위대가화 줄 셋만
+    assert [b["kind"] for b in got["blocks"]] == ["조합"] * 3 + ["사전조합"] + ["품셈"] * 3
     a = blocks[owners["pipe@100.0"]]
-    assert [(ln["kind"], ln["qty"]) for ln in a["lines"]] == [
-        ("daega", 2),
-        ("daega", 0.5),
-        ("daega", 1),
+    assert [(ln["kind"], ln["key"][:11], ln["qty"]) for ln in a["lines"]] == [
+        ("sangeun", "SG:GF000219", 2),
+        ("sangeun", "SG:GF000119", 0.5),
+        ("sangeun", "SG:GF000143", 1),
     ]
-    stone, digger, crane = (blocks[ln["key"]] for ln in a["lines"])
+    b = blocks[owners["pipe@400.0"]]
+    assert [ln["kind"] for ln in b["lines"]] == ["daega"] * 4
+    stone, digger, crane = (blocks[ln["key"]] for ln in b["lines"][:3])
+    assert stone["kind"] == "품셈" and stone["name"] == "돌쌓기 메쌓기"
     assert [(ln["kind"], ln["key"]) for ln in stone["lines"]] == [
         ("labor", "LB000033"),
         ("labor", "LB000002"),
@@ -290,13 +299,13 @@ def test_견본_사본_대가_블록(project):
     assert digger["lines"][0]["kind"] == "machine" and digger["lines"][0]["key"].startswith("EQ")
     pct = crane["lines"][-1]
     assert pct["kind"] == "pct" and pct["base"] == "part:material" and pct["qty"] == 20
-    b = blocks[owners["pipe@400.0"]]
-    assert b["lines"][0]["kind"] == "sangeun" and b["lines"][0]["key"].startswith("SG:GF000219:")
-    sc = blocks[b["lines"][1]["key"]]
-    assert sc["kind"] == "사전조합" and b["lines"][1]["qty"] == 4
+    sc = blocks[b["lines"][3]["key"]]
+    assert sc["kind"] == "사전조합" and b["lines"][3]["qty"] == 4
     assert (
-        sc["lines"][0]["key"] == stone["id"] and sc["lines"][0]["qty"] == 3
-    )  # 겹 대가 = 같은 품셈
+        sc["lines"][0]["kind"] == "sangeun"
+        and sc["lines"][0]["key"] == a["lines"][0]["key"]
+        and sc["lines"][0]["qty"] == 3
+    )  # 사전조합 안 단가산출 줄 = 같은 산근(같은 로직 + 같은 입력값)
 
 
 def test_견본_사본_끝까지_셈(project):
@@ -304,14 +313,18 @@ def test_견본_사본_끝까지_셈(project):
     inputs = prices.build_inputs(None, keys)
     inputs["daega"] = daega_inputs(project)
     base = compute_base(inputs, {})
-    out = compute_labor(inputs["daega"], base)
+    sg_rows = {r["key"]: r for r in sangeun.build(project, base)["sg_list"]}
+    out = compute_labor(inputs["daega"], base, sg_rows)
     owner = inputs["daega"]["owners"]["pipe@100.0"]
     combo = _block(out, owner)
     assert combo["sum"] is not None and combo["no"] == 1
-    # 조합 줄 = 부른 품셈 합계 × 수량(ROUNDDOWN 1) · 합계 = ROUNDDOWN 0
+    # 조합 줄 = 산근 단가 × 수량(ROUNDDOWN 1) · 비고 「산근 n호표」 · 합계 = ROUNDDOWN 0
     for ln in combo["lines"]:
-        child = _block(out, ln["key"])
-        assert ln["prices"]["labor"] == child["labor"]
+        row = sg_rows[ln["key"]]
+        assert ln["prices"]["labor"] == row["labor"] and ln["ref_no"] == f"산근 {row['no']}호표"
+    # 일위대가화 블록 = 금액 다 참(기계 줄 빈칸 없음)
+    for ln in _block(out, inputs["daega"]["owners"]["pipe@400.0"])["lines"]:
+        assert _block(out, ln["key"])["sum"] is not None, ln["name"]
     price = daega_price(out, "pipe@100.0")
     assert price["no"] == "대가1" and price["sum"] == combo["sum"]
     assert daega_price(out, "pipe@500.0") is None  # 사본 없음 = 없음
@@ -367,7 +380,7 @@ def test_집계표_이음_꼴():
 
 def test_한_바퀴_내역_대가_산근_중기_집계표(tmp_path):
     """이음 끝 확인 — 설계내역서 구조물 줄(B08 열 owners) → 대가 블록마다 나눔 → 대가 줄 →
-    산근(145-1 · 승격 줄) → 중기 → 집계표(145-5) 역전개 · 짝 셈 한 벌 = Router.compute_sheets."""
+    산근(155-3 · 단가산출 줄) → 중기 → 집계표(145-5) 역전개 · 짝 셈 한 벌 = Router.compute_sheets."""
     from B09_Estimation.B09_Estimation_Calc_Base import rounddown
     from B09_Estimation.B09_Estimation_Router import compute_sheets
     from B09_Estimation.B09_Estimation_Summary import compute_summary, hopyo_lines
@@ -375,7 +388,7 @@ def test_한_바퀴_내역_대가_산근_중기_집계표(tmp_path):
     root = _project(tmp_path / "loop", [(100, "SS000901"), (400, "SS000902")])
     _snap(root, "pipe@100.0", "SS000901", LINES, _values(STONE))
     promoted = [
-        {"로직": "GF000119", "승격": True, "수량": {"손": 1}},  # 노체포설 = 산근 · 중기 줄
+        {"로직": "GF000119", "승격": True, "수량": {"손": 1}},  # 노체포설 = 일위대가화 · 중기 줄
         {"참조": {"층": "system", "주인": None, "키": "SC-T"}, "수량": {"손": 4}},
     ]
     _snap(root, "pipe@400.0", "SS000902", promoted, _values(STONE), SC)
@@ -400,11 +413,14 @@ def test_한_바퀴_내역_대가_산근_중기_집계표(tmp_path):
         block = _block(sheets, row["ref"]["key"])
         assert row["price_labor"] == block["labor"] and block["sum"] is not None
         assert row["labor"] == rounddown(row["qty"] * block["labor"], 0)
-    # 산근 이음 — 대가 줄 키 = 145-1 산근 키 · 단가가 들어옴
-    combo = _block(sheets, owners["pipe@400.0"])
+    # 산근 이음 — 단가산출 줄 키 = 145-1 산근 키 · 단가가 들어옴
+    combo = _block(sheets, owners["pipe@100.0"])
     sg_line = combo["lines"][0]
     sg_row = next(r for r in sheets["sg_list"] if r["key"] == sg_line["key"])
     assert sg_line["kind"] == "sangeun" and sg_line["prices"]["labor"] == sg_row["labor"]
+    # 일위대가화 줄 = 대가 블록 · 기계 줄 = 중기
+    digger = _block(sheets, _block(sheets, owners["pipe@400.0"])["lines"][0]["key"])
+    assert digger["kind"] == "품셈" and digger["lines"][0]["kind"] == "machine"
     # 집계표 역전개 — 대가 · 사전조합 · 품셈 · 산근 끝까지
     summary = compute_summary(sheets, hopyo_lines(sheets))
     assert summary["unlinked"] == 0
diff --git a/resources/tester/test_155_5_sangeun_text.py b/resources/tester/test_155_5_sangeun_text.py
new file mode 100644
index 000000000..314a1902d
--- /dev/null
+++ b/resources/tester/test_155_5_sangeun_text.py
@@ -0,0 +1,133 @@
+"""155-5 산근 텍스트 수식 — 엑셀 단가산출근거 꼴 글 줄(`B09_Estimation_Sangeun_Text`).
+
+- 엑셀 6호표 뒷채움: 「보통인부 : 165,545 * 0.018 = 2,979.8」 · 중기 노 · 재 · 경 세 줄 ·
+  「계 : 노무비 6,878 + 재료비 538 + 경비 912 = 8,328」(줄 ROUNDDOWN 1 · 계 ROUNDDOWN 0)
+- 엑셀 7호표 막자갈채집: 작업량 Q = ROUND 2 중간 줄 · 「55,700 * 1 / 21.59 * 2 = 5,159.7」
+- % 덧줄 = 「공구손료 (노무비의 %) : 6,878.8 * 3 % = 206.3」(규격 = 149-4 `pct_extras`)
+- 단가 없음 = 「단가 없음」 글 · 계 그 비목 빈칸 · 글 속 금액 = 산근 풀이(`Sangeun.Solver`) 줄 값
+"""
+
+import copy
+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 B09_Estimation import B09_Estimation_Sangeun as sg  # noqa: E402
+from B09_Estimation import B09_Estimation_Sangeun_Text as st  # noqa: E402
+from M02_MasterTemplete import M02_Item_Prices as item_prices  # noqa: E402
+
+BASE = "GF000218"  # 기초다짐 및 뒷채움(기계) — 보통인부 + 굴착기 0.2㎥ 로직 줄
+GIVEN = {"규격": 150, "지역": "전국평균", "보정작업": "해당 없음"}
+EXCEL_EQ = {"labor": 55700, "material": 7695, "expense": 13041}  # 중기목록표 굴삭기 0.2㎥
+
+
+def _whole(edit=None):
+    """사본 단가 묶음 — `edit(로직 줄)` 로 GF000218 을 엑셀 견본 꼴로 바꿈(수량 · 중간 · 덧줄)."""
+    files = copy.deepcopy(item_prices.to_json(item_prices.collect([BASE])))
+    if edit:
+        for data in files.values():
+            for row in data.get("줄") or []:
+                if isinstance(row, dict) and row.get("키") == BASE:
+                    edit(row)
+    return item_prices.load_prices(files)
+
+
+def _excel(qty_labor: str, qty_eq: str, mids=(), extras=()):
+    def edit(row):
+        labor, eq = row["호표"][0], row["호표"][1]
+        row["호표"] = [{**labor, "수량": qty_labor}, {**eq, "수량": qty_eq}]
+        row["중간"] = [{"이름": n, "식": f} for n, f in mids]
+        row["덧줄"] = list(extras)
+
+    return edit
+
+
+def _prices(labor):
+    return lambda key: EXCEL_EQ if key.startswith("EQ") else labor.get(key)
+
+
+def test_엑셀_6호표_뒷채움_같은_글():
+    whole = _whole(_excel("0.018", "0.07"))
+    got = st.render_sangeun_text(whole, BASE, GIVEN, _prices({"LB000002": 165545}))
+    assert got[:3] == ["기초다짐 및 뒷채움(기계) / ㎥", "산림품셈 13-3-2 적용", "규격 : 150 mm"]
+    assert got[-5:] == [
+        "보통인부 : 165,545 * 0.018 = 2,979.8",
+        "굴착기(무한궤도) 0.2㎥ 노무비 : 55,700 * 0.07 = 3,899.0",
+        "굴착기(무한궤도) 0.2㎥ 재료비 : 7,695 * 0.07 = 538.6",
+        "굴착기(무한궤도) 0.2㎥ 경비 : 13,041 * 0.07 = 912.8",
+        "계 : 노무비 6,878 + 재료비 538 + 경비 912 = 8,328",
+    ]
+
+
+def test_엑셀_7호표_작업량_Q_중간_줄():
+    whole = _whole(_excel("0", "1 / Q * 2", mids=[("Q", "21.594")]))
+    got = st.render_sangeun_text(whole, BASE, GIVEN, _prices({"LB000002": 165545}))
+    assert "Q = 21.594 = 21.59" in got  # ROUND(식, 2) 뒤 쓰임
+    assert "굴착기(무한궤도) 0.2㎥ 노무비 : 55,700 * 1 / 21.59 * 2 = 5,159.7" in got
+
+
+def test_퍼센트_덧줄_노무비의_퍼센트():
+    tool = {"이름": "공구손료", "식": "노무비 * 3 / 100", "비목": "경비"}
+    whole = _whole(_excel("0.018", "0.07", extras=[tool]))
+    got = st.render_sangeun_text(whole, BASE, GIVEN, _prices({"LB000002": 165545}))
+    assert got[-2:] == [
+        "공구손료 (노무비의 %) : 6,878.8 * 3 % = 206.3",  # 밑수 = 인력 + 중기 노무비
+        "계 : 노무비 6,878 + 재료비 538 + 경비 1,119 = 8,535",
+    ]
+
+
+def test_배_켜쌓기율_꼬리_단가_없음():
+    whole = _whole(_excel("0.018", "0.07"))
+    got = st.render_sangeun_text(whole, BASE, GIVEN, _prices({}), times=10, rate=90)
+    assert "보통인부 : 단가 없음 * 0.018 / 10 * 90 % = 빈칸" in got
+    assert got[-1] == "계 : 노무비 빈칸 + 재료비 48 + 경비 82 = 빈칸"
+
+
+def _solver_prices(whole, code, given):
+    """산근 풀이와 같은 단가 — 키마다 같은 수(노무 · 자재 1,000 · 중기 엑셀 값)."""
+    sheets = {"labor": [], "machine": [], "compare": []}
+    asked = []
+
+    def price_of(key):
+        asked.append(key)
+        return EXCEL_EQ if key.startswith("EQ") else 1000.0
+
+    st.render_sangeun_text(whole, code, given, price_of)
+    for key in dict.fromkeys(asked):
+        if key.startswith("EQ"):
+            sheets["machine"].append({"key": key, **EXCEL_EQ})
+        elif key.startswith("LB"):
+            sheets["labor"].append({"key": key, "price": 1000.0})
+        else:
+            sheets["compare"].append({"key": key, "applied": 1000.0})
+    return sheets, price_of
+
+
+def test_글_속_금액은_산근_풀이_값과_같음():
+    for code, given in ((BASE, GIVEN), ("GF000288", {})):  # 중기 · 노무 · % 덧줄 · 배 1,000
+        whole = item_prices.load_prices(item_prices.to_json(item_prices.collect([code])))
+        sheets, price_of = _solver_prices(whole, code, given)
+        block = sg.Solver(sheets).add(whole, {"code": code, "given": given}, "s1")
+        times = sg._unit(code)[1]  # 결과단위 배(「원/1,000㎡」) — 산근 풀이와 같은 1 단위
+        got = st.render_sangeun_text(whole, code, given, price_of, times=times)
+        parts = " + ".join(f"{st.PART_NAME[p]} {block[p]:,.0f}" for p in sg.PARTS)
+        assert got[-1] == f"계 : {parts} = {block['sum']:,.0f}", code
+
+
+def test_자재_자리표시_키는_실제_키로():
+    """「MO:휘발유:{지역}」 자리표시 = 대비표 키(MO…)로 물음 — 산근 풀이 흠(H4 · 155 데스크탑 보조가
+    고침)과 달리 단가가 나옴 · Q 중간 줄 · 「줄.'이름'」 % 덧줄."""
+    whole = item_prices.load_prices(item_prices.to_json(item_prices.collect(["GF000062"])))
+    asked = []
+
+    def price_of(key):
+        asked.append(key)
+        return 1000.0
+
+    got = st.render_sangeun_text(whole, "GF000062", {}, price_of)
+    assert not [k for k in asked if ":" in k] and any(k.startswith("MO") for k in asked)
+    assert "Q = 아키야윈치임업용윈치집재.수집량 = 8" in got and "일수 = 1 / Q = 0.125" in got
+    assert "휘발유(아키아윈치(휘발유)) : 1,000 * 6.5 * 0.125 = 812.5" in got
diff --git a/resources/tester/test_155_b09_sources.py b/resources/tester/test_155_b09_sources.py
new file mode 100644
index 000000000..449d9c637
--- /dev/null
+++ b/resources/tester/test_155_b09_sources.py
@@ -0,0 +1,133 @@
+"""155-3 · 155-4 B09 호표 갈래 — 사용자 뜻(10-9 둘째 · 145 정함 뒤집음 · M02 구분 짝 · 엑셀 꼴):
+일위대가화(승격) 줄 = 일위대가 호표(대가 블록) · 단가산출 줄 = 산근 ·
+일위대가화 줄의 하위 로직 줄 = 산근(대가 블록 산근 줄 키 = 산근 목록 키) ·
+산근 줄 수량 = 수량 그대로(배 10 로직 금액 1/배 흠) · 비고 「산근 n호표」(파이썬 · TS 짝) ·
+산근 자재 자리표시 키(「MO:경유:…」) = 자재단가대비표 키.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+for path in (ROOT, ROOT / "resources" / "tester"):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+import test_145_2_b09_labor_calc as t145  # noqa: E402
+
+from B09_Estimation import B09_Estimation_Prices as prices  # noqa: E402
+from B09_Estimation import B09_Estimation_Sangeun as sg  # noqa: E402
+from B09_Estimation.B09_Estimation_Calc_Base import compute_base, rounddown  # noqa: E402
+from B09_Estimation.B09_Estimation_Calc_Labor import compute_labor  # noqa: E402
+from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs  # noqa: E402
+from B09_Estimation.B09_Estimation_Linked import linked_resource_keys, used_keys  # noqa: E402
+from B09_Estimation.B09_Estimation_Router import compute_sheets  # noqa: E402
+from M02_MasterTemplete import M02_Item_Prices as item_prices  # noqa: E402
+
+PILE = "GF000233"  # 말뚝 다듬기 — 원/10개(배 10) · 인력 줄 둘
+PIPE = "GF000174"  # 흄관 부설 — 하위 로직 줄(GF000155 · GF000160) = 하위 산근
+FUEL = "GF000011"  # 재료 줄 「MO:경유:{지역}」 자리표시
+
+
+def _sheets_of(root):
+    inputs = prices.build_inputs(None, linked_resource_keys(root))
+    inputs["daega"] = daega_inputs(root)
+    inputs["hopyo"] = {}
+    inputs["bill"] = {"items": []}
+    return inputs, compute_sheets(root, inputs, {})
+
+
+def _blk(sheets, key):
+    return next(b for b in sheets["daega_blocks"] if b["key"] == key)
+
+
+def test_155_3_배_10_로직_산근_줄_수량_그대로_대가_줄만_나눔(tmp_path):
+    root = t145._project(tmp_path / "p", [(100, "SS000901"), (200, "SS000902")])
+    t145._snap(root, "pipe@100.0", "SS000901", [{"로직": PILE, "수량": {"손": 20}}], {})
+    t145._snap(
+        root, "pipe@200.0", "SS000902", [{"로직": PILE, "승격": True, "수량": {"손": 20}}], {}
+    )
+    inputs, sheets = _sheets_of(root)
+    owners = sheets["daega_owners"]
+    (sg_line,) = _blk(sheets, owners["pipe@100.0"])["lines"]
+    (dg_line,) = _blk(sheets, owners["pipe@200.0"])["lines"]
+    assert (sg_line["kind"], sg_line["qty"]) == ("sangeun", 20)  # 산근 단가 = 1 개
+    assert (dg_line["kind"], dg_line["qty"]) == ("daega", 2)  # 대가 블록 = 10 개
+    row = next(r for r in sheets["sg_list"] if r["key"] == sg_line["key"])
+    assert sg_line["ref_no"] == f"산근 {row['no']}호표" and dg_line["ref_no"].startswith("대가")
+    # 같은 일 · 같은 수량 = 금액 거의 같음(끝수 자리만 다름 · 예전 흠 = 1/10)
+    assert sg_line["amount"] is not None and dg_line["amount"] is not None
+    assert abs(sg_line["amount"] - dg_line["amount"]) <= 0.02 * dg_line["amount"]
+
+
+def test_155_4_일위대가화_하위_로직_줄_산근_목록에(tmp_path):
+    root = t145._project(tmp_path / "p", [(100, "SS000901")])
+    t145._snap(
+        root, "pipe@100.0", "SS000901", [{"로직": PIPE, "승격": True, "수량": {"손": 1}}], {}
+    )
+    inputs, sheets = _sheets_of(root)
+    (call,) = _blk(sheets, sheets["daega_owners"]["pipe@100.0"])["lines"]
+    pipe = _blk(sheets, call["key"])
+    assert pipe["kind"] == "품셈" and call["kind"] == "daega"
+    subs = [ln for ln in pipe["lines"] if ln["kind"] == "sangeun"]
+    listed = {r["key"]: r for r in sheets["sg_list"]}
+    assert {ln["key"][:11] for ln in subs} >= {"SG:GF000155", "SG:GF000160"}
+    for ln in subs:  # 대가 블록 산근 줄 = 산근 목록 줄(같은 키) · 비고 · 단가 이음
+        assert ln["key"] in listed and ln["ref_no"] == f"산근 {listed[ln['key']]['no']}호표"
+        assert ln["prices"]["labor"] == listed[ln["key"]]["labor"]
+    assert all(r["logic"] != PIPE for r in sheets["sg_list"])  # 일위대가화 줄 자체 = 산근 아님
+
+
+def test_155_4_산근_자재_자리표시_키_대비표로(tmp_path):
+    folder = tmp_path / "a"
+    folder.mkdir()
+    files = {
+        "단가.json": item_prices.to_json(item_prices.collect([FUEL])),
+        "일위대가.json": {"줄": {"종류": "일위대가", "담은로직": [{"로직": FUEL}]}},
+        "입력값.json": {},
+    }
+    for name, data in files.items():
+        (folder / name).write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+    sheets = compute_base(prices.build_inputs(None, used_keys(folder)), {})
+    (block,) = sg.collect([("s1", folder)], sheets)["sg"]
+    fuel = [ln for ln in block["lines"] if ln["kind"] == "material"]
+    assert fuel and all(ln["ref"]["key"].startswith("MO0") for ln in fuel)
+    applied = {r["key"]: r["applied"] for r in sheets["compare"]}
+    for ln in fuel:
+        assert ln["material"] == rounddown(applied[ln["ref"]["key"]] * ln["qty"], 1)
+
+
+def test_155_3_비고_산근_n호표_거울():
+    sangeun = {k: {**v, "no": n} for n, (k, v) in enumerate(t145.SANGEUN.items(), 1)}
+    py = json.loads(json.dumps(compute_labor(t145.EXCEL, t145.SHEETS, sangeun), ensure_ascii=False))
+    ts = t145._ts(t145.EXCEL, t145.SHEETS, sangeun)
+    assert t145._same(py, ts["out"])
+    notes = [
+        ln.get("ref_no") for b in py["daega_blocks"] for ln in b["lines"] if ln["kind"] == "sangeun"
+    ]
+    assert notes and notes[0] == "산근 1호표" and all(n and n.startswith("산근 ") for n in notes)
+
+
+def test_155_5_산근_글_줄마다_덧줄_퍼센트_표기(tmp_path):
+    lines = [{"로직": "GF000143", "수량": {"손": 1}}, {"로직": PILE, "수량": {"손": 20}}]
+    root = t145._project(tmp_path / "p", [(100, "SS000901")])
+    lines = [{"로직": "GF000143", "수량": {"손": 1}}, {"로직": PILE, "수량": {"손": 20}}]
+    t145._snap(root, "pipe@100.0", "SS000901", lines, {})
+    inputs, sheets = _sheets_of(root)
+    crane, pile = sheets["sg"]
+    assert crane["head"][:2] == ["케이블 크레인 운반대 설치 / 1기", "산림품셈 10-8-2 적용"]
+    extra = crane["lines"][-1]
+    assert (extra["kind"], extra["spec"], extra["qty"], extra["unit"]) == (
+        "extra", "재료비의 %", 20.0, "%",
+    )  # fmt: skip
+    assert extra["text"][0].startswith("기타비용 (재료비의 %) : ")
+    for b in (crane, pile):
+        for ln in b["lines"]:
+            money = sum(ln[p] or 0 for p in sg.PARTS)
+            assert ln["text"][-1].endswith(f"= {money:,.1f}") or ln["kind"] == "machine"
+        assert b["foot"] == (
+            f"계 : 노무비 {b['labor']:,.0f} + 재료비 {b['material']:,.0f}"
+            f" + 경비 {b['expense']:,.0f} = {b['sum']:,.0f}"
+        )
+    assert " / 10 = " in pile["lines"][0]["text"][0]  # 배 10 로직 꼬리
diff --git a/resources/tester/test_155_b09_tabs.py b/resources/tester/test_155_b09_tabs.py
new file mode 100644
index 000000000..4f58a2581
--- /dev/null
+++ b/resources/tester/test_155_b09_tabs.py
@@ -0,0 +1,104 @@
+"""155 B09 탭 화면 꼴 — 일위대가표 줄 꼴(155-2) · 단가산출근거 텍스트 수식 칸(155-5).
+
+`B09_Estimation_UI_Tabs.ts` + `B09_Estimation_UI_Tabs_Labor.ts` 를 Node(타입 지움)로 돌려
+견본 블록 하나(머리 · 품셈 인용 · 줄 둘 · 합계)의 표 줄 글 · 줄 꼴을 판정.
+"""
+
+import json
+import re
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+IMPORTS = re.compile(r"^import[^;]*;\n", re.MULTILINE)
+
+BLOCK = {
+    "id": "DG1",
+    "no": 1,
+    "name": "찰쌓기",
+    "spec": "",
+    "unit": "m2",
+    "kind": "품셈",
+    "cite": "건설표준품셈 7-1-2",
+    "lines": [
+        {"kind": "labor", "key": "L00005", "name": "석공", "qty": 0.072, "unit": "인",
+         "price": 258935, "amount": 18643.3, "ref_no": "노무3",
+         "prices": {"labor": 258935, "material": None, "expense": None},
+         "amounts": {"labor": 18643.3, "material": None, "expense": None}},
+        {"kind": "sangeun", "key": "SG1", "name": "뒷채움", "qty": 0.5, "unit": "m3",
+         "price": 8328, "amount": 4164, "ref_no": "산근 1호표",
+         "prices": {"labor": 6878, "material": 538, "expense": 912},
+         "amounts": {"labor": 3439, "material": 269, "expense": 456}},
+    ],
+    "sum": 22807, "labor": 22082, "material": 269, "expense": 456,
+}  # fmt: skip
+
+
+def _node(js_body, tab="UI_Tabs_Labor"):
+    src = "".join(
+        IMPORTS.sub("", (ROOT / "B09_Estimation" / f"B09_Estimation_{n}.ts").read_text("utf-8"))
+        for n in ("UI_Tabs", tab)
+    )
+    result = subprocess.run(
+        ["node", "--experimental-strip-types", "--no-warnings",
+         "--input-type=module-typescript", "-e", src + js_body],
+        capture_output=True, text=True, encoding="utf-8", timeout=60,
+    )  # fmt: skip
+    assert result.returncode == 0, result.stderr
+    return json.loads(result.stdout)
+
+
+def test_155_2_일위대가표_제목_굵게_하위_ㄴ():
+    out = _node(
+        f"\nconst t = buildDaegaBlocks({{ sheets: {{ daega_blocks: [{json.dumps(BLOCK)}] }} }});"
+        "\nconsole.log(JSON.stringify({ names: t.rows.map((r) => r.name),"
+        " cls: t.rows.map((_, i) => t.rowClass(i) ?? null) }));"
+    )
+    assert out["names"] == [
+        "제 1 호표  찰쌓기",
+        "  ㄴ 건설표준품셈 7-1-2",
+        "  ㄴ 석공",
+        "  ㄴ 뒷채움",
+        "  합  계",
+    ]
+    assert out["cls"] == ["is-title", None, None, None, "is-title"]
+
+
+SG = {
+    "key": "SG:A", "no": 1, "name": "뒷채움", "unit": "m3", "spec": "규격=150",
+    "head": ["뒷채움 / m3", "산림품셈 13-3-2 적용", "규격 : 150 mm"],
+    "lines": [
+        {"kind": "labor", "name": "보통인부", "ref": {"tab": "labor", "key": "LB2"}, "why": None,
+         "labor": 2979.8, "material": 0.0, "expense": 0.0,
+         "text": ["보통인부 : 165,545 * 0.018 = 2,979.8"]},
+        {"kind": "machine", "name": "굴착기", "ref": {"tab": "machine", "key": "EQ1"}, "why": None,
+         "labor": 3899.0, "material": 538.6, "expense": 912.8,
+         "text": ["굴착기 노무비 : 55,700 * 0.07 = 3,899.0", "굴착기 재료비 : 7,695 * 0.07 = 538.6",
+                  "굴착기 경비 : 13,041 * 0.07 = 912.8"]},
+    ],
+    "labor": 6878, "material": 538, "expense": 912, "sum": 8328, "why": None,
+    "foot": "계 : 노무비 6,878 + 재료비 538 + 경비 912 = 8,328",
+}  # fmt: skip
+
+
+def test_155_5_단가산출근거_엑셀_꼴_칸():
+    out = _node(
+        f"\nconst t = buildSg({{ sheets: {{ sg: [{json.dumps(SG, ensure_ascii=False)}] }} }});"
+        "\nconsole.log(JSON.stringify({ rows: t.rows, cols: t.columns.map((c) => c.key),"
+        " cls: t.rows.map((_, i) => t.rowClass(i) ?? null) }));",
+        "UI_Tabs_Sangeun",
+    )
+    assert out["cols"] == ["kind", "text", "sum", "labor", "material", "expense", "note"]
+    rows = out["rows"]
+    assert [(r.get("kind"), r["text"]) for r in rows] == [
+        ("제 1 호표", "뒷채움 / m3"),
+        (None, "  산림품셈 13-3-2 적용"),
+        (None, "  규격 : 150 mm"),
+        ("노무", "  보통인부 : 165,545 * 0.018 = 2,979.8"),
+        ("중기", "  굴착기 노무비 : 55,700 * 0.07 = 3,899.0"),
+        ("", "  굴착기 재료비 : 7,695 * 0.07 = 538.6"),
+        ("", "  굴착기 경비 : 13,041 * 0.07 = 912.8"),
+        ("총  계", "계 : 노무비 6,878 + 재료비 538 + 경비 912 = 8,328"),
+    ]
+    assert [r.get("sum") for r in rows[3:7]] == [2979.8, 3899.0, 538.6, 912.8]
+    assert out["cls"] == ["is-title"] + [None] * 6 + ["is-title"]
diff --git a/resources/tester/test_ui_data_table.py b/resources/tester/test_ui_data_table.py
index 56fe2c74a..70ab16487 100644
--- a/resources/tester/test_ui_data_table.py
+++ b/resources/tester/test_ui_data_table.py
@@ -101,3 +101,24 @@ def test_줄_누름_옵션일_때만_data_i(r):
     assert '<tr class="is-alt is-clickable" data-i="1">' in pick
     assert pick.count("data-i=") == 2
     assert "data-i" not in r["opts"] and "is-clickable" not in r["foot"]
+
+
+def test_155_1_글자_14px_열_폭_같은_비율(r):
+    # 155-1 — 표 글 12 → 14px · 열 폭(12px 글 기준 값)에 14/12 를 곱함 · 줄 높이 28px
+    assert abs(r["scale"] - 14 / 12) < 1e-9
+    w = r["widths"]
+    assert '<col style="width:112px"><col style="width:98px"><col style="width:140px">' in w
+    assert 'style="width:350px"' in w  # 표 폭 = 112 + 98 + 140
+    assert 'class="is-frozen is-edge" style="left:112px"' in w  # 둘째 고정 열 left 도 같이
+    assert "font-size: var(--text-body-sm);" in r["css"]
+    assert "--dt-row-h: 28px;" in r["css"]
+
+
+def test_155_2_줄_꼴_곁값(r):
+    # 155-2 — rowClass 가 낸 class 를 본문 줄에만 · 빈 값이면 안 붙임 · 앞 빈칸을 접지 않는 서식
+    rc = r["rowClass"]
+    assert '<tr class="is-title"><td>제 1 호표</td></tr>' in rc
+    assert '<tr class="is-alt"><td>  ㄴ 석공</td></tr>' in rc
+    assert rc.count("is-title") == 1  # 합계 줄엔 안 붙음
+    assert "white-space-collapse: preserve-spaces;" in r["css"]
+    assert "tr.is-title td" in r["css"]
diff --git a/ui_template/ui_template_data_table.css b/ui_template/ui_template_data_table.css
index db528c844..af0a5e26d 100644
--- a/ui_template/ui_template_data_table.css
+++ b/ui_template/ui_template_data_table.css
@@ -4,7 +4,7 @@
  * ========================================================================== */
 
 .ui-data-table {
-  --dt-row-h: 24px;
+  --dt-row-h: 28px;
   --dt-zebra: var(--color-surface);
   --dt-hover: color-mix(in srgb, var(--color-accent) 14%, var(--color-canvas));
   --dt-head: color-mix(in srgb, var(--color-accent) 6%, var(--color-surface));
@@ -30,7 +30,7 @@
   border-collapse: separate;
   border-spacing: 0;
   color: var(--color-text-body);
-  font-size: var(--text-caption);
+  font-size: var(--text-body-sm);
   line-height: 1.3;
 }
 
@@ -52,6 +52,7 @@
   background: var(--color-canvas);
   text-overflow: ellipsis;
   white-space: nowrap;
+  white-space-collapse: preserve-spaces; /* 앞 빈칸(들여쓰기) · 겹 빈칸을 접지 않음 · 줄바꿈은 안 함 */
 }
 
 /* 숫자 — 오른쪽 맞춤 · 자리 폭 같게 */
@@ -134,6 +135,12 @@
   font-weight: var(--font-weight-bold);
 }
 
+/* 제목 줄(PLAN 155-2 · rowClass) — 굵게 */
+.ui-data-table__table tbody tr.is-title td {
+  color: var(--color-text);
+  font-weight: var(--font-weight-bold);
+}
+
 .ui-data-table__table tbody tr.is-clickable {
   cursor: pointer;
 }
diff --git a/ui_template/ui_template_data_table.ts b/ui_template/ui_template_data_table.ts
index e9c682480..f16bc7ecf 100644
--- a/ui_template/ui_template_data_table.ts
+++ b/ui_template/ui_template_data_table.ts
@@ -9,6 +9,7 @@
  *   열 = { key: "cut_soil_area", label: "단면적", group: ["절토", "토사"], kind: "number", decimals: 2 }
  *   고칠 칸(PLAN 121) = editable(줄, 열) 참인 칸만 글 상자 · 바꾸면 onEdit(줄, 열, 글) — 다시 그려도 커서 자리 지킴
  *   칸 누름(PLAN 144) = onCellClick(줄, 열) · 줄로 이동 = t.focusRow(줄)(스크롤 + 강조)
+ *   줄 꼴(PLAN 155-2) = rowClass(줄) → 줄 class(예 is-title 굵게) · 안 주면 글 그대로
  * ========================================================================== */
 
 import "./ui_template_data_table.css";
@@ -26,7 +27,7 @@ export interface DataColumn {
   decimals?: number;
   /** 끝 0 지움(decimals 는 최대 자리) — 사용자가 넣는 값처럼 자리가 줄마다 다른 열 */
   trim?: boolean;
-  /** 열 폭 px(기본 숫자 84 · 글 96) */
+  /** 열 폭 px(12px 글 기준 · 기본 숫자 84 · 글 96) — 그릴 때 글 비 SCALE 을 곱함 */
   width?: number;
   /** 맨 아래 머리 칸 풍선 글(기본 label) */
   title?: string;
@@ -57,6 +58,8 @@ export interface DataTableOptions {
   editable?: (index: number, key: string) => boolean;
   /** 고친 칸 글(바꾼 뒤 · 커서가 옮겨 간 다음에 부름) */
   onEdit?: (index: number, key: string, text: string) => void;
+  /** 줄 꼴 class(본문 줄만 · 예 `is-title` = 굵게) — 빈 값이면 안 붙임 */
+  rowClass?: (index: number) => string | null | undefined;
 }
 
 export interface DataTable {
@@ -70,8 +73,11 @@ const EMPTY = "-";
 const ESC: Record<string, string> = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
 const esc = (s: string): string => s.replace(/[&<>"]/g, (c) => ESC[c]);
 
+/** 글 크기 비(14px ÷ 12px) — 페이지가 준 열 폭(12px 글 기준)을 같은 비율로 넓힘 */
+export const SCALE = 14 / 12;
+
 function colWidth(c: DataColumn): number {
-  return c.width ?? (c.kind === "number" ? 84 : 96);
+  return Math.round((c.width ?? (c.kind === "number" ? 84 : 96)) * SCALE);
 }
 
 /** 값 한 칸 → [보일 글, 빈 값인지] */
@@ -132,6 +138,7 @@ function rowHtml(
   edit: number | null = null,
   editable?: (index: number, key: string) => boolean,
   focus = false,
+  extra: string | null | undefined = null,
 ): string {
   let tr = "";
   for (let j = 0; j < cols.length; j++) {
@@ -154,11 +161,13 @@ function rowHtml(
       (fmts[j] ? ' data-num=""' : "");
     tr += `<td${attrs}>${esc(txt)}</td>`;
   }
-  const cls = [alt && "is-alt", index !== null && "is-clickable", focus && "is-focus"]
+  const cls = [alt && "is-alt", index !== null && "is-clickable", focus && "is-focus", extra]
     .filter(Boolean)
     .join(" ");
   const data = index !== null ? ` data-i="${index}"` : "";
-  return cls || data ? `<tr${cls ? ` class="${cls}"` : ""}${data}>${tr}</tr>` : `<tr>${tr}</tr>`;
+  return cls || data
+    ? `<tr${cls ? ` class="${esc(cls)}"` : ""}${data}>${tr}</tr>`
+    : `<tr>${tr}</tr>`;
 }
 
 /** 그릴 줄 구간 — 밖의 줄은 빈 줄 높이(rowH px)로만 채움 */
@@ -208,6 +217,7 @@ export function renderDataTableHtml(o: DataTableOptions, win?: RowWindow): strin
       i,
       o.editable,
       o.focus === i,
+      o.rowClass?.(i),
     );
   if (win) body += pad((n - to) * win.rowH, cols.length);
   const foot = o.total ? `<tfoot>${rowHtml(cols, fmts, left, o.total, false, blank)}</tfoot>` : "";
@@ -226,7 +236,7 @@ export function createDataTable(opts: DataTableOptions): DataTable {
   root.className = "ui-data-table";
   root.tabIndex = 0; // 키보드로 표 안 스크롤
   const state = { ...opts };
-  let win: RowWindow = { from: -1, to: -1, rowH: 24 }; // --dt-row-h · 그린 뒤 재서 고침
+  let win: RowWindow = { from: -1, to: -1, rowH: 28 }; // --dt-row-h · 그린 뒤 재서 고침
   // 보이는 줄 근처만 그림 — 줄 1,000개를 다 배치하면 수백 ms
   const draw = (force: boolean) => {
     const n = state.rows.length;