test(813-2b): 옵션 표본 하한 18700 → 18400

작업량당 기계경비 6 문서 지움으로 옵션 표본 18,716 → 18,438 · 낡은 하한 낮춤 · 파일 전체 9 통과

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

A00_Common/line_stack_rows.ts

@@ -30,6 +30,7 @@ import {
   newVar,
   setRow,
   shapeOf,
+  sourceOf,
   unfold,
   type StackItem,
   type StackLine,
@@ -254,7 +255,9 @@ export function buildBlock(
       const was = h.before?.get(id);
       const freed = !iffy && raw !== undefined && !!was && hasIf(tryParse(was) ?? ["num", 0, "0"]);
       const sub = link?.갈래 === "단가산출" && link.키 ? h.subDoc(link.키) : null;
-      const tag = expr ? null : sourceTag(h, id, link);
+      const src = v ? sourceOf(h.doc, v) : null; // 가져온 값(812-3) = 옵션 가로 칸과 같은 값 · 꼬리표만
+      const srcTag = src === "원파일" ? lt("Src_Native") : src === "엑셀" ? lt("Src_Excel") : src;
+      const tag = expr ? null : srcTag ? clipTag(srcTag) : sourceTag(h, id, link);
       const tools: HTMLElement[] = [];
       if (sub?.결과 && link?.키)
         tools.push(

A00_Common/line_stack_sourced.ts

@@ -51,7 +51,7 @@ export function buildSourced(
       const n = Number(f.input.value.trim().replace(/,/g, ""));
       if (f.input.value.trim() === "" || !Number.isFinite(n))
         return void (f.input.value = String(v.연결?.값 ?? "")); // 수만 — 빈 값 · 글 = 그대로
-      set(id, v, String(n));
+      set(id, v, n); // 수 그대로(글 「0.7」 = 셈 「—」 · 공식 묶음 값 칸 `setRow` 와 같은 꼴 · 812-3)
     });
     f.root.dataset.option = id;
     const tagText = tag === "원파일" ? lt("Src_Native") : tag === "엑셀" ? lt("Src_Excel") : tag;
@@ -64,7 +64,7 @@ export function buildSourced(
     if (guess) f.root.dataset.guess = mark;
     return guess
       ? cell(f.root, lt("Guess"), "warning", lt("Guess_Hint"))
-      : cell(f.root, lt("Src_Native"), "info", lt("Src_Hint"));
+      : cell(f.root, lt(head.원파일 ? "Src_Native" : "Src_Excel"), "info", lt("Src_Hint")); // 812-1 엑셀 읽기기 = 「엑셀」
   };
   if (head.규격) out.push(ro(lt("Spec"), head.규격, "", false));
   for (const g of head.추정 ?? [])

A00_Common/line_stack_text.ts

@@ -14,7 +14,7 @@ const TEXT = {
   Add_Item: ["+ 그룹", "+ Group"],
   Add_Line: ["줄 더함", "Add line"],
   Add_율: ["율 — 그룹 소계의 %", "Rate — % of subtotal"],
-  Add_식: ["식 — 공식 틀", "Formula"],
+  Add_식: ["식", "Formula"],
   Del_Item: ["그룹 지움", "Delete group"],
   Del: ["지움", "Delete"],
   Item: ["그룹", "Group"],

M01_MasterData/M01_MasterData_Parts.py

@@ -0,0 +1,89 @@
+"""부품 문서(PLAN 813-2 · 요구 722-3 · 724~735) — 수식 문서 머리 칸 `부품` 읽기.
+
+갈래 = 기계경비식(기계 시간당 경비 셈 방식) · 작업량 틀(`기종` = 기계표 상세구분 목록 ·
+`규격` = 고른 기계 규격 수를 받는 변수 열쇠) · 계수식(기계 무관 · 돈 아닌 식).
+틀 = `_수식문서_틀.md` 9 장.
+- 단가산출 기초 목록 · 찾아 넣기 「다른 단가산출」 목록에서 뺌(`strip`) — 키로 열기 · 셈 · 부르기는 그대로
+- 기종 → 그 기종 기계가 쓰는 기계경비식 · 작업량 틀(`of_kind` · M01 「기계」 화면)
+- 기계 원문번호 → 그 기종 작업량 틀 문서(`of_machine` · 줄 쌓기 기계 넣기)
+쓰기 없음 · 로그인 사용자 모두(마스터 읽기).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from M01_MasterData import M01_MasterData_Doc as doc_store
+from M01_MasterData import M01_MasterData_Store as store
+
+KINDS = ("기계경비식", "작업량 틀", "계수식")
+
+
+def parts() -> dict[str, dict]:
+    """{문서 키: 부품 표지}."""
+    return {k: d["부품"] for k, d in doc_store.docs().items() if isinstance(d.get("부품"), dict)}
+
+
+def strip(rows: list[dict]) -> list[dict]:
+    """목록에서 부품 문서를 뺌."""
+    have = parts()
+    return [r for r in rows if str(r.get("키")) not in have]
+
+
+def _brief(key: str, d: dict) -> dict[str, Any]:
+    tag = d.get("부품") or {}
+    return {
+        "키": key,
+        "이름": d.get("이름") or "",
+        "결과단위": d.get("결과단위") or "",
+        "갈래": tag.get("갈래") or "",
+        "규격": tag.get("규격") or "",
+    }
+
+
+def _machines() -> list[dict]:
+    files = store.loaded()[0]
+    return list((files.get("기계.json") or {}).get("줄") or [])
+
+
+def _templates(kind: str) -> list[tuple[str, dict]]:
+    return [
+        (k, d)
+        for k, d in doc_store.docs().items()
+        if (d.get("부품") or {}).get("갈래") == "작업량 틀" and kind in d["부품"].get("기종", [])
+    ]
+
+
+def of_kind(group: str, detail: str = "") -> dict[str, list]:
+    """M01 화면 — 계수식 = 그 넷 · 기계 = 상세구분 `detail` 기계가 쓰는 기계경비식(기계 수)
+    + 작업량 틀."""
+    docs = doc_store.docs()
+    if group == "계수식":
+        return {
+            "계수식": [
+                _brief(k, d) for k, d in docs.items() if parts().get(k, {}).get("갈래") == "계수식"
+            ]
+        }
+    from M02_MasterTemplete import M02_Machine_Hourly as hourly  # M02 가 M01 을 부름 — 늦게
+
+    used: dict[str, int] = {}
+    for m in _machines():
+        if m.get("상세구분") != detail:
+            continue
+        got = hourly.logic_of(str(m.get("원문번호") or ""))
+        if got:
+            used[str(got["키"])] = used.get(str(got["키"]), 0) + 1
+    rule = [{**_brief(k, docs[k]), "기계수": n} for k, n in used.items() if k in docs]
+    return {"기계경비식": rule, "작업량 틀": [_brief(k, d) for k, d in _templates(detail)]}
+
+
+def of_machine(no: str) -> dict[str, Any]:
+    """줄 쌓기 기계 넣기 — 기계 원문번호 → {기계 {이름 · 규격 · 상세구분}, 틀 [{… 문서}]}."""
+    row = next((m for m in _machines() if str(m.get("원문번호")) == str(no)), None)
+    if not row:
+        raise store.StoreError(404, f"없는 기계 「{no}」")
+    kind = str(row.get("상세구분") or "")
+    return {
+        "기계": {"이름": row.get("이름"), "규격": row.get("규격") or "", "상세구분": kind},
+        "틀": [{**_brief(k, d), "문서": d} for k, d in _templates(kind)],
+    }

M01_MasterData/M01_MasterData_Router.py

@@ -14,6 +14,7 @@ from pydantic import BaseModel
 
 from M01_MasterData import M01_MasterData_Doc as doc_screen
 from M01_MasterData import M01_MasterData_Equation as equation
+from M01_MasterData import M01_MasterData_Parts as parts
 from M01_MasterData import M01_MasterData_Sheet as line_sheet
 from M01_MasterData import M01_MasterData_Store as store
 from M01_MasterData import M01_MasterData_Store_Combo as combo_store
@@ -205,7 +206,14 @@ def get_logics(
     sub: str = "", detail: str = "", q: str = "", blocked: int | None = None, owner: str = ""
 ) -> dict:
     """줄마다 덧칸(묶음 · 작업량 · 부르는/불리는 수 · 관련 · 713-3) — 읽기만."""
-    return {"logics": store_list.attach(_call(store.logics, sub, detail, q, blocked, owner))}
+    rows = parts.strip(_call(store.logics, sub, detail, q, blocked, owner))  # 부품 문서 뺌(813-2)
+    return {"logics": store_list.attach(rows)}
+
+
+@router.get("/parts")
+def get_parts(group: str, detail: str = "") -> dict:
+    """부품 문서(813-2) — 계수식 · 기계 상세구분의 기계경비식 · 작업량 틀."""
+    return _call(parts.of_kind, group, detail)
 
 
 @router.get("/logic")

M01_MasterData/M01_MasterData_UI_LogicLab.ts

@@ -571,7 +571,13 @@ export async function mountM01LogicLab(
   showLoadingOverlay();
   const openKeyOn = async (key: string): Promise<void> => {
     if (!(await leave())) return;
-    const found = allLogics.find((x) => x.키 === key);
+    // 목록에 없는 부품 문서(813-2) = 키로 읽어 엶
+    const found =
+      allLogics.find((x) => x.키 === key) ??
+      (await fetchLogic(key).then(
+        (o) => o.logic as unknown as { 구분: string; 키: string },
+        () => null,
+      ));
     if (found) await open(logicId(found.구분, found.키), found.구분, found.키);
     else showToast(tx("Load_Failed"), "error");
   };

M01_MasterData/M01_MasterData_UI_LogicLab_Side.css

@@ -18,9 +18,7 @@
 .m01lab-src__title {
   flex: 1;
   min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  overflow-wrap: anywhere; /* 제목 한 줄이 길면 접음 */
 }
 
 .m01lab-src__body {
@@ -40,6 +38,11 @@
   line-height: 1.6;
 }
 
+/* [주] 글 — 본문(--text-body)보다 한 단 작게 */
+.m01lab-src__note {
+  font-size: var(--text-body-sm);
+}
+
 .m01lab-src__file {
   margin: 0;
   font-size: var(--text-body-sm);
@@ -56,6 +59,11 @@
   white-space: pre;
 }
 
+/* 표 머리 · 칸 = 본문과 같은 16 — 좁으면 둘레 칸(m01-logic__scroll)이 가로로 굴림 */
+.m01lab-src .m01lab-src__table :is(td, th) {
+  font-size: var(--text-body);
+}
+
 /* 출처가 가리킨 항 · 주 — 옅은 바탕 + 왼쪽 막대 */
 .m01lab-src__hit {
   background: color-mix(in srgb, var(--color-accent) 14%, transparent);

M01_MasterData/M01_MasterData_UI_LogicLab_Source.ts

@@ -38,6 +38,9 @@ interface Found {
   item?: string;
 }
 
+/** 절 제목 블록의 글만 「번호 이름」 꼴로 */
+const headFixed = (b: Block): Block => (b.h ? { ...b, text: headText(b.text ?? "") } : b);
+
 function blockNode(b: Block): HTMLElement {
   const node = rawNode(b);
   if (b.hit) node.classList.add("m01lab-src__hit");
@@ -65,6 +68,27 @@ function rawNode(b: Block): HTMLElement {
   return el("p", { className: "m01lab-src__p", text: b.p ?? "" });
 }
 
+/** 출처 글에서 첫 번호 앞까지 = 책 · 부문(예 「건설품셈 공통」) — 제목 한 줄의 앞 */
+const prefixOf = (src: string): string => {
+  const at = src.search(/\d+(?:-\d+)+/);
+  return (at < 0 ? src : src.slice(0, at)).trim();
+};
+
+/** 절 제목 줄 「9-7-1. 이름」 → 「9-7-1 이름」 */
+const headText = (t: string): string => t.replace(/^(\d+(?:-\d+)*)\.\s*/, "$1 ");
+
+/** 「[주]」 줄부터 다음 제목 앞까지 글 줄 = 한 단 작은 글자(`m01lab-src__note`) */
+function noteMarked(blocks: Block[]): HTMLElement[] {
+  let inNote = false;
+  return blocks.map((b) => {
+    if (b.h) inNote = false;
+    else if (b.p?.trim().startsWith("[주]")) inNote = true;
+    const node = blockNode(b);
+    if (inNote && b.p !== undefined) node.classList.add("m01lab-src__note");
+    return node;
+  });
+}
+
 export interface SourceView {
   root: HTMLElement;
   /** 그 출처 글의 원문을 그림 — 지금 보이는 것과 같으면 안 부름 */
@@ -121,20 +145,28 @@ export function createSourceView(opts: SourceViewOptions = {}): SourceView {
       .then(({ found }) => {
         if (shown !== src) return;
         if (!found.length) return none();
+        // 제목 한 줄 = 「책 부문 + 절 번호 · 이름(개정 꼬리)」 — 절 하나면 원문 제목 줄을 숨김 · 여럿이면 절마다 번호 · 이름 줄 둠
+        const lone = found.length === 1 && found[0].blocks[0]?.h ? found[0] : null;
+        if (found.length > 1 || lone) {
+          const pre = prefixOf(src);
+          title.textContent = lone ? `${pre} ${headText(lone.blocks[0].text ?? "")}`.trim() : pre;
+        }
         body.replaceChildren(
-          ...found.flatMap((f) => [
-            el("p", {
-              className: "ui-text ui-text--muted m01lab-src__file",
-              text: [
-                f.file,
-                f.matched === f.number ? "" : ts("Near", f.number),
-                f.item ? (/^\d+$/.test(f.item) ? `${f.item}항` : f.item) : "",
-              ]
-                .filter(Boolean)
-                .join(" · "),
-            }),
-            ...f.blocks.map(blockNode),
-          ]),
+          ...found.flatMap((f) => {
+            // 파일 경로는 안 보임 — 가까운 절 · 항 안내만
+            const note = [
+              f.matched === f.number ? "" : ts("Near", f.number),
+              f.item ? (/^\d+$/.test(f.item) ? `${f.item}항` : f.item) : "",
+            ]
+              .filter(Boolean)
+              .join(" · ");
+            return [
+              ...(note
+                ? [el("p", { className: "ui-text ui-text--muted m01lab-src__file", text: note })]
+                : []),
+              ...noteMarked(f === lone ? f.blocks.slice(1) : f.blocks.map(headFixed)),
+            ];
+          }),
         );
         // 강조 항을 패널 몸 가운데로 — 몸만 굴림(85-5 · scrollIntoView 는 메인 창까지 굴림)
         requestAnimationFrame(() => {

M01_MasterData/M01_MasterData_UI_LogicLab_SourceFind.ts

@@ -77,7 +77,7 @@ export function createSourceFind(opts: {
         unit: x.결과단위 ?? "",
         onPick: () => {
           find.setRows([]);
-          find.hint.textContent = `${x.원문번호 || x.키} ${x.이름}`;
+          find.hint.textContent = ""; // 고른 기초 이름은 원문 제목 한 줄이 보임
           opts.onPick(x);
         },
       })),

M01_MasterData/M01_MasterData_UI_Page.ts

@@ -48,6 +48,7 @@ import {
 } from "./M01_MasterData_UI_Side";
 import { loadTable } from "./M01_MasterData_UI_Logic_Note";
 import { tl } from "./M01_MasterData_UI_LogicLab_Text";
+import { renderParts } from "./M01_MasterData_UI_Parts";
 import { renderTables } from "./M01_MasterData_UI_Tables";
 import type { LogicHandle } from "./M01_MasterData_UI_LogicLab";
 import "./M01_MasterData_UI_Style.css";
@@ -84,6 +85,7 @@ function buildPage(): HTMLElement {
     attrs: { hidden: "" },
   });
   const body = el("div", { className: "m01-master__body" });
+  const partsHost = el("div"); // 기계 · 계수 표 아래 부품 문서(813-2)
   // 제목 줄 · 찾기 줄 = 「단가산출 로직」 화면과 같은 공용 조각
   const headBar = buildHeadBar({ title, status: [summary], buttons: [drop, save] });
   const head = el("div", {
@@ -99,6 +101,7 @@ function buildPage(): HTMLElement {
       notice,
       el("p", { className: "m01-master__hint", text: L("M01_WideHint") }),
       body,
+      partsHost,
     ],
   });
 
@@ -173,6 +176,7 @@ function buildPage(): HTMLElement {
       : pick.group === "요율"
         ? renderRateRows(body, pick, query)
         : renderRows(body, pick, query);
+    renderParts(partsHost, pick, (key) => openLogicTab(key));
     showNotice(isStale(pick.file.file, pick.file.version) ? [L("M01_FileStale")] : []);
   };
 

M01_MasterData/M01_MasterData_UI_Parts.ts

@@ -0,0 +1,105 @@
+/* =============================================================================
+ * M01_MasterData_UI_Parts.ts
+ * M01 「기계」 · 「계수」 표 아래 부품 문서(PLAN 813-2 · 요구 722-3 · 724~732) — 단가산출 기초 목록에서 뺀 보조 문서 자리
+ *   기계 · 상세구분(기종) 고름 = 「시간당 기계경비 계산식」(그 기종 기계가 쓰는 방식 · 기계 수) · 「작업량 공식 틀」(그 기종 틀)
+ *   계수 = 「계수식」(기계 무관 · 돈 아닌 식 넷)
+ *   이름 누름 = 줄 쌓기 읽기 창(`createStackScreen` · 고침 없음) · [단가산출 기초에서 열기] = 지금 수식 탭 그대로 고침
+ *   서버 = `GET /api/m01/parts?group&detail`(`M01_MasterData_Parts.of_kind`)
+ * ========================================================================== */
+
+import { API_BASE_URL } from "@config/config_frontend";
+import { createButton } from "@ui/ui_template_button";
+import { el } from "@ui/ui_template_elements";
+import { openModal } from "@ui/ui_template_modal";
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+import { createText } from "@ui/ui_template_text";
+import { createStackScreen } from "../A00_Common/line_stack_screen";
+import type { Pick } from "./M01_MasterData_UI_Side";
+
+interface Part {
+  키: string;
+  이름: string;
+  결과단위: string;
+  기계수?: number;
+}
+type Parts = Partial<Record<"기계경비식" | "작업량 틀" | "계수식", Part[]>>;
+
+const T = {
+  기계경비식: ["시간당 기계경비 계산식", "Hourly machine cost formula"],
+  "작업량 틀": ["작업량 공식 틀", "Output formula templates"],
+  계수식: ["계수식", "Coefficient formulas"],
+  Open: ["단가산출 기초에서 열기", "Open in unit price basis"],
+  Machines: ["기계", "machines"],
+  None: ["없음", "None"],
+  Close: ["닫기", "Close"],
+} as const;
+const tx = (k: keyof typeof T): string => T[k][currentLanguageIndex === 1 ? 1 : 0];
+const KINDS = ["기계경비식", "작업량 틀", "계수식"] as const;
+
+/** 표 아래 부품 칸 — 기계(상세구분 있음) · 계수만 · 그 밖 = 비움 */
+export function renderParts(host: HTMLElement, pick: Pick, openLogic: (key: string) => void): void {
+  host.replaceChildren();
+  const group = pick.group === "계수" ? "계수식" : pick.group === "기계" ? "기계" : "";
+  if (!group || (group === "기계" && !pick.detail)) return;
+  let stack: ReturnType<typeof createStackScreen> | null = null;
+  /** 줄 쌓기 읽기 창 — 고침 없음 · [단가산출 기초에서 열기] = 수식 탭에서 고침 */
+  const show = (p: Part): void => {
+    stack ??= createStackScreen({ base: "/m01/logic/doc", admin: false, cache: "m01_parts_view" });
+    const view = stack;
+    openModal({
+      title: `${p.키} · ${p.이름}`,
+      closeLabel: tx("Close"),
+      width: "1100px",
+      wide: true,
+      mount: (body, close, actions) => {
+        actions.append(
+          createButton({
+            label: tx("Open"),
+            variant: "ghost",
+            size: 28,
+            onClick: () => {
+              close();
+              openLogic(p.키);
+            },
+          }),
+        );
+        body.append(view.root);
+        view.draw(p.키, true);
+      },
+    });
+  };
+  const q = new URLSearchParams({ group, detail: pick.detail ?? "" });
+  const mine = (host.dataset.partsAsk = q.toString()); // 늦게 온 옛 답은 버림
+  void fetch(`${API_BASE_URL}/m01/parts?${q}`, { credentials: "include" })
+    .then((r): Promise<Parts> | Parts => (r.ok ? (r.json() as Promise<Parts>) : {}))
+    .catch((): Parts => ({}))
+    .then((got) => {
+      if (host.dataset.partsAsk !== mine) return;
+      const blocks = KINDS.filter((k) => k in got).map((k) => {
+        const list = got[k] ?? [];
+        const items = list.map((p) => {
+          const b = createButton({
+            label: `${p.이름}${p.기계수 ? ` · ${tx("Machines")} ${p.기계수}` : ""}`,
+            variant: "ghost",
+            tone: "link",
+            size: 28,
+            onClick: () => show(p),
+          });
+          b.dataset.part = p.키;
+          return b;
+        });
+        return el("section", {
+          className: "m01-parts__block",
+          attrs: { "data-parts": k },
+          children: [
+            el("h3", { className: "m01-parts__title", text: tx(k) }),
+            items.length
+              ? el("div", { className: "m01-parts__list", children: items })
+              : createText(tx("None")),
+          ],
+        });
+      });
+      if (blocks.length)
+        host.replaceChildren(el("div", { className: "m01-parts", children: blocks }));
+    });
+}

M01_MasterData/M01_MasterData_UI_Style.css

@@ -170,3 +170,21 @@ table.m01-master__grid {
   gap: var(--spacing-8);
   padding: var(--spacing-4) var(--spacing-8);
 }
+
+/* 부품 문서(813-2) — 기계 · 계수 표 아래 */
+.m01-parts {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-12);
+  margin-top: var(--spacing-16);
+}
+.m01-parts__title {
+  margin: 0 0 var(--spacing-4);
+  font-size: var(--text-body);
+  color: var(--color-text);
+}
+.m01-parts__list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-4);
+}

M02_MasterTemplete/M02_Doc_FromNative.py

@@ -52,7 +52,10 @@ def pack(got: dict, name: str) -> dict[str, Any]:
     out: dict[str, Any] = {"꼴": got["꼴"], "파일": name, "표지": got.get("표지") or []}
     out |= {"엑셀": True} if got.get("엑셀") else {}  # 812-1 엑셀 읽기기(`M02_San_Xlsx`) — 같은 꼴
     head = ("코드", "번", "이름", "규격", "단위", "저장")
-    if got.get("엑셀"):  # 엑셀 읽기기 — 줄 행 = 시트 행(원문 카드 · 옛 엑셀 길과 같은 자리)
+    if got.get(
+        "엑셀"
+    ):  # 엑셀 읽기기 — 줄 행 = 시트 행(원문 카드 · 옛 엑셀 길과 같은 자리) · 블록 표지
+        head += ("표지", "몸", "꼬리")
         got = {**got, "산근": [_rows(b) for b in got["산근"]]}
     if got["꼴"] == "EST":
         out["산근"] = [
@@ -106,27 +109,29 @@ def emit(saved: dict, no: int, keys: bool = True) -> dict[str, Any]:
         names = {b["코드"]: n for n, b in numbers(saved).items()}
         out = ne.block(blk, int(no), keys, saved["파일"], names)
         out["원본"] |= {"원코드": blk["코드"]} | ({"규격": blk["규격"]} if blk.get("규격") else {})
-        return _excel(saved, out)
+        return _excel(saved, out, blk)
     from M02_MasterTemplete import M02_San_Stmate as stm
 
     nodes = [{"행": ln["행"], "글": ln["글"], **stm.parse_line(ln["글"])} for ln in blk["줄"]]
     saved_amt = blk.get("저장") or {}
     head = {"C": saved_amt.get("T"), "D": saved_amt.get("L"), "E": saved_amt.get("M")}
     head["F"] = saved_amt.get("S")
-    block = {"코드": blk["코드"], "이름": blk.get("이름"), "몸": [], "꼬리": [], "머리": head}
+    block = {"코드": blk["코드"], "이름": blk.get("이름"), "머리": head}
+    block |= {"몸": blk.get("몸") or [], "꼬리": blk.get("꼬리") or []}  # 엑셀 = 줄 금액 · 계 꼬리
     out = em.stmate(block, nodes, saved["단가"], saved["끝전"], keys, saved["파일"])
     marks = sum(1 for one in out["원본"]["글줄"] if one.get("표지"))
     sure = len(out["로직"]["호표"]) + len(out["로직"].get("덧줄") or []) + len(out["로직"]["중간"])
     out["원본"] |= {"원파일": True, "갈래": "STmate", "확정": {"확정": sure, "표지": marks}}
-    return _excel(saved, out)
+    return _excel(saved, out, blk)
 
 
-def _excel(saved: dict, out: dict) -> dict[str, Any]:
+def _excel(saved: dict, out: dict, blk: dict) -> dict[str, Any]:
     """엑셀 읽기기 꼴(812-1) — 원본 `원파일` 거짓 · `엑셀` 참(화면 꼬리표 「엑셀」 · 원코드 = 단산 번)."""
     if saved.get("엑셀"):
         out["원본"] |= {"원파일": False, "엑셀": True}
         out["원본"] |= {"시트": "단가산출"} if saved["꼴"] == "EST" else {}
         out["원본"].pop("원코드", None)
+        out["원본"]["표지"] += [m for m in blk.get("표지") or [] if m.startswith("참고 · ")]
     return out
 
 

M02_MasterTemplete/M02_Doc_Import_Shape.py

@@ -161,7 +161,10 @@ def machines(doc: dict, title: dict[str, str]) -> None:
 
 def shape(doc: dict, meta: dict) -> dict:
     """derive 문서 다듬기 — 원본 글줄 · 엔진 줄 자원 이름."""
+    from M02_MasterTemplete import M02_Doc_NativeLayout as lay
+
     src = meta.get("원본") or {}
+    lay.tag(doc, meta)  # 812-3 원파일 차림 — 금액 줄 ↔ 로직 줄(끝에 `apply`)
     names(doc, list(src.get("글줄") or []))
     title = {}
     for item in (meta.get("로직") or {}).get("호표") or []:
@@ -169,4 +172,5 @@ def shape(doc: dict, meta: dict) -> dict:
         if res.get("갈래") == "기계" and res.get("이름"):
             title[str(item.get("이름"))] = " ".join(x for x in (res["이름"], res.get("규격")) if x)
     machines(doc, title)
+    lay.apply(doc, meta)
     return doc

M02_MasterTemplete/M02_Doc_Match.py

@@ -7,9 +7,10 @@
     ② 옵션 풀이 = 그 문서의 선택 · 입력 변수 값을 줄마다 좁힘(줄 수량 · 단가가 의존하는 변수만 돌림 ·
        값이 가져온 줄 수량 · 단가 묶음에 있거나 0(꺼진 줄)인 값만 남김) → 남은 조합(상한 `CAP_ALL`)을
        문서 셈 · 입력 변수 후보 = 기본값 · 0 · 가져온 식에 나온 수 · 선택은 가져온 글에 든 값부터.
-    ③ 판정 = 줄 대조(수량 · 단가 · 비목 금액 · 율 줄) + 노 · 재 · 경 · 계 —
+    ③ 판정 = 줄 대조 = 로직(812-2 · 요구 712 — `M02_Doc_Match_Note`): 다른 항 = 자원 · 기계 규격 · 수량 ·
+       비목 · 율 구조(대상 · 비목) · 줄 없음 · 이름 · 참고 = 단가 · 끝수 · 율 값 %(값 — 확정을 안 막음) —
        다른 항 0 = 「확정」 · 같은 줄이 하나 넘고 핵심 줄 반 넘게 짝 = 「근접」(다른 항 목록) · 그 밖 「없음」.
-결과 `{판정, 키, 이름, 옵션, 다른, 금액 {가져온, 우리}, 후보수}` = 가져온 식 원본 `연결후보`.
+결과 `{판정, 키, 이름, 옵션, 다른, 참고, 금액 {가져온, 우리}, 후보수}` = 가져온 식 원본 `연결후보`.
 """
 
 from __future__ import annotations
@@ -22,6 +23,7 @@ from decimal import Decimal, InvalidOperation
 from typing import Any
 
 from M02_MasterTemplete import M02_Doc_Copy as dc
+from M02_MasterTemplete import M02_Doc_Match_Note as note
 
 md, mc, ml = dc.md, dc.mc, dc.ml
 if not hasattr(
@@ -133,6 +135,7 @@ def facts(doc: dict, got: dict) -> list[dict]:
                 "합밖": bool(row.get("합밖")),
             }
         )
+    note.rates(doc, got, out)
     return out
 
 
@@ -405,7 +408,7 @@ def _ratio(a: Any, b: Any) -> str | None:
 
 
 def compare(mine: list[dict], ours: list[dict]) -> dict[str, Any]:
-    """가져온 줄(mine) ↔ M01 줄(ours) → {같음, 짝, 핵심, 다른 [{항, 글}]}."""
+    """가져온 줄(mine) ↔ M01 줄(ours) → {같음(로직 같은 줄), 짝, 핵심, 다른 [{항, 글}], 참고 [{항, 글}]}."""
     left, right = list(mine), list(ours)
     same = paired = 0
     diffs: list[dict] = []
@@ -426,22 +429,29 @@ def compare(mine: list[dict], ours: list[dict]) -> dict[str, Any]:
     def cls(a: dict, b: dict) -> bool:
         return a["갈래"] == b["갈래"] or {a["갈래"], b["갈래"]} <= {"기계", "산출"}
 
+    notes: list[dict] = []
     exact = take(
         lambda a, b: (
-            a["수량"] == b["수량"] and a["단가"] == b["단가"] and a["비목"] == b["비목"]
-            if core(a, b)
-            else a["갈래"] == b["갈래"] == "율" and a["비목"] == b["비목"]
+            core(a, b)
+            and a["수량"] == b["수량"]
+            and a["단가"] == b["단가"]
+            and a["비목"] == b["비목"]
+            and (a["코드"] == b["코드"] or not (a["코드"] and b["코드"]))  # 코드 다름 = 짝 대조
         )
     )
-    same += sum(1 for a, _ in exact if a["갈래"] != "율")
-    for a, b in take(lambda a, b: core(a, b) and cls(a, b) and a["수량"] == b["수량"]):
-        paired += 1
-        if a["갈래"] == "기계" and b["갈래"] == "기계" and a["코드"] != b["코드"]:
-            diffs.append({"항": "기계 규격", "글": f"{a['이름']} {a['코드']} ↔ {b['코드']}"})
-        elif a["단가"] != b["단가"]:
-            diffs.append({"항": "단가 차이", "글": f"{a['이름']} 단가 {a['단가']} ↔ {b['단가']}"})
-        else:
-            diffs.append({"항": "비목", "글": f"{a['이름']} 비목 다름"})
+    same += len(exact)
+
+    def twin(a: dict, b: dict) -> bool:
+        return core(a, b) and cls(a, b) and a["수량"] == b["수량"]
+
+    for a, b in take(lambda a, b: twin(a, b) and not note.pair(a, b)[0]):  # 로직 같은 짝 먼저
+        same += 1
+        notes += note.pair(a, b)[1]
+    for a, b in take(twin):
+        bad, ref = note.pair(a, b)
+        same, paired = (same + 1, paired) if not bad else (same, paired + 1)
+        diffs += bad
+        notes += ref
     for a, b in take(lambda a, b: core(a, b) and cls(a, b) and a["단가"] == b["단가"]):
         paired += 1
         how = _ratio(a["수량"], b["수량"])
@@ -452,10 +462,9 @@ def compare(mine: list[dict], ours: list[dict]) -> dict[str, Any]:
         diffs.append(
             {"항": "기계 규격", "글": f"{a['이름']} {a['코드']} ↔ {b['코드']} · 수량 다름"}
         )
-    for a, b in take(lambda a, b: a["갈래"] == b["갈래"] == "율" and a["금액"] == b["금액"]):
-        diffs.append({"항": "비목", "글": f"율 줄 {a['이름']} 비목 다름"})
-    for a, b in take(lambda a, b: a["갈래"] == b["갈래"] == "율"):
-        diffs.append({"항": "율 값", "글": f"{a['이름']} {a['금액']} ↔ {b['이름']} {b['금액']}"})
+    rate_diffs, rate_notes = note.rate_pairs(left, right, take)
+    diffs += rate_diffs
+    notes += rate_notes
     for side, rows in (("가져온 쪽만", left), ("우리 쪽만", right)):
         for x in rows:
             if x["갈래"] == "율":
@@ -464,7 +473,7 @@ def compare(mine: list[dict], ours: list[dict]) -> dict[str, Any]:
                 what = "줄 없음"
             diffs.append({"항": what, "글": f"{side} — {x['이름']}"})
     n_core = sum(1 for a in mine if a["갈래"] != "율")
-    return {"같음": same, "짝": same + paired, "핵심": n_core, "다른": diffs}
+    return {"같음": same, "짝": same + paired, "핵심": n_core, "다른": diffs, "참고": notes}
 
 
 def _totals(got: dict) -> dict:
@@ -473,27 +482,30 @@ def _totals(got: dict) -> dict:
 
 EXPLAINED = (
     "이름 다름",
-    "단가 차이",
+    "자원",
+    "산출 단가",
+    "율 대상",
     "단위 환산",
     "기계 규격",
     "비목",
-    "율 값",
     "율 줄",
     "공구손료 유무",
-    "끝수",
 )
 
 
 def verdict(
     mine: list[dict], ours: list[dict], got_a: dict, got_b: dict, off: list[dict] = ()
 ) -> dict:
-    """확정 = 다른 항 0(옵션 글 근거까지 맞음) · 근접 = 핵심 줄 반 넘게 짝 + (같은 줄 있음 또는
-    다른 항이 모두 까닭 있는 갈래 — 단가 · 단위 환산 · 기계 규격 · 비목 · 율) · 그 밖 없음."""
+    """확정 = 다른 항 0(옵션 글 근거까지 맞음 · 참고는 있어도 됨) · 근접 = 핵심 줄 반 넘게 짝 + (같은 줄
+    있음 또는 다른 항이 모두 까닭 있는 갈래 — 자원 · 단위 환산 · 기계 규격 · 비목 · 율) · 그 밖 없음 ·
+    끝수 = 줄 로직 · 단가 모두 같은데 합만 다름(참고)."""
     res = compare(mine, ours)
     res["다른"] = [*off, *res["다른"]]
     ta, tb = _totals(got_a), _totals(got_b)
-    if not res["다른"] and ta != tb:
-        res["다른"].append({"항": "끝수", "글": f"줄은 같고 합이 다름 {ta} ↔ {tb}"})
+    if not res["다른"] and not res["참고"] and ta != tb:
+        res["참고"].append(
+            {"항": "끝수", "글": f"줄은 같고 합이 다름 {_sum_txt(ta)} ↔ {_sum_txt(tb)}"}
+        )
     if not res["다른"] and res["같음"]:
         res["판정"] = SURE
     elif res["짝"] * 2 >= res["핵심"] + 1 and (
@@ -505,6 +517,10 @@ def verdict(
     return res
 
 
+def _sum_txt(t: dict) -> str:
+    return " · ".join(f"{k} {note.txt(v)}" for k, v in t.items() if v is not None)
+
+
 # ── 한 문서 ───────────────────────────────────────────────────────────
 def _calc(doc: dict, links: Any, given: dict) -> dict | None:
     try:
@@ -533,12 +549,26 @@ def try_doc(
         off = [_off(base, k, pick[k], ev[k]) for k in ev if k in pick and pick[k] not in ev[k]]
         off += named
         res = verdict(mine, facts(base, got), got_imp, got, off)
-        rank = (res["판정"] == SURE, -len(off), res["같음"], res["짝"], -len(res["다른"]))
+        rank = (
+            res["판정"] == SURE,
+            -len(off),
+            res["같음"],
+            res["짝"],
+            -len(res["다른"]),
+            -len(res["참고"]),
+        )
         if best is None or rank > best["순위"]:
             best = {**res, "순위": rank, "옵션": pick, "금액": _totals(got)}
-        if res["판정"] == SURE:
+        if res["판정"] == SURE and not res["참고"]:
             break
-    return best or {"판정": NONE, "같음": 0, "짝": 0, "다른": [], "순위": (False, -9, 0, 0, 0)}
+    return best or {
+        "판정": NONE,
+        "같음": 0,
+        "짝": 0,
+        "다른": [],
+        "참고": [],
+        "순위": (False, -9, 0, 0, 0, 0),
+    }
 
 
 def _off(doc: dict, vid: str, value: Any, seen: set) -> dict:
@@ -549,7 +579,7 @@ def _off(doc: dict, vid: str, value: Any, seen: set) -> dict:
 
 
 def match(imported: dict, links_imp: Any, index: Index, links: Any) -> dict[str, Any]:
-    """가져온 식 문서 → 연결후보 `{판정, 키, 이름, 옵션, 다른, 금액, 후보수}`."""
+    """가져온 식 문서 → 연결후보 `{판정, 키, 이름, 옵션, 다른, 참고, 금액, 후보수}`."""
     links = links if isinstance(links, Memo) else Memo(links)
     got_imp = _calc(imported, links_imp, {})
     if got_imp is None:
@@ -561,7 +591,7 @@ def match(imported: dict, links_imp: Any, index: Index, links: Any) -> dict[str,
         res = try_doc(index.docs[key], links, imported, got_imp, mine, index.regions)
         if best is None or res["순위"] > best["순위"]:
             best, best_key = res, key
-        if res["판정"] == SURE:
+        if res["판정"] == SURE and not res["참고"]:
             break
     if best is None:
         return {"판정": NONE, "후보수": 0}
@@ -575,6 +605,7 @@ def match(imported: dict, links_imp: Any, index: Index, links: Any) -> dict[str,
         "이름": base.get("이름"),
         "옵션": _shown(base, best["옵션"]),
         "다른": best["다른"],
+        "참고": best["참고"],
         "금액": {"가져온": _plain(_totals(got_imp)), "우리": _plain(best["금액"])},
         "후보수": len(keys),
     }

M02_MasterTemplete/M02_Doc_MatchSk.py

@@ -33,7 +33,8 @@ def index() -> dm.Index:
     """M01 수식 문서 색인 — 폴더가 바뀌면(M01 관리자 고침) 다시."""
     docs = dc.folder()
     if _INDEX["문서"] is not docs:
-        _INDEX["문서"], _INDEX["색인"] = docs, dm.Index(docs)
+        aims = {k: d for k, d in docs.items() if not d.get("부품")}  # 부품 문서 = 과녁 아님(813-2)
+        _INDEX["문서"], _INDEX["색인"] = docs, dm.Index(aims)
     return _INDEX["색인"]
 
 

M02_MasterTemplete/M02_Doc_Match_Note.py

@@ -0,0 +1,228 @@
+"""연결 찾기 — 로직 차이(다른 항) 대 값 차이(참고) 가르기(PLAN 812-2 · 요구 712) — `M02_Doc_Match` 가 부름.
+
+확정을 막는 「다른 항」 = 로직 차이만 — 자원 갈래 · 기계 규격 · 노임 종류 · 자재 이름 종류 · 비목 · 산출 단가 ·
+    율 구조(있고 없음 · 대상 비목 — 율 값 % 는 참고) · 수량(옵션 풀이 뒤 · 원 단위 같아야 함).
+「참고」 = 값 차이 — 인력 · 재료 · 기계 시간당 단가 · 끝수(합만 다름) · 율 값(%) · 그로 인한 비목 금액 · 계.
+율 = 율 줄 셈값 ÷ 대상 금액 합 — 대상 = 율 식이 (거쳐서) 부르는 금액 줄 · 비목 이름이면 그 비목 몫 · 번지 합 = 핵심 줄 전부 ·
+    대상 금액 끝수 자리 차이만 지움(유효 6 자리 · 두 바탕 중 짧은 꼴) — 지어 맞추기 아님.
+"""
+
+from __future__ import annotations
+
+import re
+from decimal import Decimal, InvalidOperation
+from typing import Any
+
+from M02_MasterTemplete import M02_Doc_Copy as dc
+
+md = dc.md
+PRICED = ("노임", "재료", "기계")  # 시간당 · 단위 단가 = 값(참고)
+
+
+# ── 율 구조 ───────────────────────────────────────────────────────────
+def _names(text: Any) -> set[str]:
+    if text in (None, ""):
+        return set()
+    try:
+        return set(md.names(md.parse(text)))
+    except md.DocError:
+        return set()
+
+
+def _reach(doc: dict) -> dict[str, set[str]]:
+    """기호 → 바로 부르는 이름(변수 연결 · 식 줄 · 금액 줄 수량 · 단가)."""
+    direct: dict[str, set[str]] = {}
+    for v in doc.get("변수") or []:
+        direct[md.var_id(v)] = set(md.link_names(v.get("연결") or {}))
+    for line in doc.get("식") or []:
+        direct[str(line.get("기호"))] = _names(line.get("식"))
+    for line in doc.get("금액") or []:
+        if line.get("기호"):
+            direct[str(line["기호"])] = _names(line.get("수량")) | _names(line.get("단가"))
+    return direct
+
+
+def _close(start: set[str], direct: dict[str, set[str]]) -> set[str]:
+    seen, todo = set(start), list(start)
+    while todo:
+        for n in direct.get(todo.pop(), ()):
+            if n not in seen:
+                seen.add(n)
+                todo.append(n)
+    return seen
+
+
+def _short(r: Decimal) -> Decimal:
+    return Decimal(f"{r:.6g}").normalize()
+
+
+def rates(doc: dict, got: dict, facts: list[dict]) -> None:
+    """율 사실에 `율`(비율 · 못 셈 None) · `대상`({(자원 갈래, 비목)})을 채움(제자리)."""
+    money, rows = doc.get("금액") or [], got.get("줄") or []
+    direct = _reach(doc)
+    core = [f for f in facts if f["갈래"] != "율" and not f["합밖"]]
+    for f in facts:
+        if f["갈래"] != "율":
+            continue
+        line, row = money[f["번"]], rows[f["번"]]
+        reach = _close(_names(line.get("수량")) | _names(line.get("단가")), direct)
+        costs = reach & set(md.COSTS)
+        hits = [c for c in core if _hit(money[c["번"]], reach)]
+        if hits:  # 줄 기호 · 줄 수량 · 단가 이름 = 그 줄 금액 전부
+            parts = [(c, tuple(c["비목"])) for c in hits]
+        elif costs:  # 비목 이름(「노무비 × 4 %」) = 그 비목 몫만
+            parts = [(c, tuple(k for k in c["비목"] if k in costs)) for c in core]
+        else:  # 번지 합 · 못 찾음 = 블록 핵심 줄 전부
+            parts = [(c, tuple(c["비목"])) for c in core]
+        parts = [(c, ks) for c, ks in parts if ks]
+        f["대상"] = frozenset((_cls(c["갈래"]), k) for c, ks in parts for k in ks)
+        f["율"] = None
+        amount = _mul(row.get("수량"), row.get("단가"))
+        if amount is None:
+            continue
+        bases = [sum((_num(c["비목"][k]) for c, ks in parts for k in ks), Decimal(0))]
+        if hits:
+            each = (_mul(rows[c["번"]].get("수량"), rows[c["번"]].get("단가")) for c in hits)
+            bases.append(sum((x or 0 for x in each), Decimal(0)))
+        found = [_short(amount / b) for b in bases if b]
+        if found:
+            f["율"] = min(found, key=lambda r: len(r.as_tuple().digits))
+
+
+def _hit(line: dict, reach: set[str]) -> bool:
+    parts = _names(line.get("수량")) | _names(line.get("단가"))
+    return bool(line.get("기호") and str(line["기호"]) in reach) or bool(parts and parts <= reach)
+
+
+def _cls(kind: str) -> str:
+    return "기계" if kind == "산출" else kind  # 기계경비 묶음(코드 없음) = 기계
+
+
+def _num(v: Any) -> Decimal:
+    if isinstance(v, dict):
+        return sum((_num(v.get(k)) for k in md.COSTS), Decimal(0))
+    try:
+        return Decimal(str(v)) if v is not None else Decimal(0)
+    except InvalidOperation:
+        return Decimal(0)
+
+
+def _mul(q: Any, p: Any) -> Decimal | None:
+    if q is None or p is None:
+        return None
+    return _num(q) * _num(p)
+
+
+def pct(r: Any) -> str:
+    """비율 → 「9 %」."""
+    if not isinstance(r, Decimal):
+        return "?"
+    return f"{(r * 100).normalize():f} %"
+
+
+# ── 짝 줄 ─────────────────────────────────────────────────────────────
+def txt(v: Any) -> str:
+    """단가 글 — 수 = 원 단위 쉼표 · 기계 묶음 = 노 · 재 · 경."""
+    if isinstance(v, tuple):
+        return " · ".join(f"{k[0]} {txt(x)}" for k, x in zip(md.COSTS, v) if x)
+    if isinstance(v, Decimal):
+        return f"{v.normalize():,f}"
+    return str(v)
+
+
+_ALIAS = (("로울러", "롤러"), ("굴삭", "굴착"), ("브레이카", "브레이커"), ("로우더", "로더"))
+_ALIAS += (("물탱크", "살수차"), ("아스팔트페이버", "아스팔트피니셔"))  # 같은 기계 다른 이름
+
+
+def _plain(text: str) -> str:
+    t = re.sub(r"\s", "", text)
+    for old, new in _ALIAS:
+        t = t.replace(old, new)
+    return t
+
+
+def _head(text: str) -> str:
+    """기계 이름 머리(괄호 · 규격 앞 한글) — 「머캐덤로울러(자주식)」 → 「머캐덤롤러」."""
+    m = re.match(r"[가-힣]+", _plain(text))
+    return m.group(0) if m else ""
+
+
+def _same_machine(a: str, b: str) -> bool:
+    x, y = _head(a), _head(b)
+    return bool(x and y) and (x in y or y in x)
+
+
+def _grams(text: str) -> set[str]:
+    t = _plain(text)
+    return {run[i : i + 2] for run in re.findall(r"[가-힣]+", t) for i in range(len(run) - 1)}
+
+
+def pair(a: dict, b: dict) -> tuple[list[dict], list[dict]]:
+    """수량 같은 짝 줄 → (다른 항, 참고) — 단가만 다르면 참고 · 자원 · 비목이 다르면 다른 항."""
+    diffs: list[dict] = []
+    kinds = {a["갈래"], b["갈래"]}
+    # 기계경비 숫자 묶음(코드 없음 · 원파일 값) ↔ 우리 기계 = 이름 종류로 같은 기계인지
+    loose = kinds == {"기계", "산출"} and not (a if a["갈래"] == "산출" else b)["코드"]
+    if a["갈래"] == b["갈래"] == "기계" and a["코드"] != b["코드"]:
+        diffs.append({"항": "기계 규격", "글": f"{a['이름']} {a['코드']} ↔ {b['코드']}"})
+    elif loose and not _same_machine(a["이름"], b["이름"]):
+        diffs.append({"항": "기계 규격", "글": f"{a['이름']} ↔ {b['이름']} {b['코드']}"})
+    elif a["갈래"] == b["갈래"] == "노임" and a["코드"] != b["코드"]:
+        diffs.append({"항": "자원", "글": f"{a['이름']} {a['코드']} ↔ {b['이름']} {b['코드']}"})
+    elif a["갈래"] == b["갈래"] == "재료" and not _same_stuff(a, b):
+        diffs.append({"항": "자원", "글": f"{a['이름']} ↔ {b['이름']}"})
+    machine = a["갈래"] == b["갈래"] == "기계" or loose  # 시간당 단가 구성(운전 노무비 등) = 값
+    priced = a["비목"] and b["비목"]  # 한쪽 단가 없음(0) = 값
+    if priced and not machine and set(a["비목"]) != set(b["비목"]):
+        diffs.append(
+            {"항": "비목", "글": f"{a['이름']} 비목 {'·'.join(a['비목'])} ↔ {'·'.join(b['비목'])}"}
+        )
+    if a["단가"] == b["단가"]:
+        return diffs, []
+    say = f"{a['이름']} 단가 {txt(a['단가'])} ↔ {txt(b['단가'])}"
+    if (a["갈래"] == b["갈래"] and a["갈래"] in PRICED) or loose:
+        return diffs, [{"항": "단가 차이", "글": say}]
+    return [*diffs, {"항": "산출 단가", "글": say}], []
+
+
+def _same_stuff(a: dict, b: dict) -> bool:
+    """자재 종류 같음 — 두 코드가 있으면 코드 · 없으면 이름 낱말(한글 두 글자) 겹침."""
+    if a["코드"] and b["코드"] and a["코드"] == b["코드"]:
+        return True
+    return bool(_grams(a["이름"]) & _grams(b["이름"]))
+
+
+def rate_pairs(left: list[dict], right: list[dict], take: Any) -> tuple[list[dict], list[dict]]:
+    """율 줄 짝 → (다른 항, 참고) — 구조 = 대상 · 비목 · 같으면 로직 같음(율 값 % 다름 = 참고 · 값은 업데이트됨)."""
+    diffs: list[dict] = []
+    notes: list[dict] = []
+
+    def is_rate(a: dict, b: dict) -> bool:
+        return a["갈래"] == b["갈래"] == "율"
+
+    def same(a: dict, b: dict, *keys: str) -> bool:
+        return is_rate(a, b) and all(
+            (set(a[k]) == set(b[k])) if k == "비목" else a.get(k) == b.get(k) for k in keys
+        )
+
+    def name(a: dict, b: dict) -> str:
+        return f"{a['이름']} {pct(a.get('율'))} ↔ {b['이름']} {pct(b.get('율'))}"
+
+    def target(x: dict) -> str:
+        return "·".join(f"{k} {c}" for k, c in sorted(x.get("대상") or ())) or "없음"
+
+    def value(a: dict, b: dict) -> None:
+        if a.get("율") != b.get("율"):
+            notes.append({"항": "율 값", "글": f"{name(a, b)} — 바꾸면 우리 값"})
+
+    take(lambda a, b: same(a, b, "율", "대상", "비목"))  # 로직 · 값 같음
+    for a, b in take(lambda a, b: same(a, b, "대상", "비목")):  # 로직 같음 · 율 값만 다름
+        value(a, b)
+    for a, b in take(lambda a, b: same(a, b, "대상")):
+        diffs.append({"항": "비목", "글": f"율 줄 {name(a, b)} 비목 다름"})
+        value(a, b)
+    for a, b in take(lambda a, b: same(a, b, "율")):
+        diffs.append({"항": "율 대상", "글": f"{name(a, b)} 대상 {target(a)} ↔ {target(b)}"})
+    for a, b in take(is_rate):
+        diffs.append({"항": "율 대상", "글": f"{name(a, b)} 대상 {target(a)} ↔ {target(b)}"})
+    return diffs, notes

M02_MasterTemplete/M02_Doc_NativeEst.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import re
 
+from M02_MasterTemplete import M02_Doc_NativeLayout as lay
 from M02_MasterTemplete import M02_San_Emit as em
 from M02_MasterTemplete import M02_San_Est as est
 from M02_MasterTemplete import M02_San_Expr as ex
@@ -76,6 +77,8 @@ class Block:
         self.groups: dict[str, list[tuple[str, float]]] = {}  # 구간 글자 → (부름 글, 결과)
         self.extra: dict[int, dict] = {}  # 행 → 소계가 정한 비목(아래 줄)
         self.got = {"확정": 0, "표지": 0, "추정": 0}
+        self.memo: list[int] = []  # 글 줄 행(812-3 차림 · 분수 그림 위아래 줄 뺌)
+        self.frac: set[int] = set()
 
     # ── 작은 도구 ──────────────────────────────────────────────────
     def mark(self, ln: dict, why: str) -> None:
@@ -182,6 +185,7 @@ class Block:
             return re.sub(r"\s*([×÷·+*/−-])\s*", r"\1", t).strip().split()
 
         tops, bottoms, at = cols(i - 1), cols(i + 1), [0]
+        self.frac |= {self.lines[k]["행"] for k in (i - 1, i + 1) if 0 <= k < len(self.lines)}
 
         def one(_: re.Match) -> str:
             k = at[0]
@@ -298,7 +302,7 @@ class Block:
         """기계 · 산근 · 견적 세 줄 → 로직 값묶음 한 줄(수량 식 · 자리 같을 때) · 아니면 줄마다."""
         got = [self.money(ln) for ln in rows]
         parts = [ln["비목"] for ln in rows]
-        same = all(got) and len({g for g in got}) == 1 and sorted(parts) == ["L", "M", "S"]
+        same = all(got) and len({repr(g) for g in got}) == 1 and sorted(parts) == ["L", "M", "S"]
         if not same:
             for ln, g in zip(rows, got):
                 self.machine_line(ln, g)
@@ -485,6 +489,7 @@ class Block:
 
     def text_line(self, ln: dict) -> None:
         """글 줄 — 품셈 · 조건 이름만 있는 글(값 없음) = 「추정」 표지(연결 안 함 · 810-3 화면)."""
+        self.memo.append(ln["행"])
         if _COND.search(ln["보임"]):
             self.o.glyph(
                 ln["행"], ln["보임"], mark=f"{NOTE}{GUESS} — 품셈 조건 글(값 없음 · 연결 안 함)"
@@ -493,6 +498,22 @@ class Block:
             return
         self.o.glyph(ln["행"], ln["보임"])
 
+    def tags(self) -> None:
+        """812-3 차림 표지(`M02_Doc_NativeLayout`) — 글줄 `차림` = 머리(단 > 0 ·
+        소계 구간 첫 글 · 번호 글) · 합계 · 글(근거 · 메모)."""
+        self.o.head[lay.TAG] = True
+        for ln in self.lines:
+            one = self.o.at.get(ln["행"])
+            if one is None or ln["행"] in self.frac or "자리" in one:
+                continue
+            head = (ln.get("단") or 0) > 0 or ln.get("색인") == -20
+            if ln.get("합계"):
+                one[lay.TAG] = "합계"
+            elif head or (ln["행"] in self.memo and lay.NUMBERED.match(one["글"])):
+                one[lay.TAG] = "머리"
+            elif ln["행"] in self.memo:
+                one[lay.TAG] = "글"
+
     # ── 한 벌 ─────────────────────────────────────────────────────
     def run(self) -> dict:
         for k, ln in enumerate(self.lines):  # 「노무비 : ‹단가›」(식 · 결과 없음) = 단가 × 1
@@ -544,6 +565,7 @@ class Block:
             elif (ln.get("보임") or "").strip():
                 self.text_line(ln)
             i += 1
+        self.tags()
         saved = self.blk.get("저장") or {}
         check = {COMP[c]: saved.get(c) or 0 for c in COMP} | {"계": saved.get("T") or 0}
         out = self.o.done("비목버림", None, check, "산근", self.file)

M02_MasterTemplete/M02_Doc_NativeLayout.py

@@ -0,0 +1,442 @@
+"""가져온 단가산출 줄 쌓기 차림(PLAN 812-3 · 요구 713 · 669~677) — 경쟁사 산출근거 꼴.
+
+금액 · 셈 그대로. `M02_Doc_Import_Shape.shape` 가 부름(`tag` = 다듬기 앞 · `apply` = 끝) ·
+원본 `차림` 표지 있는 블록만(EST = `M02_Doc_NativeEst` · STmate = `M02_San_Emit.stmate`):
+    항목 = 머리 줄(글줄 `차림` 「머리」 · 「1. …」 「가. …」 글) · 번호 글은 떼고 화면이 매김 ·
+        가 · 나 = `가나다` · STmate 는 계 줄(`단계:`)마다 끊고 그 뒤 첫 글 줄 = 제목 ·
+        머리 앞 줄 = 제목 없는 항목 · 합계 줄(「합계」 · 「소계」 절)만 있는 머리 = 뺌
+        (화면 소계 · 합계가 냄)
+    금액 줄 = 그 자리(원본 행 차례) — EST 는 셈이 같을 때만 금액 차례를 원본 차례로
+        (단계 · 누계 이름 없고 기호 부름이 앞 줄일 때)
+    공식 묶음 = 변수 대입 줄(`mid:` · 쓰는 차례) · 글 줄 = 근거 · 메모(글줄 `차림` 「글」)
+    저장 = 금액 줄 `묶음` = 항목 제목 + 문서 `쌓기`(기본 차림과 다를 때만).
+파이썬 · TS 짝 — `common_util/common_util_line_stack.ts` `stackOf` · `saveOf` ·
+`hiddenOf`(안 놓인 기호 자리 · 기본 차림)의 거울 · 거울 시험
+`resources/tester/test_812_3_native_layout.py`(TS 왕복). 고칠 때 둘을 같이 고침.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+_SCRIPTS = Path(__file__).resolve().parents[1] / "resources" / "master_data" / "scripts"
+if str(_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS))
+
+import master_doc as md  # noqa: E402
+
+from M02_MasterTemplete import M02_Sangeun_Doc as sd  # noqa: E402
+
+TAG = "차림"  # 글줄 칸 — 머리 | 합계 | 글 · 원본 칸 = 차림 낼 블록
+KEEP = "_로직줄"  # 문서 금액 줄 ↔ 로직 줄 차례(다듬기 사이 임시)
+GANADA = "가나다라마바사아자차카타파하"
+NUMBERED = re.compile(rf"^\s*'?\s*(\d{{1,2}}|[{GANADA}])\s*[.)]\s*(?!\d)(\S.*)$")
+_TOTAL = {"합계", "소계", "계"}
+
+
+def tag(doc: dict, meta: dict) -> None:
+    """다듬기(이름 · 기계 합침) 앞 — 금액 줄마다 로직 줄 차례(호표 → 덧줄)를 적어 둠."""
+    row = meta.get("로직") or {}
+    n = len(row.get("호표") or []) + len(row.get("덧줄") or [])
+    money = doc.get("금액") or []
+    if (meta.get("원본") or {}).get(TAG) and money and len(money) == n:
+        for k, line in enumerate(money):
+            line[KEEP] = k
+
+
+def title_of(text: str) -> tuple[str, bool]:
+    """「 1. 기 계(100%)」 → (「기 계(100%)」, 거짓) · 「'가. 굴삭기'」 → (「굴삭기」, 가나다)."""
+    flat = " ".join(str(text or "").replace("'", " ").split())
+    m = NUMBERED.match(flat)
+    if not m:
+        return flat, False
+    return m.group(2).strip(), m.group(1) in GANADA
+
+
+# ── 차림 ──────────────────────────────────────────────────────────────
+def apply(doc: dict, meta: dict) -> None:
+    money = doc.get("금액") or []
+    keys = [line.pop(KEEP, None) for line in money]
+    src = meta.get("원본") or {}
+    if not src.get(TAG) or not money or None in keys:
+        return
+    from M02_MasterTemplete import M02_Sangeun_Imported as imp
+
+    row = meta.get("로직") or {}
+    ids = sd.line_ids(
+        imp.row_of({imp.KEY: {"로직": row}}) or {}
+    )  # 글줄 자리 = 줄 정체(`imp._named`)
+    lines = [*(row.get("호표") or []), *(row.get("덧줄") or [])]
+    by: dict[str, int] = {}
+    for k, (cid, one) in enumerate(zip(ids, lines)):
+        by.setdefault(cid, k)
+        by.setdefault(str(one.get("이름")), k)
+    inv = {k: j for j, k in enumerate(keys)}
+    texts = sorted(
+        (t for t in src.get("글줄") or [] if isinstance(t.get("행"), int)), key=lambda t: t["행"]
+    )
+    at: dict[int, int] = {}  # 문서 금액 줄 → 원본 행
+    for t in texts:
+        for spot in t.get("자리들") or ([t["자리"]] if t.get("자리") else []):
+            j = inv.get(by.get(str(spot), -1))
+            if j is not None:
+                at[j] = min(at.get(j, t["행"]), t["행"])
+    rows = _fill([at.get(j) for j in range(len(money))])
+    order = sorted(range(len(money)), key=lambda j: (rows[j], j))
+    if order != list(range(len(money))) and _safe(doc, order):
+        doc["금액"] = money = [money[j] for j in order]
+        rows = [rows[j] for j in order]
+    else:
+        for j in range(1, len(rows)):  # 차례 그대로 — 앞 줄보다 위면 앞 줄 자리로
+            rows[j] = max(rows[j], rows[j - 1])
+    items = _items(doc, texts, rows, src.get("갈래") == "STmate")
+    for it in items:
+        for kind, j in it["줄"]:
+            if kind == "금액":
+                money[j].pop("묶음", None)
+                money[j] |= {"묶음": it["제목"]} if it["제목"] else {}
+    raw = [_save_item(it, money) for it in items]
+    doc.pop("쌓기", None)
+    plain = save_of(stack_of(doc), money)
+    got = save_of(stack_of({**doc, "쌓기": raw}), money)
+    if got != plain:
+        doc["쌓기"] = got
+
+
+def _fill(rows: list[int | None]) -> list[int]:
+    """원본 행 없는 줄(글줄에 안 붙은 소계 덧줄 등) = 다음 줄 행 · 없으면 앞 줄 행."""
+    out = list(rows)
+    for j in range(len(out) - 1, -1, -1):
+        if out[j] is None and j + 1 < len(out):
+            out[j] = out[j + 1]
+    for j in range(len(out)):
+        if out[j] is None:
+            out[j] = out[j - 1] if j else 0
+    return [int(x or 0) for x in out]
+
+
+def _safe(doc: dict, order: list[int]) -> bool:
+    """금액 차례를 바꿔도 셈이 같음 — 단계 없음 · 누계 · 번지 · 단계 이름 안 씀 ·
+    줄 기호 부름 = 앞 줄."""
+    if doc.get("단계"):
+        return False
+    money = doc.get("금액") or []
+    pos = {j: p for p, j in enumerate(order)}
+    sym = {str(x["기호"]): pos[j] for j, x in enumerate(money) if x.get("기호")}
+    for j, line in enumerate(money):
+        for text in (line.get("수량"), line.get("단가")):
+            if text is None or str(text).strip() == "":
+                continue
+            try:
+                got = md.names(md.parse(text))
+            except md.DocError:
+                return False
+            if any(n in md.MONEY_NAMES or n == "계" for n in got):
+                return False
+            if any(n in sym and sym[n] >= pos[j] for n in got):
+                return False
+    return True
+
+
+def _items(doc: dict, texts: list[dict], rows: list[int], stm: bool) -> list[dict]:
+    """원본 행 차례로 항목 · 줄을 쌓음 — 줄 = (금액, 문서 줄) | (공식, [기호]) | (글, 글)."""
+    have = set(symbols(doc))
+    hidden = hidden_of(doc)
+    ev: list[tuple[int, int, int, str, Any]] = []
+    for t in texts:
+        mark, text = t.get(TAG), str(t.get("글") or "")
+        spots = t.get("자리들") or ([t["자리"]] if t.get("자리") else [])
+        mids = [s[4:] for s in spots if str(s).startswith("mid:")]
+        if any(str(s).startswith("단계:") for s in spots):
+            ev.append((t["행"], 0, 0, "끝", None))
+        elif mark == "합계":
+            ev.append((t["행"], 0, 0, "합계", None))
+        elif not spots and (mark == "머리" or (mark == "글" and NUMBERED.match(text))):
+            ev.append((t["행"], 0, 0, "머리", title_of(text)))
+        elif not spots and mark == "글" and text.strip():
+            ev.append((t["행"], 1, 0, "글", " ".join(text.replace("'", " ").split())))
+        ids = [m for m in mids if m in have and m not in hidden]
+        if ids:
+            ev.append((t["행"], 1, 0, "공식", ids))
+    ev += [(r, 2, j, "금액", j) for j, r in enumerate(rows)]
+    ev.sort(key=lambda e: e[:3])
+    items: list[dict] = []
+    cur: dict | None = None
+    cut = False  # STmate 계 줄 뒤 — 다음 첫 글 줄 = 제목
+
+    def new(title: str = "", sub: bool = False) -> dict:
+        it = {"제목": title, "가나다": sub, "줄": [], "합계": False}
+        items.append(it)
+        return it
+
+    for _, _, _, kind, val in ev:
+        if kind == "끝":
+            cur, cut = None, stm
+        elif kind == "합계":
+            if cur is not None:
+                cur["합계"] = True
+        elif kind == "머리" or (kind == "글" and cut and cur is None):
+            title, sub = val if kind == "머리" else title_of(val)
+            if cur is not None and not cur["줄"] and not cur["제목"]:
+                cur["제목"], cur["가나다"] = title, sub
+            else:
+                cur = new(title, sub)
+            cut = False
+        else:
+            cur = cur if cur is not None else new()
+            if kind == "공식" and cur["줄"] and cur["줄"][-1][0] == "공식":
+                cur["줄"][-1][1].extend(x for x in val if x not in cur["줄"][-1][1])
+            else:
+                cur["줄"].append((kind, list(val) if kind == "공식" else val))
+    keep = []
+    for it in items:
+        flat = re.sub(r"\s+", "", it["제목"])
+        if not it["줄"] and (it["합계"] or not flat or flat in _TOTAL):
+            continue
+        keep.append(it)
+    return keep
+
+
+def _save_item(it: dict, money: list[dict]) -> dict:
+    out: dict[str, Any] = {}
+    if it["제목"]:
+        out["제목"] = it["제목"]
+    if it["가나다"]:
+        out["가나다"] = True
+    lines = []
+    for kind, val in it["줄"]:
+        if kind == "금액":
+            lines.append({"금액": val, "이름": money[val].get("이름") or ""})
+        elif kind == "공식":
+            lines.append({"공식": val})
+        else:
+            lines.append({"글": val})
+    return out | {"줄": lines}
+
+
+# ── 줄 쌓기 모델 거울(`common_util_line_stack.ts`) ──────────────────────
+def _names_in(text: Any) -> list[str]:
+    if text is None or str(text).strip() == "":
+        return []
+    try:
+        return md.names(md.parse(text))
+    except md.DocError:
+        return []
+
+
+def symbols(doc: dict) -> list[str]:
+    out = [md.var_id(v) for v in doc.get("변수") or []]
+    for line in doc.get("식") or []:
+        sid = str(line.get("기호") or "")
+        if sid and sid not in out:
+            out.append(sid)
+    return out
+
+
+def _is_option(v: dict | None) -> bool:
+    return bool(v and v.get("열쇠") and (v.get("연결") or {}).get("갈래") in ("선택", "입력"))
+
+
+def uses_of(doc: dict) -> dict[str, list[str]]:
+    out: dict[str, list[str]] = {}
+
+    def add(sid: str, more: list[str]) -> None:
+        now = out.setdefault(sid, [])
+        now += [n for n in more if n not in now]
+
+    for v in doc.get("변수") or []:
+        add(md.var_id(v), md.link_names(v["연결"]) if v.get("연결") else [])
+    for line in doc.get("식") or []:
+        add(str(line.get("기호") or ""), _names_in(line.get("식")))
+    return out
+
+
+def price_sym(line: dict) -> str | None:
+    text = line.get("단가")
+    if text is None or str(text).strip() == "":
+        return None
+    try:
+        n = md.parse(text)
+    except md.DocError:
+        return None
+    if n[0] == "var":
+        return n[1]
+    if n[0] == "field" and n[1][0] == "var":
+        return n[1][1]
+    return None
+
+
+def owned_of(doc: dict) -> dict[int, str]:
+    count: dict[str, int] = {}
+    for ns in (
+        *(_names_in(x.get("수량")) + _names_in(x.get("단가")) for x in doc.get("금액") or []),
+        *uses_of(doc).values(),
+        *([[doc["결과"]]] if doc.get("결과") else []),
+    ):
+        for n in ns:
+            count[n] = count.get(n, 0) + 1
+    vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
+    lines = {str(x.get("기호") or "") for x in doc.get("식") or []}
+    out = {}
+    for i, line in enumerate(doc.get("금액") or []):
+        s = price_sym(line)
+        kind = ((vars_.get(s) or {}).get("연결") or {}).get("갈래") if s else None
+        if s and kind in ("요소", "단가산출") and count.get(s) == 1 and s not in lines:
+            out[i] = s
+    return out
+
+
+def hidden_of(doc: dict) -> set[str]:
+    """차림에 안 넣는 기호 — 옵션 · 금액 줄이 가진 연결(가져온 값 옵션 칸은 공식 묶음에도 보임)."""
+    out = set(owned_of(doc).values())
+    out |= {md.var_id(v) for v in doc.get("변수") or [] if _is_option(v)}
+    return out
+
+
+def _post_order(doc: dict, roots: list[str], uses: dict[str, list[str]]) -> list[str]:
+    out: list[str] = []
+    seen: set[str] = set()
+    stack: list[tuple[str, int]] = []
+    for start in [*roots, *symbols(doc)]:  # 되부름 없이(깊은 식 사슬)
+        if start in seen:
+            continue
+        seen.add(start)
+        stack.append((start, 0))
+        while stack:
+            sid, k = stack.pop()
+            kids = uses.get(sid) or []
+            if k < len(kids):
+                stack.append((sid, k + 1))
+                if kids[k] not in seen:
+                    seen.add(kids[k])
+                    stack.append((kids[k], 0))
+            else:
+                out.append(sid)
+    return out
+
+
+def _reach(line: dict, uses: dict[str, list[str]]) -> set[str]:
+    out: set[str] = set()
+    todo = _names_in(line.get("수량")) + _names_in(line.get("단가"))
+    while todo:
+        sid = todo.pop()
+        if sid in out:
+            continue
+        out.add(sid)
+        todo += uses.get(sid) or []
+    return out
+
+
+def stack_of(doc: dict) -> list[dict]:
+    """`stackOf` — 저장 차림 + 안 놓인 것은 기본 자리 ·
+    줄 = {꼴 금액 i | 꼴 공식 기호 틀? | 꼴 글 글}."""
+    money = doc.get("금액") or []
+    all_ = set(symbols(doc))
+    hidden = hidden_of(doc)
+    items: list[dict] = []
+    where: dict[int, dict] = {}
+    placed: set[str] = set()
+    saved = doc.get("쌓기") if isinstance(doc.get("쌓기"), list) else []
+    taken: set[int] = set()
+    for s in saved:
+        s = s if isinstance(s, dict) else {}
+        it: dict[str, Any] = {
+            "제목": str(s.get("제목") if s.get("제목") is not None else ""),
+            "줄": [],
+        }
+        if s.get("가나다"):
+            it["가나다"] = True
+        for line in s.get("줄") if isinstance(s.get("줄"), list) else []:
+            if isinstance(line, dict) and "금액" in line:
+                i = int(line["금액"])
+                name = line.get("이름")
+                if not (
+                    0 <= i < len(money) and (money[i].get("이름") or "") == name and i not in taken
+                ):
+                    free = (k for k, m in enumerate(money) if k not in taken)
+                    i = next((k for k in free if (money[k].get("이름") or "") == name), -1)
+                if i < 0 or i in taken:
+                    continue
+                taken.add(i)
+                where[i] = it
+                it["줄"].append({"꼴": "금액", "i": i})
+            elif isinstance(line, dict) and "공식" in line:
+                got = [
+                    x
+                    for x in line["공식"] or []
+                    if x in all_ and x not in hidden and x not in placed
+                ]
+                placed |= set(got)
+                one: dict[str, Any] = {"꼴": "공식", "기호": got}
+                if line.get("틀"):
+                    one["틀"] = str(line["틀"])
+                    if line.get("틀꼴"):
+                        one["틀꼴"] = str(line["틀꼴"])
+                it["줄"].append(one)
+            elif isinstance(line, dict) and "글" in line:
+                it["줄"].append(
+                    {"꼴": "글", "글": str(line["글"] if line["글"] is not None else "")}
+                )
+        items.append(it)
+    for i, m in enumerate(money):
+        if i in taken:
+            continue
+        title = str(m.get("묶음") if m.get("묶음") is not None else "")
+        prev = where.get(i - 1)
+        if prev is not None and prev["제목"] == title:
+            it = prev
+            at = next(k for k, x in enumerate(prev["줄"]) if x["꼴"] == "금액" and x["i"] == i - 1)
+            prev["줄"].insert(at + 1, {"꼴": "금액", "i": i})
+        else:
+            it = next((x for x in items if x["제목"] == title), None) if saved else None
+            if it is None:
+                it = {"제목": title, "줄": []}
+                items.append(it)
+            it["줄"].append({"꼴": "금액", "i": i})
+        taken.add(i)
+        where[i] = it
+    uses = uses_of(doc)
+    reach = [_reach(m, uses) for m in money]
+    for sid in _post_order(doc, [doc["결과"]] if doc.get("결과") else [], uses):
+        if sid not in all_ or sid in hidden or sid in placed:
+            continue
+        i = next((k for k, r in enumerate(reach) if sid in r), -1)
+        it = where.get(i) if i >= 0 else (items[0] if items else None)
+        if it is None:
+            it = {"제목": "", "줄": []}
+            items.append(it)
+        block = next((x for x in it["줄"] if x["꼴"] == "공식"), None)
+        if block is None:
+            block = {"꼴": "공식", "기호": []}
+            it["줄"].insert(0, block)
+        block["기호"].append(sid)
+        placed.add(sid)
+    return items
+
+
+def save_of(items: list[dict], money: list[dict]) -> list[dict]:
+    """`saveOf`(차례 그대로)."""
+    out = []
+    for it in items:
+        one: dict[str, Any] = {}
+        if it["제목"]:
+            one["제목"] = it["제목"]
+        if it.get("가나다"):
+            one["가나다"] = True
+        lines = []
+        for x in it["줄"]:
+            if x["꼴"] == "금액":
+                lines.append({"금액": x["i"], "이름": money[x["i"]].get("이름") or ""})
+            elif x["꼴"] == "글":
+                lines.append({"글": x["글"]})
+            else:
+                lines.append(
+                    {"공식": list(x["기호"])}
+                    | ({"틀": x["틀"]} if x.get("틀") else {})
+                    | ({"틀꼴": x["틀꼴"]} if x.get("틀꼴") else {})
+                )
+        out.append(one | {"줄": lines})
+    return out

M02_MasterTemplete/M02_Logic_Lib_Read.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 from fastapi import APIRouter, HTTPException
 
+from M01_MasterData import M01_MasterData_Parts as parts
 from M01_MasterData import M01_MasterData_Router as m01
 from M02_MasterTemplete import M02_Machine_Hourly as machine
 
@@ -72,3 +73,9 @@ def post_text(body: m01.CalcBody) -> dict:
 def get_machine_hourly(key: str) -> dict:
     """기계(EQ) 한 시간 값 노 · 재 · 경(736-3 · [항목 추가] 기계 고정 줄 단가)."""
     return machine.hourly(key)
+
+
+@router.get("/machine-parts")
+def get_machine_parts(no: str) -> dict:
+    """줄 쌓기 기계 넣기(813-2) — 기계 원문번호 → 그 기종 작업량 틀(문서째)."""
+    return m01._call(parts.of_machine, no)

M02_MasterTemplete/M02_Machine_Hourly.py

@@ -41,6 +41,12 @@ def _rank(row: dict) -> tuple:
     return (attach, loss, loss and "보정작업" in names, len(_codes(row)), str(row.get("키")))
 
 
+def logic_of(code: str) -> dict | None:
+    """기계 원문번호 → 그 기계 시간당 경비 로직(짝 차례 첫째) · 없으면 None(813-2 M01 화면도 씀)."""
+    fit = [r for r in _family() if code in [str(c) for c in _codes(r)]]
+    return min(fit, key=_rank) if fit else None
+
+
 def hourly(key: str) -> dict[str, Any]:
     """`{ok, 이름, 규격, 로직, 원문번호, 노무비, 재료비, 경비, 계}` · 못 셈 = `{ok: False, reason}`."""
     if not key.startswith("EQ"):
@@ -50,10 +56,9 @@ def hourly(key: str) -> dict[str, Any]:
     except cm.mf.FormulaError as e:
         return {"ok": False, "reason": str(e)}
     code = str(row.get("원문번호") or "")
-    fit = [r for r in _family() if code in [str(c) for c in _codes(r)]]
-    if not fit:
+    logic = logic_of(code)
+    if not logic:
         return {"ok": False, "reason": f"「{row.get('이름')}」 은 시간당 경비를 셀 자료가 없음"}
-    logic = min(fit, key=_rank)
     args = "".join(
         f", {i['이름']}='{(i.get('고르기') or [''])[0]}'"
         for i in logic.get("입력") or []

M02_MasterTemplete/M02_MasterTemplete_Router_Combos.py

@@ -19,6 +19,7 @@ from pydantic import BaseModel
 
 from common_util.common_util_auth import verify_session
 from common_util.common_util_http_cache import cached_file_response
+from M01_MasterData import M01_MasterData_Parts as parts
 from M01_MasterData import M01_MasterData_Store as m01
 from M01_MasterData import M01_MasterData_Store_Make as make
 from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
@@ -40,7 +41,7 @@ def _read(fn, *args):
 
 @router.get("/logic-lib/logics", dependencies=[Depends(verify_session)])
 def get_logics() -> dict:
-    return {"logics": _read(m01.logics, "", "", "", None)}
+    return {"logics": parts.strip(_read(m01.logics, "", "", "", None))}  # 부품 문서 뺌(813-2)
 
 
 @router.get("/logic-lib/subs", dependencies=[Depends(verify_session)])

M02_MasterTemplete/M02_San_Book.py

@@ -12,11 +12,8 @@ from __future__ import annotations
 import io
 import re
 import warnings
-from pathlib import Path
 from typing import Any
 
-from M02_MasterTemplete import M02_Hopyo_ReadEst as read_est
-
 STM_SHEETS = (
     "단가산출근거",
     "단가산출근거목록표",
@@ -233,23 +230,3 @@ def est_prices(book: dict[str, list]) -> tuple[list[dict[str, Any]], dict[int, d
                     one = {"종류": "산근", "이름": f"단산{n}", "규격": ""}
                     out.append({**one, "비목": k, "값": san[n][k]})
     return out, san
-
-
-def est_blocks(book: dict[str, list]) -> list[dict[str, Any]]:
-    """→ [{번, 이름, 단위, 글 [줄], 글행 [행]}]."""
-    blocks = read_est.read(book.get(read_est.SHEET))
-    keep = ("번", "이름", "단위", "글", "글행")
-    return [{k: b[k] for k in keep} for b in blocks.values()]
-
-
-def load(path: str | Path) -> dict[str, Any]:
-    """파일 → {꼴, 블록, 단가(STmate dict | EST 목록), 총괄(EST)}."""
-    path = Path(path)
-    book = sheets(path.name, path.read_bytes())
-    kind = kind_of(book)
-    if kind == "STmate":
-        return {"꼴": kind, "블록": stmate_blocks(book), "단가": stmate_prices(book)}
-    if kind == "EST":
-        prices, san = est_prices(book)
-        return {"꼴": kind, "블록": est_blocks(book), "단가": prices, "총괄": san}
-    raise ValueError("STmate · EST 산근 시트 없음")

M02_MasterTemplete/M02_San_Emit.py

@@ -1,6 +1,6 @@
 """경쟁사 산근 → 우리 엔진 로직 줄 꼴 내보내기(PLAN 793-2a · 요구서_652 · eval 없음).
 
-793-1 줄 나무(`M02_San_Stmate` · `M02_San_Est`) → `{로직, 원본}` — 꼴 = 793-2 가져온 식 SK
+793-1 줄 나무(`M02_San_Stmate`) → `{로직, 원본}`(EST = 원파일 · 엑셀 둘 다 `M02_Doc_NativeEst` · 812-1) — 꼴 = 793-2 가져온 식 SK
 만들기 몸(`M02_Sangeun_Imported.py` 머리) · 로직 = `_틀.md` 7 장 꼴(셈 = `master_formula.run` →
 `master_cut.engine` · `요소` 는 SK 서버가 채움).
 - 로직 = {이름, 결과단위, 입력 [], 중간 [{이름, 식, 표시?}], 호표,
@@ -33,7 +33,6 @@ COMP = {"L": "노무비", "M": "재료비", "S": "경비"}
 _CODE = {v: k for k, v in COMP.items()}
 _SUM = "@합{}@"  # 누계 % 밑 자리(블록 끝에 `finish` 가 채움)
 KIND = {"L": "인력", "M": "재료", "X": "기계", "D": "단가산출", "B": "단가산출"}
-KIND_EST = {"노임": "인력", "자재": "재료", "기계": "기계", "견적": "고정", "산근": "단가산출"}
 RESERVED = {"노무비", "재료비", "경비", "계", "번지", "단계", "줄", "찾기", "로직", "그리고"}
 RESERVED |= {"또는", "만약", "올림", "버림", "반올림", "최소", "최대"}
 _KEY = re.compile(r"[A-Z]{2}\d{6}")
@@ -486,11 +485,15 @@ def stmate(
     me = prices.get(block["코드"]) or {}
     meta = me.get("meta") or {}
     o = Out(block.get("이름"), me.get("단위"), "STmate", block["코드"])
+    o.head["차림"] = True  # 812-3 — 계 단으로 항목 · 글 줄(`M02_Doc_NativeLayout`)
     st = _Stm(o, block, prices, keys)
     for node in nodes:
         kind, src = node["종류"], {"행": node.get("행"), "글": node.get("글") or ""}
         if kind in ("빈", "글"):
-            if src["글"].strip():
+            if src["글"].strip().strip("'").strip():
+                o.glyph(src["행"], src["글"])
+                o.at[src["행"]]["차림"] = "글"  # 812-3 줄 쌓기 글 줄 · 제목(`M02_Doc_NativeLayout`)
+            elif src["글"].strip():
                 o.glyph(src["행"], src["글"])
         elif kind == "대입":
             st.assign(node, src)
@@ -527,90 +530,3 @@ def stmate(
         more["계약"] = {"낙찰률": float(meta["NAG"]), "금액": _cols(block["머리"])}
     end = "큰나머지" if rule.startswith("합버림") else "비목버림"
     return o.done(end, adjust, _cols(kye), "단가산출근거", file, **more)
-
-
-# ── EST ────────────────────────────────────────────────────────────────
-_VAR = re.compile(r"([A-Za-z][A-Za-z0-9_]*)\s*(?:\([^)]*\))?\s*=")
-
-
-def _est_res(role: dict, value: float, comp: str | None) -> dict:
-    """EST 단가 토큰 정체 → 자원 이음 열쇠(옮김 = 성분 비목이 단가 비목과 다를 때)."""
-    p = role["정체"]
-    pc = p["비목"] if p["비목"] in COMP else (comp or "S")
-    res = {"꼴": "EST", "갈래": KIND_EST.get(p["종류"], "고정"), "종류": p["종류"]}
-    res |= {"이름": p["이름"], "규격": p["규격"], "단위": None}
-    res |= {"단가": {pc: value}}
-    res |= {"비목": pc, "옮김": comp if comp and comp != pc else None, "열쇠비목": p["비목"]}
-    return res | ({"모호": True} if role.get("모호") else {})
-
-
-def est(block: dict, lines: list[dict], want: dict, keys: bool = False, file: str = "") -> dict:
-    """EST 블록(`M02_San_Book.est_blocks` 한 개) + 복원 줄(`M02_San_Est.parse_block`) +
-    총괄표 성분 want {T, L, M, S} → {로직, 원본} · 성분을 낸 줄만 합(나머지 = 합밖)."""
-    des = ev.designate(lines, want)
-    mine = {k: c for c, k in des.items() if isinstance(k, int)}
-    o = Out(block.get("이름"), block.get("단위"), "EST", block.get("번"))
-    rows = block.get("글행") or []
-    if want.get("칸"):  # 당초 칸 사용 · 적용 ≠ 당초(797-1a)
-        o.marks.append(f"{NOTE}{want['칸']}")
-    for c, k in des.items():
-        if k is None:
-            o.marks.append(f"성분 {COMP[c]} {want[c]} 을 낸 줄 없음")
-    val = ev.run_est(lines)
-    ref: dict[int, str] = {}  # 차례 → 엔진 부름 글(앞줄 · 숨은 합)
-    for L in lines:
-        k, form, kind = L["차례"], L["꼴"], L.get("종류")
-        at, glyph = rows[k] if k < len(rows) else k, L["원글"]
-        comp = mine.get(k)
-        if form == "빈":
-            continue
-        if form == "변수" and L.get("값") is not None:
-            m = _VAR.search(L["원글"])
-            eng = o.names.line(m.group(1) if m else "변수")
-            o.middle(eng, num(L["값"]), None, at, glyph)  # 얼린 값(금액엔 보인 값이 박힘)
-            continue
-        if form not in ("돈", "값"):
-            shown = L.get("보인") if form == "글끝" else L.get("값") if form == "식못읽음" else None
-            if shown is None:
-                o.glyph(at, glyph)
-            else:  # 금액 줄 못 읽음 — 보인 값 얼림(글줄 값으로 보존)
-                o.glyph(at, glyph, value=shown, mark=f"{NOTE}금액 줄 못 읽음 · 보인 값 얼림")
-            continue
-        head = {} if comp else {"합밖": True}
-        try:
-            place = _place(L.get("규칙"))
-            if k not in val:
-                raise EmitError("보인 값이 되는 식 · 자리 못 찾음 — 보인 값으로 얼림")
-            if kind == "단가줄":
-                i, role = next((i, r) for i, r in L["역할"].items() if r["갈래"] == "단가")
-                price = next(n[1] for n in ex.numbers(L["식"]) if n[2] == i)
-                res = _est_res(role, price, comp)
-                link, many = _m01(res["갈래"], res) if keys else (None, None)
-                qty = text(L["식"], {}, {i: "1"})
-                one = resource(o.names.item(L.get("라벨") or ""), None, qty, res, link)
-                one |= {**head, **({"자리": place} if place else {})}
-                o.add_line(one, True, at, glyph, L["값"])
-                if many:
-                    o.glyph(at, glyph, mark=many)
-                if role.get("모호"):  # 임의 선택 아님 — 후보를 사람이 고름
-                    o.glyph(at, glyph, mark=f"{NOTE}단가 후보 여럿({role['남은']}) · 사람 확인")
-                elif role.get("갈림") in ("문맥", "기계 세 줄"):
-                    o.glyph(at, glyph, mark=f"{NOTE}추정 — 단가 정체 근거 {role['갈림']}")
-                ref[k] = f"줄.'{one['이름']}'"
-                continue
-            if kind == "값줄":
-                parts = [ref.get(j) or num(lines[j]["값"]) for j in L["숨은"]["줄"]]
-                formula = " + ".join(parts)
-            else:
-                swap = {i: ref[r["줄"]] for i, r in L["역할"].items() if r.get("줄") in ref}
-                formula = text(L["식"], {}, swap)
-        except EmitError as error:
-            o.glyph(at, glyph, mark=str(error))
-            formula, place = num(L["값"]), None
-        name = o.names.line(L.get("라벨") or "줄")
-        one = {"이름": name, "식": formula, "비목": COMP[comp or L.get("비목") or "S"]}
-        o.add_line(one | head | ({"자리": place} if place else {}), False, at, glyph, L["값"])
-        if k in val:
-            ref[k] = name
-    check = _money(want) | {"계": want["T"]}
-    return o.done("비목버림", None, check, "단가산출", file)

M02_MasterTemplete/M02_San_Est.py

@@ -1,42 +1,19 @@
-"""EST 산근 보이는 글 → 식 복원(PLAN 793-1 · 요구서_652 · 문법 = `_분석_648-A` 3 장 · eval 없음).
+"""EST 식 글 토큰(PLAN 793-1 · 812-1 · eval 없음) — 원파일 산근 변환(`M02_Doc_NativeEst`)이 쓰는 수 · 토큰 읽기만.
 
-엑셀엔 식이 없고 인쇄 글뿐 — 「라벨 : 식 = 결과」 로 나눠 식을 되살림. 셈은 `M02_San_Eval.run_est`.
-
-줄 꼴(`꼴`) — 빈 · 그림(분수 ─) · 글 · 글끝(끝이 결과 아님) · 식못읽음 · 변수 · 값 · 돈.
-- 돈(`종류` 단가줄 · 참조줄 · 상수줄) — 라벨 · 비목(라벨 끝 노무비 · 재료비 · 경비) ·
-  값(보인 결과) · 식(`M02_San_Expr` 나무) ·
-  역할 {수 토큰 차례: 단가(후보 · 정체 · 모호) | 앞줄(같은 블록 앞 결과 줄 차례) | 상수} ·
-  규칙(보인 결과가 되는 줄 자리 속성 · 기본 버림1)
-- 값(`종류` 값줄 「소 계 : 1,355.9」) — 숨은 = {갈래 복사 | 합, 줄 [차례], 규칙}(앞 결과 하나 또는
-  바로 앞 돈 · 값 줄 이음 합)
-- 변수(`종류` 변수식 · 변수값 · 변수기호 · 변수글) — 값 · 규칙 = 얼림(금액엔 반올림된 값이 박힘)
+옛 엑셀 글 추정 사슬(줄 꼴 · 역할 · 값 역색인 · `parse_block`)은 812-1 엑셀 읽기기(`M02_San_Xlsx`)로 바뀌어 걷음.
 """
 
 from __future__ import annotations
 
-import collections
 import re
-from typing import Any
 
 from M02_MasterTemplete import M02_San_Expr as ex
-from M02_MasterTemplete.M02_San_Book import flat
 
-COMPW = {"노무비": "L", "재료비": "M", "경비": "S"}
 NUMRE = r"\d{1,3}(?:,\d{3})+(?:\.\d*)?|\d+(?:\.\d*)?|\.\d+"
 EPS = ex.EPS
 OPS = {"×": "*", "x": "*", "X": "*", "*": "*", "÷": "/", "/": "/", "+": "+", "-": "-"}
 OPS |= {"－": "-", "−": "-"}
 _UNIT = re.compile(r"\s*(?:[A-Za-z가-힣㎡㎥㎏ℓ㎝㎜°˚’'\"Øø]+(?:\s*/\s*[A-Za-z가-힣㎡㎥㎏ℓ]+)?)")
-VARLINE = re.compile(r"^\s*(?:[○●◦·\-]\s*)?[A-Za-z][A-Za-z0-9_]*\s*(?:\([^)]*\))?\s*=")
-RES = re.compile(
-    r"^\s*(?:[A-Z]\s+)?("
-    + NUMRE
-    + r")\s*\.?\s*(?:원)?\s*(?:[￦\\]?\s*/\s*\S+)?\s*(?:\([^()]*\))?\s*$"
-)
-_PLAIN = re.compile(r"[\s\d.,×÷+\-()A-Za-z가-힣㎡㎥]*")
-_LABEL = re.compile(r"^(?P<l>[^:：=]{0,40}?)\s*[:：]\s*(?P<r>.*)$")
-TAIL = re.compile(r"^\s*(" + NUMRE + r")\s*\.?\s*[:：][^=]*$")  # 결과 뒤 꼬리 글 「3,094.2 : 채집」
-_HEADING = re.compile(r"^\s*(\d+|[가-하])\s*[.)]")
 
 
 def num(s: str) -> float:
@@ -112,214 +89,3 @@ def tokens(seg: str) -> list[tuple] | None:
     if depth != 0 or want or not any(t[0] in ("연산", "%") for t in out):
         return None
     return out
-
-
-def calc(node: tuple, sub: dict | None = None) -> float | None:
-    try:
-        return ex.value(node, {"V": {}, "sub": sub})
-    except ex.ExprError:
-        return None
-
-
-def label_comp(label: str) -> str | None:
-    w = flat(label)
-    return next((v for k, v in COMPW.items() if w.endswith(k)), None)
-
-
-def parse_line(text: str) -> dict[str, Any]:
-    """보이는 글 한 줄 → 꼴 · 라벨 · 결과 · 식 나무(역할 전)."""
-    t = text.strip()
-    if not t:
-        return {"꼴": "빈"}
-    if "─" in t or _PLAIN.fullmatch(t) and "=" not in t and ":" not in t:
-        return {"꼴": "그림" if "─" in t else "글"}
-    label, rhs = "", t
-    mc = _LABEL.match(t)
-    if mc and not re.search(r"\d\s*$", mc.group("l")):
-        label, rhs = mc.group("l"), mc.group("r")
-    if VARLINE.match(rhs) or VARLINE.match(t):
-        return {"꼴": "변수", "조각": rhs.split("=")}
-    if "=" not in rhs:
-        m = re.match(r"^\s*(" + NUMRE + r")\s*\.?\s*$", rhs)
-        if label and m:
-            return {"꼴": "값", "라벨": label, "비목": label_comp(label), "값": num(m.group(1))}
-        return {"꼴": "글"}
-    segs = rhs.split("=")
-    mres = RES.match(segs[-1]) or TAIL.match(segs[-1])  # 꼬리 글은 떼고 읽음(797-1a)
-    if not mres:
-        lead = re.match(r"\s*(" + NUMRE + r")", segs[-1])
-        if (
-            label and lead and re.search(r"\d", "=".join(segs[:-1]))
-        ):  # 금액 줄 못 읽음 — 보인 값 보존
-            return {"꼴": "글끝", "라벨": label, "보인": num(lead.group(1))}
-        return {"꼴": "글끝"}
-    shown = num(mres.group(1))
-    toks = None
-    for seg in reversed(segs[:-1]):
-        toks = tokens(seg)
-        if toks is None:  # 라벨 없는 줄 — 왼쪽 글을 깎아 가며
-            starts = {m.start() for m in re.finditer(NUMRE, seg)}
-            starts |= {m.start() for m in re.finditer(r"\(\s*\d", seg)}
-            for p in sorted(starts):
-                if p and (seg[p - 1].isdigit() or seg[p - 1] in ".,"):
-                    continue
-                toks = tokens(seg[p:])
-                if toks:
-                    label = label or seg[:p]
-                    break
-        if toks:
-            break
-    if not toks:
-        return {"꼴": "식못읽음", "라벨": label, "값": shown}
-    return {"꼴": "돈", "라벨": label, "비목": label_comp(label), "값": shown, "식": ex.parse(toks)}
-
-
-# ── 블록 풀이 ──────────────────────────────────────────────────────────
-def _ident(p: dict[str, Any]) -> tuple:
-    return (p["종류"], p["이름"], p["규격"])
-
-
-def _money(L: dict, prices_by_value: dict, results: list) -> None:
-    """돈 줄 — 수 토큰 역할(단가 · 앞줄 · 상수) · 다시 셈 · 자리 규칙."""
-    comp = L["비목"]
-    nums = [(n[2], n[1]) for n in ex.numbers(L["식"])]
-    roles: dict[int, dict[str, Any]] = {}
-    price_at = None
-    for i, v in nums:
-        if v >= 1 and any(abs(r[1] - v) < EPS for r in results):
-            continue  # 앞 결과와 같은 수 = 참조(단가표 우연 일치보다 먼저)
-        cands = [p for p in prices_by_value.get(v, []) if v >= 1 or (v == 0 and comp)]
-        if comp:
-            cands = [p for p in cands if p["비목"] == comp] or cands
-        if v == 0 and comp and not cands:
-            cands = [{"종류": "0", "이름": "-", "규격": "", "비목": comp, "값": 0.0}]
-        first = i == nums[0][0]
-        if cands and (v >= 100 or (first and v > 0)) or (v == 0 and cands):
-            price_at = i
-            roles[i] = {"갈래": "단가", "후보": cands}
-            break
-    for i, v in nums:
-        if i in roles:
-            continue
-        hit = [r for r in reversed(results) if abs(r[1] - v) < EPS]
-        roles[i] = {"갈래": "앞줄", "줄": hit[0][0]} if hit and v >= 1 else {"갈래": "상수"}
-    L["역할"] = roles
-    L["셈"] = calc(L["식"])
-    L["규칙"] = ex.fit(L["셈"], L["값"])
-    if price_at is not None:
-        L["종류"] = "단가줄"
-        pc = roles[price_at]["후보"]
-        L["비목"] = L["비목"] or (pc[0]["비목"] if len({p["비목"] for p in pc}) == 1 else None)
-        L["후보수"] = len({_ident(p) for p in pc})
-    elif any(r["갈래"] == "앞줄" for r in roles.values()):
-        L["종류"] = "참조줄"
-    else:
-        L["종류"] = "상수줄"
-
-
-def _value(L: dict, lines: list, results: list) -> None:
-    """값 줄 — 앞 결과 하나(자리 처리) 또는 바로 앞 돈 · 값 줄 이음 합."""
-    v, how = L["값"], None
-    for r in reversed(results):
-        rule = ex.fit(r[1], v)
-        if rule:
-            how = {"갈래": "복사", "줄": [r[0]], "규칙": rule}
-            break
-    if not how and flat(L["라벨"]) in ("계", "합계"):
-        got: dict[str, dict] = {}
-        for x in reversed(lines):
-            c = x.get("비목")
-            if c and x.get("꼴") in ("돈", "값") and c not in got:
-                got[c] = x
-            if len(got) == 3:
-                break
-        if got:
-            rule = ex.fit(sum(x["값"] for x in got.values()), v)
-            if rule:
-                how = {"갈래": "합", "줄": sorted(x["차례"] for x in got.values()), "규칙": rule}
-    if not how:
-        acc, used = 0.0, []
-        for x in reversed([x for x in lines if x.get("꼴") in ("돈", "값")]):
-            if len(used) >= 25:
-                break
-            acc += x["값"]
-            used.append(x["차례"])
-            rule = ex.fit(acc, v)
-            if rule and len(used) > 1:
-                how = {"갈래": "합", "줄": used[::-1], "규칙": rule}
-                break
-    L["종류"] = "값줄"
-    L["숨은"] = how
-    L["규칙"] = how["규칙"] if how else None
-
-
-def _var(L: dict) -> None:
-    segs = L.pop("조각")
-    m = re.match(r"^\s*(" + NUMRE + r")", segs[-1]) if len(segs) > 1 else None
-    if not m:
-        L["종류"] = "변수글"
-        return
-    shown, toks = num(m.group(1)), None
-    for seg in reversed(segs[1:-1]):
-        toks = tokens(seg)
-        if toks:
-            break
-    L["값"] = shown
-    L["규칙"] = ex.fit(calc(ex.parse(toks)), shown) if toks else None
-    L["종류"] = "변수식" if toks else ("변수값" if len(segs) == 2 else "변수기호")
-
-
-def parse_block(text: list[str], prices: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """블록 글 줄 → 복원 줄 목록(역할 · 숨은 합 · 자리 규칙 · 단가 정체)."""
-    by_value = collections.defaultdict(list)
-    for p in prices:
-        by_value[p["값"]].append(p)
-    lines: list[dict[str, Any]] = []
-    results: list[tuple] = []  # (차례, 값, 비목)
-    for k, raw in enumerate(text):
-        L = {"차례": k, "원글": raw, **parse_line(raw)}
-        if L["꼴"] == "돈":
-            _money(L, by_value, results)
-            results.append((k, L["값"], L["비목"]))
-        elif L["꼴"] == "값":
-            _value(L, lines, results)
-            results.append((k, L["값"], L["비목"]))
-        elif L["꼴"] == "변수":
-            _var(L)
-        lines.append(L)
-    identify(lines)
-    return lines
-
-
-def identify(lines: list[dict[str, Any]]) -> None:
-    """단가 토큰 정체 — 값 하나 · 기계 세 줄 겹침 · 문맥(라벨 · 머리 글 이름) · 남으면 모호 표지."""
-    head = ""
-    for L in lines:
-        if L["꼴"] in ("글", "글끝") or _HEADING.match(L["원글"]):
-            head = L["원글"]
-        if L.get("종류") != "단가줄":
-            continue
-        role = next(r for r in L["역할"].values() if r["갈래"] == "단가")
-        cands = role["후보"]
-        ids = {_ident(p) for p in cands}
-        how = "값"
-        if len(ids) > 1 and cands[0]["종류"] in ("기계", "산근"):
-            k0, inter = L["차례"], set(ids)
-            for M in lines[max(0, k0 - 3) : k0 + 4]:
-                if M is L or M.get("종류") != "단가줄":
-                    continue
-                r2 = next(r for r in M["역할"].values() if r["갈래"] == "단가")
-                ids2 = {_ident(p) for p in r2["후보"]}
-                if ids2 & inter and len(ids2 & inter) < len(inter):
-                    inter &= ids2
-            ids, how = inter, "기계 세 줄"
-        if len(ids) > 1:
-            ctx = flat(L["원글"]) + "|" + flat(head)
-            hit = {x for x in ids if x[1] and (x[1] in ctx or x[1][:3] in ctx)}
-            ids, how = ({x for x in hit if not x[2] or x[2] in ctx} or hit or ids), "문맥"
-        role["모호"] = len(ids) != 1
-        role["갈림"] = how
-        role["남은"] = len(ids)
-        pick = sorted(ids)[0]
-        p = next(p for p in cands if _ident(p) == pick)
-        role["정체"] = {"종류": p["종류"], "이름": p["이름"], "규격": p["규격"], "비목": p["비목"]}

M02_MasterTemplete/M02_San_Eval.py

@@ -7,9 +7,8 @@ STmate 셈 규칙(`_분석_649-G2` 1 장) — 줄 금액 = 단가 × (계수 + 1
 T% = 바로 앞 계표시 값 × 수량 · 계표시 = 아래 단 누계 · `(-=)` = 찍되 위 합에서 뺌 ·
 `->` = 번지엔 쌓되 합에서 뺌 · 블록 끝전 두 갈래(비목 버림 / 계 버림 + 큰 나머지) ·
 결과금액 조정(SBM = 계를 한 비목으로) · 계약단가 = 비목 × 낙찰률 원 버림.
-EST 셈 규칙(같은 문서 2 장) — 줄 = 복원 식(단가 · 앞줄 결과 · 상수) → 줄 자리 속성 ·
-값 줄 = 숨은 복사 · 합 → 자리 속성 · 블록 성분 = 그 값을 낸 마지막 줄.
-단가 바뀜 전파 — STmate = 단가 dict 를 바꿔 다시 셈 · EST = `run_est(lines, {정체 열쇠: 새 값})`.
+단가 바뀜 전파 — 단가 dict 를 바꿔 다시 셈. 옛 EST 엑셀 셈 · 엑셀 검산(`run_est` · `est_check` ·
+`stmate_check`)은 812-1 엑셀 읽기기로 걷음(EST = `M02_Doc_NativeEst`).
 """
 
 from __future__ import annotations
@@ -22,7 +21,6 @@ from M02_MasterTemplete import M02_San_Expr as ex
 
 COMPS = ("L", "M", "S")
 SPECIAL = ("L%", "M%", "S%", "T%")
-TOL_LINE = 0.05
 
 
 def _zero() -> dict[str, float]:
@@ -179,115 +177,3 @@ def stmate_block(block: dict, nodes: list[dict], prices: dict, rule: str) -> dic
         fin = {c: math.floor(round(kye[c] * nag / 100, 6)) for c in COMPS}
         fin["T"] = fin["L"] + fin["M"] + fin["S"]
     return {"줄": lines, "합": tot, "계": kye, "금액": fin, "낙찰": nag}
-
-
-def stmate_check(block: dict, result: dict) -> dict[str, Any]:
-    """줄마다 · 블록 검산 — 금액 줄(참조 · 율 · 특수) C~F 대조 · 계표시 줄 · 블록 머리 · 꼬리 계."""
-    bad, n_amt, n_tot, ok_tot = [], 0, 0, 0
-    for r, ln in zip(result["줄"], block["몸"], strict=True):
-        want = {"L": ln["D"] or 0, "M": ln["E"] or 0, "S": ln["F"] or 0}
-        if r["종류"] in ("참조", "율", "특수"):
-            n_amt += 1
-            if not r["값"] or any(abs(r["값"][c] - want[c]) >= TOL_LINE for c in COMPS):
-                bad.append({"행": ln["행"], "엑셀": want, "셈": r["값"], "오류": r["오류"]})
-        elif r["종류"] == "계" and ln["C"] is not None:
-            n_tot += 1
-            ok_tot += all(abs(r["값"][c] - want[c]) < 0.15 for c in COMPS)
-    head = block["머리"]
-    want = {"T": head["C"] or 0, "L": head["D"] or 0, "M": head["E"] or 0, "S": head["F"] or 0}
-    kye = next((t for t in block["꼬리"] if t["A"] == "계"), None)
-    want_k = {"T": kye["C"], "L": kye["D"], "M": kye["E"], "S": kye["F"]} if kye else None
-    same = lambda x, y: all(abs((x[k] or 0) - (y[k] or 0)) < 0.5 for k in "TLMS")  # noqa: E731
-    ok = same(result["금액"], want) and (want_k is None or same(result["계"], want_k))
-    return {
-        "맞음": ok,
-        "엑셀": want,
-        "엑셀계": want_k,
-        "금액줄": n_amt,
-        "틀린줄": bad,
-        "계줄": n_tot,
-        "계줄맞음": ok_tot,
-    }
-
-
-# ── EST ────────────────────────────────────────────────────────────────
-def key_of(ident: dict[str, Any]) -> tuple:
-    """EST 단가 정체 → 전파 열쇠 (종류, 이름, 규격, 비목)."""
-    return (ident["종류"], ident["이름"], ident["규격"], ident["비목"])
-
-
-def run_est(lines: list[dict], newp: dict[tuple, float] | None = None) -> dict[int, float | None]:
-    """복원 줄 → {차례: 다시 셈 값}(줄 자리 속성 그대로) · newp = {정체 열쇠: 새 단가}."""
-    newp = newp or {}
-    val: dict[int, float | None] = {}
-    for L in lines:
-        k = L["차례"]
-        if L.get("꼴") == "돈" and L.get("규칙"):
-            sub = {}
-            for i, r in L["역할"].items():
-                if r["갈래"] == "단가" and key_of(r["정체"]) in newp:
-                    sub[i] = newp[key_of(r["정체"])]
-                elif r["갈래"] == "앞줄" and val.get(r["줄"]) is not None:
-                    sub[i] = val[r["줄"]]
-            v = _est_calc(L["식"], sub)
-            val[k] = ex.RULE[L["규칙"]](v) if v is not None else None
-        elif L.get("종류") == "값줄" and L.get("숨은"):
-            how = L["숨은"]
-            s = sum(
-                (val.get(j) if val.get(j) is not None else lines[j]["값"]) or 0 for j in how["줄"]
-            )
-            val[k] = ex.RULE[how["규칙"]](s)
-    return val
-
-
-def _est_calc(node: tuple, sub: dict) -> float | None:
-    try:
-        return ex.value(node, {"V": {}, "sub": sub})
-    except ex.ExprError:
-        return None
-
-
-def designate(lines: list[dict], want: dict[str, float]) -> dict[str, Any]:
-    """블록 성분(총괄표) → 그 값을 낸 줄(마지막 · 라벨 비목 우선) · 0 = 「영」 · 없음 = None."""
-    out: dict[str, Any] = {}
-    kinds = ("단가줄", "참조줄", "상수줄", "값줄")
-    for c in COMPS:
-        w = want[c]
-        if not w:
-            out[c] = "영"
-            continue
-        cand = [L for L in lines if L.get("종류") in kinds and abs(L["값"] - w) < ex.EPS]
-        pick = [L for L in cand if L.get("비목") == c] or cand
-        out[c] = pick[-1]["차례"] if pick else None
-    return out
-
-
-def est_block(lines: list[dict], des: dict[str, Any], newp: dict | None = None) -> dict[str, Any]:
-    """성분 줄 → 블록 금액(성분 원 버림 · 계 = 합) · 줄 값."""
-    val = run_est(lines, newp)
-    raw = {
-        c: (0.0 if k == "영" else (val.get(k) if k is not None else None)) for c, k in des.items()
-    }
-    if any(v is None for v in raw.values()):
-        return {"줄": val, "성분": raw, "금액": None}
-    fin = {c: math.floor(round(raw[c], 6)) for c in COMPS}
-    fin["T"] = fin["L"] + fin["M"] + fin["S"]
-    return {"줄": val, "성분": raw, "금액": fin}
-
-
-def est_check(lines: list[dict], want: dict[str, float]) -> dict[str, Any]:
-    """블록 검산 — 다시 셈 성분 = 총괄표 · 줄마다 보인 값 대조(돈 · 값 줄)."""
-    des = designate(lines, want)
-    got = est_block(lines, des)
-    val = got["줄"]
-    n, bad = 0, []
-    for L in lines:
-        if L.get("꼴") == "돈" or L.get("종류") == "값줄":
-            n += 1
-            v = val.get(L["차례"])
-            if v is None or abs(v - L["값"]) >= ex.EPS:
-                bad.append({"차례": L["차례"], "글": L["원글"].strip(), "보인": L["값"], "셈": v})
-    fin = got["금액"]
-    ok = fin is not None and all(abs(fin[c] - want[c]) < 0.5 for c in COMPS)
-    ok = ok and abs(want["L"] + want["M"] + want["S"] - want["T"]) < 0.5
-    return {"맞음": ok, "성분줄": des, "금액": fin, "줄수": n, "틀린줄": bad}

M02_MasterTemplete/M02_San_Xlsx.py

@@ -141,8 +141,9 @@ def resources(sheets: dict[str, list]) -> dict[str, list[dict[str, Any]]]:
         got = []
         for one in _table(sheets.get(sheet) or [], ()):
             r = list(one["줄"]) + [None] * 30
-            vals = {k: float(v or 0) for k, v in book.applied(r).items()}
-            got.append({**_drop(one), "표": sheet, "값": vals})
+            vals, note = book.applied_how(r)
+            vals = {k: float(v or 0) for k, v in vals.items()}
+            got.append({**_drop(one), "표": sheet, "값": vals} | ({"칸": note} if note else {}))
         out[kind] = got
     return out
 

M02_MasterTemplete/M02_San_Xlsx_Est.py

@@ -300,6 +300,45 @@ class Lines:
         self.plain(ln)
         return self.done(ln)
 
+    def sections(self, saved: dict) -> None:
+        """절 소계(가 · 나 … 머리 아래 합계 줄 「노무비 : a + b = X」)가 뺀 줄 하나 = 합에 안 든 줄(비목 없음) —
+        절(앞 숫자 머리부터) 안 그 비목 줄 결과 합 − X 가 꼭 한 줄 값이고 나머지 줄 값은 모두 덧셈 글에 있을
+        때만 · 블록 금액도 그 줄을 빼야 맞을 때만(엑셀 글 덧셈 · 원파일 SCheck 0)."""
+        lines, start = self.lines, 0
+        for i, ln in enumerate(lines):
+            text = ln["보임"]
+            if ln["단"] == 1 and re.match(r"^\s*\d", text):
+                start = i
+            if not (ln["합계"] and ln["비목"] in ("L", "M", "S") and ln["결과"] and "+" in text):
+                continue
+            head = next((k for k in range(i - 1, start - 1, -1) if lines[k]["단"] == 1), None)
+            if head is None or not re.match(r"^\s*[가-하]", lines[head]["보임"]):
+                continue
+            part, want = ln["비목"], ln["결과"][-1]
+            kids = [
+                x for x in lines[start:head] if x["비목"] == part and x["결과"] and not x["합계"]
+            ]
+            kids += [
+                x for x in lines[start:head] if x["비목"] == part and x["줄참조"] and not x["결과"]
+            ]
+            value = {id(x): (x["결과"] or x["줄참조"])[-1] for x in kids}
+            extra = sum(value.values()) - want
+            odd = [x for x in kids if abs(value[id(x)] - extra) < 0.5]
+            colon = _COLON.search(text)
+            adds = [v for _, _, v in _nums(text, colon.end() if colon else 0, text.rfind("="))]
+            rest = [value[id(x)] for x in kids if odd and x is not odd[0]]
+            listed = all(any(_close(v, a) for a in adds) for v in rest)
+            if len(odd) != 1 or abs(extra) < 0.5 or not listed:
+                continue
+            every = sum(
+                (x["결과"] or x["줄참조"])[-1]
+                for x in lines
+                if x["비목"] == part and not x["합계"] and (x["결과"] or x["줄참조"])
+            )
+            block = float(saved.get(part) or 0)  # 블록 금액이 그 줄을 빼야 맞을 때만
+            if abs(every - block) >= 1 and abs(every - extra - block) < 1:
+                odd[0]["비목"] = None
+
     def unused(self) -> None:
         """머리 아닌 줄의 기계 이름 — 아래 세 줄이 안 쓰면 글 줄(설명 속 장비 이름)."""
         for h in self.heads:
@@ -597,10 +636,13 @@ def read(sheets: dict[str, list]) -> dict[str, Any]:
         }
         if not one:
             tags.append(f"{sx.NOTE}총괄표에 단산{b['번']} 없음")
+        elif one.get("칸"):  # 총괄표 당초 / 적용 칸(797-1a)
+            tags.append(f"참고 · {one['칸']}")
         work = Lines(look, tags)
         for src in b["줄"]:
             work.run(src)
         work.unused()
+        work.sections(head["저장"] or {})
         lines = []
         for ln in work.lines:
             marks = ln.pop("_marks")

M02_MasterTemplete/M02_San_Xlsx_Stmate.py

@@ -59,7 +59,14 @@ def read(sheets: dict[str, list]) -> dict[str, Any]:
         head = {"코드": blk["코드"], "이름": blk.get("이름") or me.get("이름")}
         head |= {"규격": me.get("규격"), "단위": me.get("단위"), "저장": _amt(blk["머리"])}
         _, tot = ev.run_stmate([ln["풀이"] for ln in lines], prices)
-        out["산근"].append({**head, "줄": lines, "줄합": tot, "표지": tags, "엑셀행": blk["행"]})
+        body = [{k: ln.get(k) for k in ("행", "B", "C", "D", "E", "F")} for ln in blk["몸"]]
+        out["산근"].append(
+            {**head, "줄": lines, "줄합": tot, "표지": tags, "엑셀행": blk["행"]}
+            | {
+                "몸": body,
+                "꼬리": blk["꼬리"],
+            }  # 엑셀 줄 금액 · 계 꼬리(검산 · `M02_San_Emit.stmate`)
+        )
     rule, got = vote(out["산근"], prices)
     out["옵션"] = {"SAN_TYP": RULE[rule]}
     out["내역"] = None

M02_MasterTemplete/logic/M02_Sangeun_Match.ts

@@ -3,6 +3,7 @@
  * 가져온 식 ↔ 우리 M01 기초 연결 판정 띠 자료(PLAN 810-4 · 요구 707 · 709 · 703) — 원문 패널 카드 위.
  *   SK `가져온.원본.연결후보`(서버 `M02_Doc_Match` 가 적음) → 띠 글 · 다른 항 · 단추 하나:
  *     확정 = [우리 기초 사본으로 바꾸기] · 근접 · 없음 = 단추 없음(703) · 안 찾음 = [연결 찾기] ·
+ *     다른 항 = 로직 차이(확정을 막음) · 참고 = 단가 · 끝수 · 율 값 %(값 차이 — 「우리 단가로 셈 ○○ 원」 · 812-2 · 812-4) ·
  *     바꾼 SK(`가져온보관` 있음) = 「우리 기초 사본 ○○」 + [가져온 식으로 되돌리기]
  *   화면 · DOM · fetch 없음
  * ========================================================================== */
@@ -15,6 +16,8 @@ export interface MatchFound {
   이름?: string;
   옵션?: Record<string, string>;
   다른?: { 항: string; 글: string }[];
+  /** 값 차이(단가 · 끝수 · 율 값) — 확정을 안 막음 */
+  참고?: { 항: string; 글: string }[];
   금액?: { 가져온?: Record<string, number | null>; 우리?: Record<string, number | null> };
   후보수?: number;
   가까움?: { 키?: string; 이름?: string; 다른?: { 항: string; 글: string }[] };
@@ -44,6 +47,23 @@ const opts = (o?: Record<string, unknown>): string => {
 const lines = (d?: { 항: string; 글: string }[]): string[] =>
   (d ?? []).map((x) => `${x.항} — ${x.글}`);
 
+const won = (n?: number | null): string =>
+  n == null ? "" : `${Math.round(n).toLocaleString("ko-KR")} 원`;
+/** 참고 요약 — 「참고: 단가 다름 3 줄 · 율 값 다름 1 줄 · 우리 단가로 셈 53,218 원」 · 참고 없음 = "" */
+const noteText = (f: MatchFound): string => {
+  const n = f.참고 ?? [];
+  if (!n.length) return "";
+  const price = n.filter((x) => x.항 === "단가 차이").length;
+  const rate = n.filter((x) => x.항 === "율 값").length;
+  const bits = [
+    price ? `단가 다름 ${price} 줄` : "",
+    rate ? `율 값 다름 ${rate} 줄` : "",
+    n.some((x) => x.항 === "끝수") ? "끝수 다름" : "",
+  ].filter(Boolean);
+  const ours = won(f.금액?.우리?.계);
+  return ` · 참고: ${bits.join(" · ")}${ours ? ` · 우리 단가로 셈 ${ours}` : ""}`;
+};
+
 /** SK → 띠 자료 · 가져온 식도 · 바꾼 SK 도 아니면 null */
 export function matchBand(sk: SkLike | null | undefined): MatchBand | null {
   const kept = sk?.가져온보관;
@@ -64,8 +84,8 @@ export function matchBand(sk: SkLike | null | undefined): MatchBand | null {
   if (f.판정 === "확정") {
     return {
       tone: "success",
-      text: `우리 기초 ${base} 와 확정 일치`,
-      details: [],
+      text: `확정 — 로직 같음 · 우리 기초 ${base}${noteText(f)}`,
+      details: lines(f.참고),
       action: "바꾸기",
     };
   }
@@ -73,8 +93,8 @@ export function matchBand(sk: SkLike | null | undefined): MatchBand | null {
     const kinds = [...new Set((f.다른 ?? []).map((x) => x.항))].join(" · ");
     return {
       tone: "warning",
-      text: `근접 — ${base} · 다른 항: ${kinds}`,
-      details: lines(f.다른),
+      text: `근접 — ${base} · 다른 항: ${kinds}${noteText(f)}`,
+      details: [...lines(f.다른), ...lines(f.참고).map((x) => `참고 ${x}`)],
       action: null,
     };
   }

common_util/common_util_line_stack.ts

@@ -150,10 +150,11 @@ export function sourceOf(doc: FormulaDoc, v: DocVar): string | null {
   return String((v as { 출처?: string }).출처 ?? (head.원파일 ? "원파일" : "엑셀"));
 }
 
-/** 차림에 안 넣는 기호 — 옵션 · 금액 줄이 가진 연결 · 가져온 식 값 옵션 칸 */
+/** 차림에 안 넣는 기호 — 옵션 · 금액 줄이 가진 연결(가져온 식 값 옵션 칸은 공식 묶음에도 보임 · 같은 값 · 812-3)
+ *  파이썬 거울 = `M02_Doc_NativeLayout.py`(stackOf · saveOf · hiddenOf · 가져온 단가산출 차림) — 고칠 때 같이 고침 */
 export function hiddenOf(doc: FormulaDoc): Set<string> {
   const out = new Set(ownedOf(doc).values());
-  for (const v of doc.변수 ?? []) if (isOption(v) || sourceOf(doc, v)) out.add(varId(v));
+  for (const v of doc.변수 ?? []) if (isOption(v)) out.add(varId(v));
   return out;
 }
 

docs/raw/요구_1104/사용자요구_1104.md

@@ -561,3 +561,179 @@ M01은 지금 상당히 잘 개발이 되었어. 일위대가 불러오기의
 ## 요구 712 (11-09 · 사용자 · 매칭은 로직으로(돈만 보지 말 것) · 권장 순서 뒤 정합성 추정 · 엑셀 엔진 새로 짜는 게 나은지)
 
 결국 전부 단가산출을 제대로 연결할 수 있어야한다인데. 결과적으로 단가산출은 로직과 값으로 되어있음. 경쟁사도 값은 주기적으로 업데이트 됨. 그렇다면 매칭해야하는 자료는 로직임. 단순히 총합계나 계산된 돈만 보면 판단이 어려워지니 조심할 것. 다음으로 권장 순서대로 했을때 정합성이 어느정도 될것같아? 그리고 현 엑셀엔진을 처음부터 코드를 만드는게 더 효율적이고 체계적일 것 같다는 생각이드는데 어떻게 생각함?
+
+## 요구 713 (11-09 · 사용자 · 제안대로 진행(엑셀 읽기기 새로 + 연결 기준 = 로직) · 가져온 단가산출이 좌측에서 읽히게(나열만 X))
+
+다음으로 중요한 점은 경쟁사의 단가산출을 가져왔다 가정하고 현재의 경쟁사 단가산출은 좌측영역에서 제대로 읽기가 힘든 그냥 노무비, 경비, 재료 1,2, 3 형태로 죽 나열만 되어있음. 분석도 중요하지만 보여지는것도 중요함. 너의 제안대로 잘 끝까지 진행해줘
+
+## 요구 714 (11-09 · 사용자 · 판단 셋 답 — 1 보류 · 2-1 율 값 = 값(로직 아님) · 2-2 기계 이름 = 별칭 조사 · 3 1 원은 로직만 맞으면 됨)
+
+1번은 생각할 시간이 필요.
+2-1번 율값 관련 내가 로직과 값을 구분하라고 했잖아. 로직은 어떤 계산을 할때 뭐를 곱하는지 뭐를 더할지 같은 것들이고 여기에 사용된 값은 결국 언제든 업데이트 될수 있다고 불러오기 기능들에서에서 초기에 검산을 위해서는 겂을 사용하겠지만 결국은 우리의 m01의 값을 사용할 수 있어야해. 그게 현재 m02의 단가산출에 있는 값 업데이트 기능이고 이해해?
+2-2번 기계 이름이 다를경우 별칭을 사용하는게 어떨까해. 우리는 품셈원문의 이름을 사용하고 있기도 하고 m01 단가산출에도 별칭으로 경쟁사와 정보가 다를경우 승인하고 별칭으로 등록하는게 있잖아. 조사해봐
+3. 1원 차이는 로직만 맞다면 문제 없음.
+
+## 요구 715 (11-09 · 사용자 · 수량 추가 설명 요청 · 1번 계속 대기 · 기계 230 블록 뜻 물음)
+
+수량 관련은 추가 설명 요청
+
+1번 계속 대기
+2번 기계 230 블럭은 경쟁사 프로그램에서 만들어둔 기계의리스트라는 말임?
+
+## 요구 716 (11-09 · 사용자 · 하나씩 — 기계 230 블록: 굴삭기 0.7 = 바스켓 크기 · 기계 옵션값 변경 또는 미리 만들어 두기 · 확인부터)
+
+일단 하나씩 하자. 기계230블럭에서 굴삭기 0.7에서 0.7은 바스켓의 사이즈로 보이는데 기계의 옵션값 변경을 하면 되는거 아닌가? 아니면 미리 만들어 두던가 확인부터 해봐.
+
+## 요구 717 (11-09 · 사용자 · 우리 단가산출에서 기계 · 옵션 변경이 안 되는 게 문제 — 기계가 들어오면 상단 옵션에 기계 선택 · 하위 옵션 · 그 뒤 연결 찾기 방향 · 확인부터)
+
+1. 그것보다 중요한 건 우리 단가산출에서 기계를 변경하거나 옵션을 변경하는게 안되는게 문제아니야? 그렇다면 기계가 단가산출에 들어오면 상단 옵션에 기계선택이나 하위 옵션선택이 되어야하는거 아닌가?
+2. 그리고 나서 연결찾기의 방향이 결정될것같은데?
+3. 확인부터 해봐.
+
+## 요구 718 (11-09 · 사용자 · 기계 줄 누르면 목록이 나옴 → 옵션 없어도 됨 · 문제는 연결을 못 찾는 것 · 조회어 「굴착기(무한궤도) 0.7㎥」 가 문제 아닌지 · 기계 못 연결하는 이유 다시 확인)
+
+지금 확인했는데 좌측영역에서 기계 줄에서 지정된 기계를 눌렀더니 옵션 별로 항목 리스트가 나오는데 이러면 옵션이 없어도 되는거잖아. 그럼 문제는 옵션 여부가 아니라 연결을 제대로 찾지 못하는게 아닌가? 그리고 추가로 좌측영역 기계를 눌렀을때 굴착기(무한궤도) 0.7㎥ 이렇게 조회를 하는데 이게 문제 아니야? 기계를 못 연결하는 이유를 다시 확인해봐.
+
+## 요구 719 (11-09 · 사용자 · 기계 예들 직접 찾아 보니 대형 브레이커 + 굴착기 빼고 다 찾을 수 있음 · 옛 이름은 별칭 사용 가능 · 조합 기계 = 설비 둘을 각각 가져오기)
+
+너의 알려준 낱말을 모르는 예와 후보가 여럿인 예를 내가 직접찾아 봤는데 대형 브레이커 + 굴착기 만 제외하면 다 려었이 아니라 다찾을 수 있겠는데? 그리고 경쟁사 프로그램이 예전프로그램이라 찾기 힘들면 별칭을 사용해도됨. 다음으로 2개의 기계의 조합을 대현 브레이커, 굴착기로 표현한게 아닐까? 우리는 설비 2개를 각각 가져오면 맞을 것같다는 생각이 드네.
+
+## 요구 720 (11-09 · 사용자 · 수정을 어떻게 요청했는지 물음)
+
+뭐지 어떻게 수정을 요청한거야?
+
+## 요구 721 (11-09 · 사용자 · 작업 이어서 · 기계 · 옵션 때문에 품셈 원문 제목과 다르게 표현된 단가산출 기초 조사 — 200 개쯤 예상 · 1,300 → 1,500 늘어난 까닭)
+
+같은 기종인데 규격만 다른 경우은 지금의 수정으로 가능한거 아니야?
+
+1. 작업은 이어서 진행, 문제는 없어보임.
+2. 우리의 단가산출은 기계나 특정 옵션에 의해 품셈 원문 제목과는 다르게 표현된 항목들이 거기에 해당 될것 같은데. 그것때문에 제대로 연결이 안되는게 아닐까? 어떤게 있는지 먼저 조사가 필요해봐. 그렇다 하더라도 품셈원문 제목에 품셈원문 제목이 있다면 모를까 하지만 제목에 기계가 들어가는 경우는 드물것같아. . 내가 예상하기로는 200개 정도 될것같은데 확인해봐. 이전에는 1300개정도에서 갑자기 1500개로 단가산출 기초가 늘었거든.
+
+## 요구 722 (11-09 · 사용자 · 기초 이름 정리 방향 다섯 — 수정 말고 대답만 · 방향성부터)
+
+1. 제목 + 옵션, 조건 덧말은 조심해야 원문제목과 대조할 필요가 있어보임
+2. 제목과 다르지만 분기가 필요해 셋으로 나눈건 괜찮음.
+3. 보조문서는 기계와 연계된 정보이니 단가산출이 아닌걸로 봐야하는게 아닌지. 자동으로 연결될 것같은데?
+4. 기계 이름이 품셈 제목에 없는데붙는 경우는 수정해야 될것같음. 
+5. 위에처럼 정리하고 나면 이름으로 구분안되는 정보들이 나올텐데 이때는 삭제하는게 맞겠지? 
+수정하지말고 대답해줘. 방향성 부터 봐야지.
+
+## 요구 723 (11-09 · 사용자 · 방향 다섯 동의(3 은 둘 자리 협의) · 원문 패널 md 경로 삭제 · [주] 글자 크기 반대로 · 반영 · 다시 조사 · 작업 이어서 — sub3 과 충돌 없으면 다른 워크트리에)
+
+1. 동의
+2. 동의
+3. 동의는 하나, 단가산출 기초 리스트에서 빼서 어디에 둘건지는 협의 필요
+4. 동의
+5. 동의
+추가로 
+6. 지금 단가산출의 우측 공통 원문 패널보기 내용 중에 md파일의 경로를 알려주고 있음. 이부분은 다른 워크트리에게 경로를 볼필요없으니 삭제해달라고 해줘. 
+7. 원문 패널의 내용 중 [주] 내용의 글자가 더크고 본문의 내용이 작음. 반대가 되는게 맞음.
+위 내용을 반영하고 다시 조사하고 작업을 이어서 하는데 너가 판단해보고 현재 작업중인 서브3과 충돌이 없다면 다른 워크트리에게 작업을 시키자.
+
+## 요구 724 (11-09 · 사용자 · 보조 문서를 단가산출 목록에서 빼면 어디에 둘지 의견 물음)
+
+단가산출 목록에서 빼면 어디다 두는게 좋을것같아?
+
+## 요구 725 (11-09 · 사용자 · 보조 문서 자리 = 권장으로 해도 될 듯 · 조사해 맞는지 먼저 보고 판단 · 「정할 것」 설명 필요)
+
+1. 권장으로 해도 될것같음. 하지만 조사해보고 맞는 먼저 보고 판단하자. 
+ 2. 정할것에 대한 설명이 필요.
+
+## 요구 726 (11-09 · 사용자 · 전용 작업량도 기계 항목으로 · 작업량당 기계경비 예시 요청 · 기계 무관 = 제안대로 · 토사절취(백호 0.7㎥) 대화창 출력 · 1~4 한 번에 진행 예정 — 일단 대기)
+
+1. 전용 일지라도 결과적으로는 다른곳에서 사용할수도 있으니 기계라면 당연히 기계항목으로 들어가는게 맞아보임. 현재는 하나지만 나중에는 늘어날수도 있잖아. 
+2. 작업량당 기계경비는 어떤걸말하는것임? 예를 들어 보여줘. 
+3. 기계무관은 너의 제안대로 
+4. 토사절취(백호 0.7㎥) 단가산출을 대화창에 출력해줘. 
+5. 1~4번은 한번에 진행할 생각이야. 그러니 일단대기하고 4번을 대화창에 출력
+
+## 요구 727 (11-09 · 사용자 · 토사절취 예시의 문제가 무엇인지 물음 — 시간당이 아니라 단위당으로 나오는 것이 문제냐)
+
+이게 뭐가 문제야? 원래는 기계의 돈은 시간당으로 나와야하는데 단위면적당으로 나온다는 거야?
+
+## 요구 728 (11-09 · 사용자 · 신규 단가산출에 기계 하나만 지정하면 작업량당 기계경비와 같은 것)
+
+아니 그러니까 내가 만약에 신규 단가산출을 만들고 거기에 기계만 하나 지정하면 같은게 되는거잖아.
+
+## 요구 729 (11-09 · 사용자 · 결국 표현 단위 차이 — 단위 환산 로직을 단가산출 기초에 두는 게 맞지 않나)
+
+결국은 표현의 단위차이라는 말 아니야? 그렇다면 표현하는 단위 환산로직을 단가산출 기초에 넣어두는게 더 맍지 않아?
+
+## 요구 730 (11-09 · 사용자 · 표로 다시 · 짧게)
+
+테이블로 다시 표현해봐 . 이해하기 힘들어. 짧게 설명해줘.
+
+## 요구 731 (11-09 · 사용자 · 나눔 맞는 것 같음 · 단가산출 기초 화면의 공식 틀 추가는 필요 없어진 것인지)
+
+맞는것같네. 그럼 이제 단가산출 기초화면에서 공식 틀 추가는 필요없어진 것임?
+
+## 요구 732 (11-09 · 사용자 · 「식」으로 변경 · 작업 진행 · 진행 뒤 엑셀 불러오기에서 더 결정할 것 알려 달라)
+
+식으로 변경하자. 이제 작업 진행하자.
+진행 후 엑셀불러오기와 관련하여 뭐를 더 결정해야하는지 알랴줘.
+
+## 요구 733 (11-09 · 사용자 · 결정 목록 여섯에 대한 답 · 물음 + 드래그 그룹 이동 확인 — 수정 아님 · 조사부터)
+
+1. 이유 짧게 설명
+2. 규격이 다른 같으 기종의 경우 가져온 걸로 우리의 기계값을 바꾸면 되는거 아닌지.
+3. 반올림 자리만 다른 경우 계산에는 정밀도 높게 계산하는지 확인하고 계산에 문제 없다면 확정. 품숫자가 다른 4개라는건 뭔지 짧게 설명
+4. 작업량 당 기계경비의 경우에는 단가산출이 어떤식으로 제목이 나오는지 확인. 기계만 있는 단가산출도 필요는 해보이는데 문제는 우리의 단가산출은 자유롭게 기계를 변경할 수 있음. 그렇다면 만약 단가산출 기초 제목으로 M02에서 찾을텐데 이때 기계명이 있는 이름의 단가산출이 있다면 사용자는 해당 단가산출 정보만 있을것으로 오해할것이기 때문에 6개의 단가산출이 기계명으로만 구분되어 있는 단가산출이라면 그냥 통합도 가능할 것으로 예상되어 물어봄(수정하라는 말은 아님)
+5. 별칭 승인의 승인요청 시점이 사용자들이 저장하여 단가산출을 저장한 시점으로 보이는데 맞음? 그리고 별칭은 있어야 되는건 맞는데 혹시 경쟁사 프로그램의 출력물로 찾을 경우 이제 빈도가 줄었을 것으로 보임. 어느정도 수준인 확인
+6. 굴삭기 + 브레이카 는 사용자가 그룹 구분 없이 사용한다면 한 덩이로 그룹으로 구분한다면 자동으로 구분되겠지. 일반적으로는 구분되게 사용하는게 맞는것같음.
+7. 드래그로 그룹이동 되는지 확인
+바로 수정작업 아님. 조사부터 진행.
+
+## 요구 734 (11-09 · 사용자 · 결정 답 — 소계는 우리 양식 · 수량 끝자리 뜻 물음 · 품 숫자 = 우리 값이 최신(가져오면 우리 값) · 작업량당 기계경비 단가산출 불필요 의견 물음 · 별칭 8 목록 요청(초기 별칭 직접 · 승인까지) · 6 · 7 문제 없음 · 1~5 한 번에 진행 예정 — 먼저 대답)
+
+1. 소계는 결국 항목들의 합계형식일 뿐 우리양식 맞춰 표기해도 문제 없을것같다는 생각이 듬. 
+2. 수량 끝자리라는게 뭐임?
+3. 품 숫자가 다르다는건 결국 품셈이나 요소들에 지정된 값이 다르다라는 의미지? 그렇다면 우리가 더 최신이 맞음. 그래서 가져오기 전 비교할때는 해당정보로 계산하겠지만 가져오면 우리값으로 업데이트 되는게 맞다고 대답한 적이 있음. 그리고 만약 그래도 사용자가 이전값으로 사용하겠다면 우리 단가산출 양식에는 값변경을 할수 있으니 OK
+4. 작업량당 기계경비는 결국 이걸 활용하여 다른 단가산출들에서 사용하고 있는거잖아. 기계로 넣어서 사용하고 있는거잖아. 그렇다면 작업량당 기계경비라는 단가산출을 만들어둘 필요가 없어보이네 너의 생각은? 어차피 경쟁사 데이터 불러오기 기능에도 우리 단가산출 표현에 문제도 없을거고 있으면 되려 혼란을 줄것같아서 말이야. 
+5. 별칭 필요한 8개의 리스트를 보여주면 초기 별칭을 내가 넣어줄게. 승인처리까지 했으면 함. 
+6. 문제 없음.
+7. 문제 없음.
+1 ~ 5번은 한번에 진행할거야. 가능한 경우에는 다른 워크트리를 사용해도됨. 그러니 먼저 대답부터
+
+## 요구 735 (11-09 · 사용자 · 1~3 동의 · 작업량당 기계경비 = 필요하면 기계 하나 넣어 만들어 씀 · 별칭 아홉 답)
+
+1. 동의
+2. 동의
+3. 동의
+4. 작업량당 기계경비는 본인이 필요한 경우 기계하나만 넣고 만들어 사용하면 됨. 
+5. 별칭 확인
+ 1) 후보맞음.
+ 2) 나중에 내가 승인(어디 단가산출에 있는지 대화창에 출력)
+ 3) 후보맞음.
+ 4) 엔진(디젤) 이렇게 되어 있음. 가솔린은 엔진(가솔린)으로 되어 있음.
+ 5) 나중에 내가 승인(어디 단가산출에 있는지 대화창에 출력)
+ 6) 나중에 내가 승인(어디 단가산출에 있는지 대화창에 출력)
+ 7) 워터젯트 
+ 8) 나중에 내가 승인(어디 단가산출에 있는지 대화창에 출력)
+ 9) 후보맞음
+
+## 요구 736 (11-09 · 사용자 · 바이브레이터 규격이 하나면 엔진식)
+
+바이브 레이터에 규격은 하나임? 하나라면 엔진식이 맞음.
+
+## 요구 737 (11-09 · 사용자 · 남은 결정 사항 물음)
+
+남은 결정사항은 뭐가 있어?
+
+## 요구 738 (11-09 · 사용자 · 별칭 넷 = 단가산출 만들다 나오면 승인(할 일 없음) · 원문 패널 표 글자 16 · 제목 통합(그림 `요구738_원문패널_제목중복.png`) · 조합 기계 = 개별 그룹으로 · 공식 연결 분리 가능한지 조사 · 반영 뒤 단가산출 불러오기 정합성 확인)
+
+지금 정할 수 있는 것. 
+ 1. 지금 하겠다는게 아니라 단가산출을 만들면서 해당내용이 나오면 내가 승인하겠다는거야. 그러니 이제 너가 할 일은 없음.
+2 .표의 글자도 16으로 변경
+2-1. [Image #1]중복표기가 많음 제목을 통합해줘. 건설품셈 공통 7-1-1 메쌓기('12, '19, '26년 보완) 형태면 될것같음.
+위 내용도 같이 반영, 반영완료
+3. 조합기계는 우리 단가산출로 가져올때 개별 그룹으로 하나씩 가져오는게 좋을것같음. 
+4. 공식을 연결해야 단가가 나올것같은데 분리할 수 없을것같은데 조사
+5. 위내용까지 반영 후 일단 단가산출에 대한 불러오기 정합성 확인
+
+## 요구 739 (11-09 · 사용자 · 4 조사 결과 — 일단 현재 유지가 좋겠음 · 지금은 원문 기준으로 만든 품셈이 맞는지)
+
+4 조가결과에서 일단 현재를 유지하는게 좋을것같은데 일단 현재는 원문을 기준으로 만들어진 품셈이잖아.  맞지?
+
+## 요구 740 (11-09 · 사용자 · 현재 유지 범위 확인)
+
+현재 유지는 지금의 범위가 맞음

resources/master_data/_수식문서_틀.md

@@ -118,3 +118,14 @@
 - 끝수 결과 · 중간 `표시` → 식 안 `반올림` · 끝수 계 · 끝전 · 단계 · 조정 · 번지 · 합밖 · 자리 → 문서 칸 그대로.
 - 기호 = 수식 탭 기호(800-1 · 800-5) · 한 문서 안 겹침 = 아래첨자 끝 숫자.
 - 저장 = 대조(기본 옵션 + 옵션 표본)가 모두 같고 부르는 단가산출도 저장되는 문서만 · 다른 것 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`.
+
+## 9. 부품 표지(813-2) — 단가산출이 아닌 보조 문서
+
+- 머리 칸 `부품` = `{갈래, 기종?, 규격?}` · 옛 로직 줄 `부품` 을 변환이 그대로 옮김 · 셈 · 부르기 · 키로 열기는 그대로.
+- 단가산출 기초 목록 · 찾아 넣기 「다른 단가산출」 목록에 안 보임(`M01_MasterData_Parts.strip`).
+
+| 갈래 | 뜻 | 칸 | 자리 |
+| --- | --- | --- | --- |
+| 기계경비식 | 기계 시간당 경비 셈 방식(기계 줄이 부름) | — | M01 「기계」 기종 아래 |
+| 작업량 틀 | 기종 공식(Q = 3,600 × q × K × f × E ÷ Cm 등) | `기종` = 기계표 상세구분 목록 · `규격` = 기계 규격 수를 받는 변수 열쇠 | M01 「기계」 기종 아래 |
+| 계수식 | 기계 무관 · 돈 아닌 식 | — | M01 「계수」 아래 |

resources/master_data/_키대장.json

@@ -1,6 +1,6 @@
 {
   "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 337, "CC": 528, "GC": 1195, "QC": 2060, "GX": 5, "UA": 38},
-  "폐기": {"MT000001": "자재품목 휘발유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000002": "자재품목 경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000003": "자재품목 선박용경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000004": "자재품목 중유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000005": "자재품목 등유 — 값이 비고 글뿐 · 유가 테이블로 감", "LB000399": "이름 「〃」 — 직종이 아니라 되풀이 기호 · 소요량 13-6-9 에서 윗줄 직종으로 바로잡음", "MN": "재료_나라장터자재 — old 로 옮김 · 로직은 자재품목·품셈재료로 갈아 끼움", "LB000372": "미확보 고급기능사 — 측량노임 항공사진고급기능사 옛이름으로 옮김", "LB000393": "미확보 리베팅공 — 건설노임 철골공 옛이름으로 옮김(2010 통합표 연번10)", "LB000405": "미확보 Belt Conveyor 설치공 — 품셈 13-10-1 주② 배분으로 다섯 직종에 나눔", "MT000006": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "MT000007": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "LB000368": "미확보 기술사 — 기술사(건설) 옛이름으로 옮김", "LB000369": "미확보 특급기술자 — 특급기술자(건설) 옛이름으로 옮김", "LB000370": "미확보 고급기술자 — 고급기술자(건설) 옛이름으로 옮김", "LB000361": "미확보 중급기술자 — 중급기술자(건설) 옛이름으로 옮김", "LB000364": "미확보 초급기술자 — 초급기술자(건설) 옛이름으로 옮김", "LB000365": "미확보 고급숙련기술자 — 고급숙련기술자(건설) 옛이름으로 옮김", "LB000366": "미확보 중급숙련기술자 — 중급숙련기술자(건설) 옛이름으로 옮김", "LB000367": "미확보 초급숙련기술자 — 초급숙련기술자(건설) 옛이름으로 옮김", "LB000389": "미확보 기계기사 — 초급기술자(기계·설비) 옛이름으로 옮김", "LB000388": "미확보 기계산업기사 — 초급숙련기술자(기계·설비) 옛이름으로 옮김", "MO000055": {"원문번호": "주택용저압:기본_200이하", "파일": "재료_유가전력.json"}, "MO000056": {"원문번호": "주택용저압:기본_201~400", "파일": "재료_유가전력.json"}, "MO000057": {"원문번호": "주택용저압:기본_400초과", "파일": "재료_유가전력.json"}, "MO000059": {"원문번호": "주택용저압:전력량_다음200", "파일": "재료_유가전력.json"}, "MO000060": {"원문번호": "주택용저압:전력량_400초과", "파일": "재료_유가전력.json"}, "MO000061": {"원문번호": "주택용저압:월간최저요금", "파일": "재료_유가전력.json"}, "MO000062": {"원문번호": "일반용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000063": {"원문번호": "일반용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000064": {"원문번호": "일반용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000065": {"원문번호": "일반용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000066": {"원문번호": "산업용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000067": {"원문번호": "산업용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000068": {"원문번호": "산업용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000069": {"원문번호": "산업용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000070": {"원문번호": "임시전력갑:기본요금적용", "파일": "재료_유가전력.json"}, "MO000071": {"원문번호": "임시전력갑:전력량요금적용", "파일": "재료_유가전력.json"}, "MO000072": {"원문번호": "임시전력갑:월간최저요금", "파일": "재료_유가전력.json"}},
+  "폐기": {"MT000001": "자재품목 휘발유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000002": "자재품목 경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000003": "자재품목 선박용경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000004": "자재품목 중유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000005": "자재품목 등유 — 값이 비고 글뿐 · 유가 테이블로 감", "LB000399": "이름 「〃」 — 직종이 아니라 되풀이 기호 · 소요량 13-6-9 에서 윗줄 직종으로 바로잡음", "MN": "재료_나라장터자재 — old 로 옮김 · 로직은 자재품목·품셈재료로 갈아 끼움", "LB000372": "미확보 고급기능사 — 측량노임 항공사진고급기능사 옛이름으로 옮김", "LB000393": "미확보 리베팅공 — 건설노임 철골공 옛이름으로 옮김(2010 통합표 연번10)", "LB000405": "미확보 Belt Conveyor 설치공 — 품셈 13-10-1 주② 배분으로 다섯 직종에 나눔", "MT000006": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "MT000007": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "LB000368": "미확보 기술사 — 기술사(건설) 옛이름으로 옮김", "LB000369": "미확보 특급기술자 — 특급기술자(건설) 옛이름으로 옮김", "LB000370": "미확보 고급기술자 — 고급기술자(건설) 옛이름으로 옮김", "LB000361": "미확보 중급기술자 — 중급기술자(건설) 옛이름으로 옮김", "LB000364": "미확보 초급기술자 — 초급기술자(건설) 옛이름으로 옮김", "LB000365": "미확보 고급숙련기술자 — 고급숙련기술자(건설) 옛이름으로 옮김", "LB000366": "미확보 중급숙련기술자 — 중급숙련기술자(건설) 옛이름으로 옮김", "LB000367": "미확보 초급숙련기술자 — 초급숙련기술자(건설) 옛이름으로 옮김", "LB000389": "미확보 기계기사 — 초급기술자(기계·설비) 옛이름으로 옮김", "LB000388": "미확보 기계산업기사 — 초급숙련기술자(기계·설비) 옛이름으로 옮김", "MO000055": {"원문번호": "주택용저압:기본_200이하", "파일": "재료_유가전력.json"}, "MO000056": {"원문번호": "주택용저압:기본_201~400", "파일": "재료_유가전력.json"}, "MO000057": {"원문번호": "주택용저압:기본_400초과", "파일": "재료_유가전력.json"}, "MO000059": {"원문번호": "주택용저압:전력량_다음200", "파일": "재료_유가전력.json"}, "MO000060": {"원문번호": "주택용저압:전력량_400초과", "파일": "재료_유가전력.json"}, "MO000061": {"원문번호": "주택용저압:월간최저요금", "파일": "재료_유가전력.json"}, "MO000062": {"원문번호": "일반용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000063": {"원문번호": "일반용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000064": {"원문번호": "일반용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000065": {"원문번호": "일반용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000066": {"원문번호": "산업용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000067": {"원문번호": "산업용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000068": {"원문번호": "산업용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000069": {"원문번호": "산업용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000070": {"원문번호": "임시전력갑:기본요금적용", "파일": "재료_유가전력.json"}, "MO000071": {"원문번호": "임시전력갑:전력량요금적용", "파일": "재료_유가전력.json"}, "MO000072": {"원문번호": "임시전력갑:월간최저요금", "파일": "재료_유가전력.json"}, "GC001145": "작업량당 기계경비 — 부르는 곳 0 · 필요하면 단가산출에 기계 하나 넣어 만듦(요구 734-4 · 735-4 · 813-2)", "GC001148": "작업량당 기계경비 — 부르는 곳 0 · 필요하면 단가산출에 기계 하나 넣어 만듦(요구 734-4 · 735-4 · 813-2)", "GC001151": "작업량당 기계경비 — 부르는 곳 0 · 필요하면 단가산출에 기계 하나 넣어 만듦(요구 734-4 · 735-4 · 813-2)", "GC001156": "작업량당 기계경비 — 부르는 곳 0 · 필요하면 단가산출에 기계 하나 넣어 만듦(요구 734-4 · 735-4 · 813-2)", "GC001159": "작업량당 기계경비 — 부르는 곳 0 · 필요하면 단가산출에 기계 하나 넣어 만듦(요구 734-4 · 735-4 · 813-2)", "GC001166": "작업량당 기계경비 — 부르는 곳 0 · 필요하면 단가산출에 기계 하나 넣어 만듦(요구 734-4 · 735-4 · 813-2)"},
   "키": {
     "CC000001": {"원문번호": "공통 1-3-1 콘크리트 및 포장용 재료", "파일": "계수_건설품셈_01장_적용기준.json"},
     "CC000002": {"원문번호": "공통 1-3-1 노상 및 노반재료", "파일": "계수_건설품셈_01장_적용기준.json"},
@@ -2490,28 +2490,22 @@
     "GC001142": {"원문번호": "공통 1-2-7 벽돌운반", "파일": "로직_건설품셈_01장_적용기준.json"},
     "GC001143": {"원문번호": "공통 8-1-4 기본식", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001144": {"원문번호": "공통 8-2-1 불도저", "파일": "로직_건설품셈_08장_건설기계.json"},
-    "GC001145": {"원문번호": "공통 8-2-1 불도저경비", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001146": {"원문번호": "공통 8-2-2 리퍼", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001147": {"원문번호": "공통 8-2-3 굴착기", "파일": "로직_건설품셈_08장_건설기계.json"},
-    "GC001148": {"원문번호": "공통 8-2-3 굴착기경비", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001149": {"원문번호": "공통 8-2-4 트랜처", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001150": {"원문번호": "공통 8-2-5 로더", "파일": "로직_건설품셈_08장_건설기계.json"},
-    "GC001151": {"원문번호": "공통 8-2-5 로더경비", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001152": {"원문번호": "공통 8-2-6 스크레이퍼", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001153": {"원문번호": "공통 8-2-7 그레이더면적", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001154": {"원문번호": "공통 8-2-7 그레이더토량", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001155": {"원문번호": "공통 8-2-8 덤프트럭", "파일": "로직_건설품셈_08장_건설기계.json"},
-    "GC001156": {"원문번호": "공통 8-2-8 덤프트럭경비", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001157": {"원문번호": "공통 8-2-9 롤러토량", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001158": {"원문번호": "공통 8-2-9 롤러면적", "파일": "로직_건설품셈_08장_건설기계.json"},
-    "GC001159": {"원문번호": "공통 8-2-9 롤러경비", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001160": {"원문번호": "공통 8-2-10 아스팔트플랜트", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001161": {"원문번호": "공통 8-2-11 스테이빌라이저", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001162": {"원문번호": "공통 8-2-12 죠", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001163": {"원문번호": "공통 8-2-12 롤", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001164": {"원문번호": "공통 8-2-12 이동식", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001165": {"원문번호": "공통 8-2-12 스크린", "파일": "로직_건설품셈_08장_건설기계.json"},
-    "GC001166": {"원문번호": "공통 8-2-13 브레이커경비", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001167": {"원문번호": "공통 8-2-14 압쇄기", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001168": {"원문번호": "공통 8-2-15 법면다짐기", "파일": "로직_건설품셈_08장_건설기계.json"},
     "GC001169": {"원문번호": "공통 8-2-16 골재세척", "파일": "로직_건설품셈_08장_건설기계.json"},
@@ -2791,16 +2785,16 @@
     "GF000249": {"원문번호": "9-14-2 다짐", "파일": "로직_산림품셈_09장_토공.json"},
     "GF000250": {"원문번호": "9-15-2 표토제거 답외구간", "파일": "로직_산림품셈_09장_토공.json"},
     "GF000251": {"원문번호": "9-17-2 비다짐", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000252": {"원문번호": "9-4-1 암파쇄(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000253": {"원문번호": "9-5-2 발파암 깎기 90%(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000252": {"원문번호": "9-4-1 암파쇄", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000253": {"원문번호": "9-5-2 발파암 깎기(90%)", "파일": "로직_산림품셈_09장_토공.json"},
     "GF000254": {"원문번호": "9-5-1 육상 암석 절취(발파 10%)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000255": {"원문번호": "9-6-1 발파암 기계소할(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000256": {"원문번호": "9-7-1 무근콘크리트 깨기(T=30㎝ 미만) 깨기(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000257": {"원문번호": "9-7-2 무근콘크리트 깨기(T=30㎝ 이상) 깨기(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000258": {"원문번호": "9-8-1 철근콘크리트 깨기(T=30㎝ 미만) 깨기(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000259": {"원문번호": "9-8-2 철근콘크리트 깨기(T=30㎝ 이상) 깨기(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000260": {"원문번호": "9-10-1 기존포장 깨기 콘크리트 깨기(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
-    "GF000261": {"원문번호": "9-10-2 기존포장 깨기 아스팔트 깨기(대형브레이커 · 굴착기 0.7㎥)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000255": {"원문번호": "9-6-1 발파암 기계소할(15%)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000256": {"원문번호": "9-7-1 무근콘크리트 깨기(T=30㎝ 미만)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000257": {"원문번호": "9-7-2 무근콘크리트 깨기(T=30㎝ 이상)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000258": {"원문번호": "9-8-1 철근콘크리트 깨기(T=30㎝ 미만)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000259": {"원문번호": "9-8-2 철근콘크리트 깨기(T=30㎝ 이상)", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000260": {"원문번호": "9-10-1 기존포장 깨기 콘크리트", "파일": "로직_산림품셈_09장_토공.json"},
+    "GF000261": {"원문번호": "9-10-2 기존포장 깨기 아스팔트", "파일": "로직_산림품셈_09장_토공.json"},
     "GF000262": {"원문번호": "9-11-1 포장절단 콘크리트(기계)", "파일": "로직_산림품셈_09장_토공.json"},
     "GF000263": {"원문번호": "9-12-2 측구터파기 암절취", "파일": "로직_산림품셈_09장_토공.json"},
     "GF000264": {"원문번호": "9-12-3 측구터파기 발파암", "파일": "로직_산림품셈_09장_토공.json"},
@@ -2822,13 +2816,13 @@
     "GF000280": {"원문번호": "10-6-2 인력운반 돌(지게)", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
     "GF000281": {"원문번호": "10-6-3 인력운반 기타 임업자재", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
     "GF000282": {"원문번호": "10-8-1 케이블 크레인 짐내리기", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
-    "GF000283": {"원문번호": "10-9-1 덤프트럭 자재 운반(1회 표준 운반량)", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
-    "GF000284": {"원문번호": "10-12-1 덤프운반(굴착기 0.7㎥ 적재 · 덤프트럭 15ton)", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
+    "GF000283": {"원문번호": "10-9-1 덤프트럭 운반(자재의 1회당 표준 운반량)", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
+    "GF000284": {"원문번호": "10-12-1 덤프운반 토사", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
     "GF000285": {"원문번호": "10-13-2 묘목 인력운반", "파일": "로직_산림품셈_10장_자재․장비_운반.json"},
     "GF000286": {"원문번호": "4-1-1 수확베기 임업용 동력기계톱 벌목", "파일": "로직_산림품셈_04장_나무베기.json"},
     "GF000287": {"원문번호": "4-2-1 단목베기(100본당)", "파일": "로직_산림품셈_04장_나무베기.json"},
-    "GF000288": {"원문번호": "4-2-2 단목베기(1,000㎡당 · 굴착기 0.2㎥ + 부착용 집게)", "파일": "로직_산림품셈_04장_나무베기.json"},
-    "GF000289": {"원문번호": "4-3 위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)", "파일": "로직_산림품셈_04장_나무베기.json"},
+    "GF000288": {"원문번호": "4-2-2 단목베기(1,000㎡당)", "파일": "로직_산림품셈_04장_나무베기.json"},
+    "GF000289": {"원문번호": "4-3 위험목 베기", "파일": "로직_산림품셈_04장_나무베기.json"},
     "GF000290": {"원문번호": "5-1-1 관목굴취", "파일": "로직_산림품셈_05장_식재_및_녹화.json"},
     "GF000291": {"원문번호": "5-3-2 관목식재(단식)", "파일": "로직_산림품셈_05장_식재_및_녹화.json"},
     "GF000292": {"원문번호": "5-3-3 관목식재(군식)", "파일": "로직_산림품셈_05장_식재_및_녹화.json"},
@@ -2860,7 +2854,7 @@
     "GF000318": {"원문번호": "8-1-2 나무주사 약제주입병", "파일": "로직_산림품셈_08장_방제.json"},
     "GF000319": {"원문번호": "8-4 끈끈이 롤 트랩 설치·제거", "파일": "로직_산림품셈_08장_방제.json"},
     "GF000320": {"원문번호": "8-6-2 드론방제(무인헬기 · 멀티콥터)", "파일": "로직_산림품셈_08장_방제.json"},
-    "GF000321": {"원문번호": "8-6-3 지상방제 차량살포(동력분무기)", "파일": "로직_산림품셈_08장_방제.json"},
+    "GF000321": {"원문번호": "8-6-3 지상방제 차량살포", "파일": "로직_산림품셈_08장_방제.json"},
     "GF000322": {"원문번호": "8-10 그물망 피복", "파일": "로직_산림품셈_08장_방제.json"},
     "GF000323": {"원문번호": "8-11 이동식 임목 파쇄(93.25KW)", "파일": "로직_산림품셈_08장_방제.json"},
     "GF000324": {"원문번호": "13-4-6 밑돌 및 천단 돌쌓기", "파일": "로직_산림품셈_13장_구조물.json"},

resources/master_data/scripts/_건설기계_로직_준설.py

@@ -26,6 +26,7 @@ def marine(C) -> list[dict]:
     )
     row.pop("결과")
     row.pop("시험입력")
+    row["이름"] = "수중펌프 설치 및 해체"  # 813-2 원문 제목 · 윗절
     row["호표"] = [
         {
             "종류": "인력",

resources/master_data/scripts/build_로직_M01보강_794_2a2.py

@@ -30,8 +30,8 @@ REGIONS = [
 ]  # fmt: skip
 ROCK = ["암석작업(연암･보통암･경암)", "해당 없음", "전석섞인토사"]
 NAMES = (
-    "시멘트운반(구역화물 운임 + 하차비)",
-    "철근운반(구역화물 운임 + 하차비)",
+    "시멘트운반",
+    "철근운반",
     "깬잡석 · 야면석 · 고임돌 · 파쇄석 채집(기계)",
 )
 
@@ -73,7 +73,7 @@ def haul(no: str, what: str, unit: str, per: str, old: str) -> dict:
     div = "1.1 * 적재량 * 포수" if sack else "1.1 * 적재량"
     return {
         "원문번호": no,
-        "이름": f"{what}(구역화물 운임 + 하차비)",
+        "이름": what,
         "결과단위": unit,
         "출처": f"산림품셈 {no}",
         "소유": "공용",

resources/master_data/scripts/build_로직_건설품셈_01장_적용기준.py

@@ -375,7 +375,7 @@ def logics(key: dict) -> list[dict]:
         "키": None,
         "열쇠": "공통 1-2-7 인력운반(지게)",
         **HEAD,
-        "이름": "인력운반(지게) — 건설 공통 1-2-7",
+        "이름": "지게운반",
         "결과단위": "원/자재 단위",
         "출처": f"{SRC} 2 · 3",
         "소유": "공용",
@@ -461,7 +461,7 @@ def logics(key: dict) -> list[dict]:
         "키": None,
         "열쇠": "공통 1-2-7 인력운반(기계설비)",
         **HEAD,
-        "이름": "인력운반(기계설비) — 건설 공통 1-2-7",
+        "이름": "인력운반(기계설비)",
         "결과단위": "원/자재 단위",
         "출처": f"{SRC} 5",
         "소유": "공용",
@@ -534,7 +534,7 @@ def logics(key: dict) -> list[dict]:
         "키": None,
         "열쇠": "공통 1-2-7 벽돌운반",
         **HEAD,
-        "이름": "벽돌운반 — 건설 공통 1-2-7",
+        "이름": "벽돌운반",
         "결과단위": "원/1,000매",
         "출처": f"{SRC} 4",
         "소유": "공용",

resources/master_data/scripts/build_로직_건설품셈_08장_건설기계.py

@@ -164,12 +164,7 @@ def main() -> None:
     C = chooser(made, old_coef)
 
     rows = L1.part1(C) + L2.part2(C) + L3.part3(C)
-    q_rows = {r["열쇠"]: r for r in rows}
-    hourly = {r["키"]: r for r in _load(LOGIC)["줄"]}
-    machines: dict[str, list] = {}
-    for m in _load("기계.json")["줄"]:
-        machines.setdefault(m.get("상세구분"), []).append(m["원문번호"])
-    rows += LC.costs(q_rows, hourly, machines) + [LC.breaker(hourly)]
+    # 작업량당 기계경비(LC.costs · LC.breaker) = 813-2 지움 — 단가산출에 기계 하나 넣어 만듦
     rows.sort(key=lambda r: _sec(r["원문번호"]))
     for r in rows:
         r["키"] = mk.issue(book, "GC", r["열쇠"], LOGIC)

resources/master_data/scripts/build_수식문서_802_2.py

@@ -12,7 +12,9 @@
 · 계(돈 아닌 로직 = 결과)
   원 단위 — 기본 옵션 전부 + 옵션 표본(로직마다 고르기 입력의 다른 갈래 하나씩 · 나머지 기본).
   둘 다 못 셈 = 같음(따로 셈). 보정 없음 — 다르면 목록에 까닭.
-- 저장 = 같은 것만(요구서_664 1 장 3) — 모든 대조가 같고 부르는 단가산출도 저장되는 문서 ·
+- 채택된 차이(`ADOPTED`) = 사용자 요구 714-3 「1원 차이는 로직만 맞다면 문제 없음」 — 식 속 단가산출
+  부름 값 = 끝수 뒤(새 계산기 그대로) · 목록에 남기고 저장은 막지 않음.
+- 저장 = 같은 것만(요구서_664 1 장 3) — 모든 대조가 같고(채택된 차이 빼고) 부르는 단가산출도 저장되는 문서 ·
   `resources/master_data/수식문서/수식_<옛 로직 파일 꼬리>.json`(로직 파일마다
   · 옛 로직 JSON 은 안 씀).
 - 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약).
@@ -44,6 +46,8 @@ RAW_SUB = (
     "식 속 단가산출 부름 = 끝수 뒤 값"
     "(옛 엔진 = 끝수 전 날 값 · `master_formula.run` 결과를 식에 씀)"
 )
+# 채택된 차이 — (로직, 옵션) · 요구 714-3
+ADOPTED = {("GC000100", "지역=경북")}
 
 
 def rows_of(files: dict) -> list[tuple[str, dict]]:
@@ -108,7 +112,7 @@ def why(doc: dict, old, new) -> str:
     if isinstance(new, str) and not isinstance(old, str):
         return f"새 계산기 못 셈 — {new}"
     if _uses_raw_sub(doc):
-        return RAW_SUB
+        return RAW_SUB + " · 채택(요구 714-3)"
     return "까닭 모름"
 
 
@@ -151,6 +155,7 @@ def build(log=print) -> dict:
             )
     for one in runs:
         if not one["같음"]:
+            one["채택"] = (one["로직"], one["옵션"]) in ADOPTED
             one["까닭"] = why(docs[one["로직"]], one["옛"], one["새"])
     keep = _keep(docs, runs)
     for one in runs:  # 같아도 못 넣는 것 — 부르는 단가산출이 빠짐
@@ -165,6 +170,7 @@ def build(log=print) -> dict:
         "옵션 표본": sum(1 for x in runs if x["옵션"]),
         "옵션 같음": sum(1 for x in runs if x["옵션"] and x["같음"]),
         "옵션 다름": sum(1 for x in runs if x["옵션"] and not x["같음"]),
+        "채택된 차이": sum(1 for x in runs if x.get("채택")),
         "둘 다 못 셈": both_out,
         "저장": len(keep),
         "변환 알림": sum(1 for v in notes.values() if v),
@@ -192,7 +198,7 @@ def _calls(doc: dict) -> set[str]:
 def _keep(docs: dict, runs: list[dict]) -> set[str]:
     """저장할 문서 — 모든 대조 같음 + 부르는 단가산출도 저장(닫힘).
     키 구멍 부름은 그 로직 대조로 판정."""
-    keep = set(docs) - {x["로직"] for x in runs if not x["같음"]}
+    keep = set(docs) - {x["로직"] for x in runs if not x["같음"] and not x.get("채택")}
     while True:
         drop = {k for k in keep if not _calls(docs[k]) <= keep}
         if not drop:

resources/master_data/scripts/master_doc_convert.py

@@ -443,6 +443,7 @@ def _build(c: _Conv, row: dict, given: dict, lone_steps: dict) -> dict:
         "이름": row.get("이름") or "",
         "결과단위": row.get("결과단위") or "",
         "출처": row.get("출처") or "",
+        **({"부품": row["부품"]} if row.get("부품") else {}),  # 813-2 부품 표지
     }
     money: list[dict] = []
     if "결과" in row:

resources/master_data/scripts/변수표_796_3.json

@@ -277,11 +277,6 @@
   "t": {"이름": "기어 변속시간", "근거": "건설품셈 공통 8-2-1 「t : 기어 변속시간(0.25분)」", "확신": "원문"},
   "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-1 「cm : 1회 싸이클 시간」", "확신": "원문"}
 },
-"GC001145": {
-  "운반거리": {"기호": "L", "근거": "건설품셈 공통 8-2-1 「L : 운반거리(m)」", "확신": "원문"},
-  "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-1 「f : 체적환산계수」", "확신": "원문"},
-  "작업량": {"이름": "시간당 작업량", "기호": "Q", "근거": "건설품셈 공통 8-2-1 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
-},
 "GC001146": {
   "작업거리": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-2 「ℓ : 1회의 작업거리(m)」", "확신": "원문"},
   "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-2 「f : 체적환산계수」", "확신": "원문"},
@@ -296,11 +291,6 @@
   "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-3 「E : 작업효율」", "확신": "원문"},
   "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-3 「cm : 1회 싸이클 시간(초)」", "확신": "원문"}
 },
-"GC001148": {
-  "버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-3 「q : 버킷용량(㎥)」", "확신": "원문"},
-  "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-3 「f : 체적환산계수」", "확신": "원문"},
-  "작업량": {"이름": "시간당 작업량", "기호": "Q", "근거": "건설품셈 공통 8-2-3 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
-},
 "GC001149": {
   "작업거리": {"기호": "L", "근거": "건설품셈 공통 8-2-4 「L : 1열 실작업거리(편도m)」", "확신": "원문"},
   "전진거리": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 8-2-4 「L_1 : 1열 전진거리(m)」", "확신": "원문"},
@@ -320,12 +310,6 @@
   "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-5 「cm : 1회 싸이클 시간(초)」", "확신": "원문"},
   "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-5 「E : 작업효율」", "확신": "원문"}
 },
-"GC001151": {
-  "버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-5 「q : 버킷용량(㎥)」", "확신": "원문"},
-  "주행거리": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-5 「ℓ : 편도주행거리(표준을 8m로 한다)」", "확신": "원문"},
-  "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-5 「f : 체적환산계수」", "확신": "원문"},
-  "작업량": {"이름": "운전시간당 작업량", "기호": "Q", "근거": "건설품셈 공통 8-2-5 「Q : 운전시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
-},
 "GC001152": {
   "적재주행거리": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 8-2-6 「L_1 : 적재시의 주행거리(m)」", "확신": "원문"},
   "공차주행거리": {"기호": "L", "아래": "2", "근거": "건설품셈 공통 8-2-6 「L_2 : 공차시의 주행거리(m)」", "확신": "원문"},
@@ -375,16 +359,6 @@
   "t5": {"기호": "t", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
   "t6": {"기호": "t", "아래": "6", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
 },
-"GC001156": {
-  "적재용량": {"기호": "T", "근거": "건설품셈 공통 8-2-8 「T : 덤프트럭의 적재용량(ton)」", "확신": "원문"},
-  "체적변화율": {"기호": "L", "근거": "건설품셈 공통 8-2-8 「L : 체적환산계수에서의 체적변화율」", "확신": "원문"},
-  "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-8 「f : 체적환산계수」", "확신": "원문"},
-  "적재싸이클": {"기호": "cms", "근거": "건설품셈 공통 8-2-8 「cms : 적재기계의 1회 싸이클시간(초)」", "확신": "원문"},
-  "적재버킷": {"기호": "q", "근거": "건설품셈 공통 8-2-8 「q : 흐트러진 상태의 덤프트럭 1회 적재량(㎥)」", "확신": "원문"},
-  "버킷계수": {"기호": "k", "근거": "건설품셈 공통 8-2-8 「k : 리퍼 또는 버킷계수」", "확신": "원문"},
-  "적재효율": {"기호": "Es", "근거": "건설품셈 공통 8-2-8 「Es : 적재기계의 작업효율」", "확신": "원문"},
-  "작업량": {"이름": "1시간당 작업량", "기호": "Q", "근거": "건설품셈 공통 8-2-8 「Q : 1시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
-},
 "GC001157": {
   "다짐횟수": {"기호": "N", "근거": "건설품셈 공통 8-2-9 「N : 소요다짐횟수」", "확신": "원문"},
   "두께": {"기호": "D", "근거": "건설품셈 공통 8-2-9 「D : 펴는 흙의 두께(m)」", "확신": "원문"},
@@ -399,12 +373,6 @@
   "V": {"이름": "다짐속도", "근거": "건설품셈 공통 8-2-9 「V : 다짐속도(㎞/hr)」", "확신": "원문"},
   "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-9 「E : 작업효율」", "확신": "원문"}
 },
-"GC001159": {
-  "다짐횟수": {"기호": "N", "근거": "건설품셈 공통 8-2-9 「N : 소요다짐횟수」", "확신": "원문"},
-  "두께": {"기호": "D", "근거": "건설품셈 공통 8-2-9 「D : 펴는 흙의 두께(m)」", "확신": "원문"},
-  "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-9 「f : 체적환산계수」", "확신": "원문"},
-  "작업량": {"이름": "시간당 다짐토량", "기호": "Q", "근거": "건설품셈 공통 8-2-9 「Q : 시간당 다짐토량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
-},
 "GC001161": {
   "W": {"이름": "유효혼합폭", "근거": "건설품셈 공통 8-2-11 「W : 유효혼합폭(m)」", "확신": "원문"},
   "V": {"이름": "작업속도", "근거": "건설품셈 공통 8-2-11 「V : 작업속도(1,000m/hr)」", "확신": "원문"},

resources/master_data/로직_건설품셈_01장_공통.json

@@ -824,7 +824,7 @@
       "원문번호": "1-2-16",
       "구분": "건설품셈 유지관리",
       "상세구분": "01장 공통",
-      "이름": "약제살포(동력분무기)",
+      "이름": "약제살포(기계)",
       "결과단위": "원/ℓ",
       "출처": "건설품셈 유지관리 1-2-16",
       "개정": [2019, 2022],

resources/master_data/로직_건설품셈_01장_도로포장공사.json

@@ -860,7 +860,7 @@
       "원문번호": "1-6-5",
       "구분": "건설품셈 토목",
       "상세구분": "01장 도로포장공사",
-      "이름": "콘크리트 페이버 조립 및 해체",
+      "이름": "기계포설 장비조립 및 해체",
       "결과단위": "원/회",
       "출처": "건설품셈 토목 1-6-5",
       "개정": [2021],

resources/master_data/로직_건설품셈_01장_적용기준.json

@@ -10,7 +10,7 @@
       "원문번호": "1-2-7",
       "구분": "건설품셈 공통",
       "상세구분": "01장 적용기준",
-      "이름": "인력운반(지게) — 건설 공통 1-2-7",
+      "이름": "지게운반",
       "결과단위": "원/자재 단위",
       "출처": "건설품셈 공통 1-2-7 2 · 3",
       "개정": [2008, 2010, 2016, 2022, 2023],
@@ -131,7 +131,7 @@
       "원문번호": "1-2-7",
       "구분": "건설품셈 공통",
       "상세구분": "01장 적용기준",
-      "이름": "인력운반(기계설비) — 건설 공통 1-2-7",
+      "이름": "인력운반(기계설비)",
       "결과단위": "원/자재 단위",
       "출처": "건설품셈 공통 1-2-7 5",
       "개정": [2008, 2010, 2016, 2022, 2023],
@@ -258,7 +258,7 @@
       "원문번호": "1-2-7",
       "구분": "건설품셈 공통",
       "상세구분": "01장 적용기준",
-      "이름": "벽돌운반 — 건설 공통 1-2-7",
+      "이름": "벽돌운반",
       "결과단위": "원/1,000매",
       "출처": "건설품셈 공통 1-2-7 4",
       "개정": [2008, 2010, 2016, 2022, 2023],
@@ -282,6 +282,7 @@
       "이름": "건설폐기물 발생량 — 건설 공통 1-5-4",
       "결과단위": "ton",
       "출처": "건설품셈 공통 1-5-4 2",
+      "부품": { "갈래": "계수식" },
       "개정": [2011, 2014, 2017, 2020],
       "소유": "공용",
       "비고": "발생량 = 면적 × 단위면적당 발생량(TON/㎡) × (1 + 증가율 ÷ 100) · 증가율 = 폐콘크리트류만(주③ 파일 시공 15% · 20% 이내 · 주④ 세륜 시설 개소당 3% 이내 — 설계자가 넣음 · 0 = 증가 없음) · 원문 칸 「-」 = 줄 없음(멈춤) · 건축물 해체는 설계도서 산출 우선(원문 2) · 주⑤ 현장 여건 조정",
@@ -314,6 +315,7 @@
       "이름": "공사용수 — 건설 공통 1-5-6",
       "결과단위": "㎥",
       "출처": "건설품셈 공통 1-5-6 3",
+      "부품": { "갈래": "계수식" },
       "소유": "공용",
       "비고": "용수량 = 작업량 × 단위당 용수(㎥) × (1 + 잡용수율 ÷ 100) · 양생 물 포함([주]) · 해석: 잡용수 = 원문 「사용량비의 40∼50%」 — 잡용수율 0 = 더하지 않음(설계자가 40∼50 넣음)",
       "시험입력": { "구분": "콘크리트혼합 및 양생", "작업량": 100, "잡용수율": 0 },

resources/master_data/로직_건설품셈_01장_철골공사.json

@@ -11,7 +11,7 @@
       "원문번호": "1-1-1",
       "구분": "건설품셈 건축",
       "상세구분": "01장 철골공사",
-      "이름": "철골 공장가공조립(기본철골공수)",
+      "이름": "철골 가공 조립 기본철골공수",
       "결과단위": "원/ton",
       "출처": "건설품셈 건축 1-1-1",
       "개정": [2008, 2013],
@@ -80,7 +80,7 @@
       "원문번호": "1-1-3",
       "구분": "건설품셈 건축",
       "상세구분": "01장 철골공사",
-      "이름": "철골 공장용접(기본용접공수)",
+      "이름": "철골 가공 조립 기본용접공수",
       "결과단위": "원/ton",
       "출처": "건설품셈 건축 1-1-3",
       "소유": "공용",
@@ -443,7 +443,7 @@
       "원문번호": "1-2-7",
       "구분": "건설품셈 건축",
       "상세구분": "01장 철골공사",
-      "이름": "타워크레인 가설 · 해체 · 수직이동",
+      "이름": "철골세우기용 장비의 가설 및 해체이동",
       "결과단위": "원/대",
       "출처": "건설품셈 건축 1-2-7",
       "소유": "공용",

resources/master_data/로직_건설품셈_05장_기초공사.json

@@ -477,7 +477,7 @@
       "원문번호": "5-1-7",
       "구분": "건설품셈 공통",
       "상세구분": "05장 기초공사",
-      "이름": "앵커 천공(크롤러형 보링장비)",
+      "이름": "앵커 천공",
       "결과단위": "원/공",
       "출처": "건설품셈 공통 5-1-7",
       "개정": [2020, 2026],
@@ -1501,7 +1501,7 @@
       "원문번호": "5-2-3",
       "구분": "건설품셈 공통",
       "상세구분": "05장 기초공사",
-      "이름": "PBD천공기 조립 및 해체",
+      "이름": "PBD 장비조립 및 해체",
       "결과단위": "원/회",
       "출처": "건설품셈 공통 5-2-3",
       "개정": [2013, 2021, 2026],

resources/master_data/로직_건설품셈_06장_방수공사.json

@@ -32,7 +32,7 @@
       "원문번호": "6-1-2",
       "구분": "건설품셈 건축",
       "상세구분": "06장 방수공사",
-      "이름": "방수프라이머 바름(롤러 1회)",
+      "이름": "방수프라이머 바름",
       "결과단위": "원/㎡",
       "출처": "건설품셈 건축 6-1-2",
       "개정": [2018],

resources/master_data/로직_건설품셈_07장_돌공사.json

@@ -10,7 +10,7 @@
       "원문번호": "7-1-1",
       "구분": "건설품셈 공통",
       "상세구분": "07장 돌공사",
-      "이름": "메쌓기(굴착기+부착용 집게)",
+      "이름": "메쌓기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-1-1",
       "개정": [2012, 2019, 2026],
@@ -49,7 +49,7 @@
       "원문번호": "7-1-2",
       "구분": "건설품셈 공통",
       "상세구분": "07장 돌공사",
-      "이름": "찰쌓기(굴착기+부착용 집게)",
+      "이름": "찰쌓기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-1-2",
       "개정": [2012, 2018, 2019, 2026],
@@ -88,7 +88,7 @@
       "원문번호": "7-2-1",
       "구분": "건설품셈 공통",
       "상세구분": "07장 돌공사",
-      "이름": "메붙임(굴착기+부착용 집게)",
+      "이름": "메붙임",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-2-1",
       "개정": [2012, 2019, 2026],
@@ -127,7 +127,7 @@
       "원문번호": "7-2-2",
       "구분": "건설품셈 공통",
       "상세구분": "07장 돌공사",
-      "이름": "찰붙임(굴착기+부착용 집게)",
+      "이름": "찰붙임",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-2-2",
       "개정": [2012, 2019, 2026],
@@ -166,7 +166,7 @@
       "원문번호": "7-3-1",
       "구분": "건설품셈 공통",
       "상세구분": "07장 돌공사",
-      "이름": "전석쌓기(굴착기+부착용 집게)",
+      "이름": "전석쌓기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-3-1",
       "개정": [1992, 2012, 2018, 2026],
@@ -221,7 +221,7 @@
       "원문번호": "7-3-2",
       "구분": "건설품셈 공통",
       "상세구분": "07장 돌공사",
-      "이름": "전석깔기(굴착기+부착용 집게)",
+      "이름": "전석깔기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-3-2",
       "개정": [2018, 2026],

resources/master_data/로직_건설품셈_08장_건설기계.json

@@ -13,6 +13,7 @@
       "이름": "굴착기(무한궤도) 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "입력": [
         { "이름": "기계", "고르기": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"] },
@@ -68,6 +69,7 @@
       "이름": "기계 시간당 기계경비(손료 보정 없는 기종)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "고르기는 쓰는 기계만 — 주연료·조종원이 있는 기계는 더 넣어 씀 · 암석·전석섞인토사 작업의 불도저(19톤 미만 · 타이어·습지)·로더(무한궤도)·덤프트럭(18톤 미만)은 「공통 8 기계 시간당 경비(손료 보정)」(8-1-7 1)",
       "입력": [
@@ -237,6 +239,7 @@
       "이름": "기계 시간당 기계경비(8-1-7 손료 보정)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "8-1-7 표의 기종만 가산 — 불도저(무한궤도) 19톤 미만 · 타이어·습지 불도저 · 로더(무한궤도) · 덤프트럭 18톤 미만 · 주① 대로 불도저 19톤 이상 · 덤프트럭 18톤 이상과 표 밖 기종은 가산 0 · 굴착기(무한궤도)는 「공통 8 굴착기(무한궤도) 시간당 경비」",
       "입력": [
@@ -432,6 +435,7 @@
       "이름": "굴착기(무한궤도)+부착용 집게 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7 · 8-4-8 주⑤",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "집게는 굴착기 부수물(8-3-1 (0250) 주 · 규격은 해당 굴착기 규격) — 집게 규격은 굴착기 규격에 맞춰 고름",
       "입력": [
@@ -498,6 +502,7 @@
       "이름": "굴착기(무한궤도)+대형브레이커 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7 · 8-4-8 주⑤",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "브레이커는 굴착기 부수물(8-3-1 (0230) · 규격은 해당 굴착기 규격) — 치즐 소모는 쓰는 절의 요율로 따로",
       "입력": [
@@ -568,6 +573,7 @@
       "이름": "기계 시간당 기계경비(조종원 없는 기종)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "원문 운전경비 표에 조종원 칸이 빈 기종(진동기 · 엔진) — 주연료가 있는 기계만",
       "입력": [
@@ -930,6 +936,7 @@
       "이름": "기계 시간당 기계경비(조종원직종 입력)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "원문 8-1-3 5 운전사 구분에 이름 없는 기종 — 조종원직종을 설계자가 고름",
       "입력": [
@@ -1008,6 +1015,7 @@
       "이름": "기계 시간당 기계경비(연료 없는 기종)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": { "갈래": "기계경비식" },
       "소유": "공용",
       "비고": "원문 운전경비 표에 주연료가 빈 기종(공기식 크롤러드릴 등 — 동력은 공기압축기) — 손료 + 조종원",
       "입력": [
@@ -1053,6 +1061,7 @@
       "이름": "시공능력 산정 기본식 Q = n·q·f·E — 건설 공통 8-1-4",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-1-4",
+      "부품": { "갈래": "계수식" },
       "소유": "공용",
       "비고": "n = 60/cm(분) 또는 3,600/cm(초) · 끝수 Q 3자리 · n 2자리 · cm 3자리(주①) · 단위는 원문대로 ㎥/hr 또는 ton/hr",
       "시험입력": { "싸이클시간": 21, "시간단위": "초", "작업량": 0.9, "f": 0.7, "E": 0.75 },
@@ -1083,6 +1092,7 @@
       "이름": "불도저 시간당 작업량 — 건설 공통 8-2-1",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-1",
+      "부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
       "개정": [2025],
       "소유": "공용",
       "비고": "q = q° × e · cm = L/V1 + L/V2 + t · 타이어형 속도 표는 규격이 수(15 · 28 · 33)",
@@ -1140,86 +1150,6 @@
         "타이어규격": { "기호": "S", "아래": "타이어규격" }
       }
     },
-    {
-      "키": "GC001145",
-      "원문번호": "8-2-1",
-      "구분": "건설품셈 공통",
-      "상세구분": "08장 건설기계",
-      "이름": "불도저 작업량당 기계경비 — 건설 공통 8-2-1",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-1 · 건설품셈 공통 8-1-4",
-      "개정": [2025],
-      "소유": "공용",
-      "비고": "시간당 기계경비(GC000269) × 1/Q — Q = 8-2-1 불도저 시간당 작업량 로직",
-      "시험입력": {
-        "종별": "무한궤도",
-        "급수": "19",
-        "운반거리": 30,
-        "거리구분": "30",
-        "현장조건": "자연상태",
-        "등급": "보통",
-        "토질명": "모래, 사질토",
-        "E보정": "해당 없음",
-        "전진단": 1,
-        "후진단": 1,
-        "f": 1,
-        "E입력": 0,
-        "기계": "0101-0007"
-      },
-      "입력": [
-        { "이름": "종별", "설명": "불도저 종별", "고르기": ["무한궤도", "타이어"], "출처": "건설품셈 공통 8-2-1 1 가" },
-        { "이름": "급수", "설명": "불도저 급수(ton)", "고르기": ["4(초습지)", "7", "10", "12", "13(습지)", "19", "32", "15", "28", "33"], "출처": "건설품셈 공통 8-2-1 1 가" },
-        { "이름": "운반거리", "설명": "운반거리(L)", "단위": "m", "출처": "건설품셈 공통 8-2-1 2" },
-        { "이름": "거리구분", "설명": "운반거리계수(e) 표의 거리 칸", "고르기": ["10이하", "20", "30", "40", "50", "60", "70", "80"], "출처": "건설품셈 공통 8-2-1 1 나" },
-        { "이름": "현장조건", "설명": "흙 상태", "고르기": ["자연상태", "흐트러진 상태"], "출처": "건설품셈 공통 8-2-1 1 다" },
-        { "이름": "등급", "설명": "작업 조건 등급", "고르기": ["양호", "보통", "불량"], "출처": "건설품셈 공통 8-2-1 1 다" },
-        { "이름": "토질명", "설명": "토질", "고르기": ["모래, 사질토", "자갈섞인 흙, 점성토", "파쇄암"], "출처": "건설품셈 공통 8-2-1 1 다" },
-        { "이름": "E보정", "설명": "작업효율에서 뺄 경우", "고르기": ["해당 없음", "정지작업을 겸하는 경우", "터파기"], "출처": "건설품셈 공통 8-2-1 1 다 주" },
-        { "이름": "전진단", "설명": "전진 기어 단", "고르기": [1, 2, 3, 4], "출처": "건설품셈 공통 8-2-1 2 주" },
-        { "이름": "후진단", "설명": "후진 기어 단", "고르기": [1, 2, 3], "출처": "건설품셈 공통 8-2-1 2 주" },
-        { "이름": "f", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4" },
-        { "이름": "E입력", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "범위": [0, 1], "출처": "건설품셈 공통 8-2-1" },
-        {
-          "이름": "기계",
-          "설명": "불도저 규격",
-          "고르기": ["0101-0007", "0101-0010", "0101-0012", "0101-0019", "0101-0032", "0102-0015", "0102-0028", "0102-0033", "0121-0004", "0121-0013"]
-        },
-        {
-          "이름": "지역",
-          "고르기": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"],
-          "출처": "건설품셈 공통 8-1-7 5"
-        },
-        { "이름": "보정작업", "고르기": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "출처": "건설품셈 공통 8-1-7 1" }
-      ],
-      "중간": [
-        {
-          "이름": "작업량",
-          "식": "로직(GC001144, 종별=종별, 급수=급수, 운반거리=운반거리, 거리구분=거리구분, 현장조건=현장조건, 등급=등급, 토질명=토질명, E보정=E보정, 전진단=전진단, 후진단=후진단, f=f, E입력=E입력)",
-          "단위": "㎥/hr"
-        }
-      ],
-      "호표": [{ "종류": "로직", "요소": "로직(GC000269, 기계=기계, 지역=지역, 보정작업=보정작업)", "이름": "불도저", "단위": "시간", "수량": "1 / 작업량", "출처": "건설품셈 공통 8-1-4" }],
-      "덧줄": [],
-      "끝수": null,
-      "변수표": {
-        "운반거리": { "기호": "L" },
-        "f": { "이름": "체적환산계수" },
-        "작업량": { "이름": "시간당 작업량", "기호": "Q" },
-        "종별": { "기호": "S", "아래": "종별" },
-        "급수": { "기호": "S", "아래": "급수" },
-        "거리구분": { "기호": "S", "아래": "거리구분" },
-        "현장조건": { "기호": "S", "아래": "현장조건" },
-        "등급": { "기호": "S", "아래": "등급" },
-        "토질명": { "기호": "S", "아래": "토질명" },
-        "E보정": { "기호": "E", "아래": "보정" },
-        "전진단": { "기호": "S", "아래": "전진단" },
-        "후진단": { "기호": "S", "아래": "후진단" },
-        "E입력": { "기호": "E", "아래": "입력" },
-        "기계": { "기호": "S", "아래": "기계" },
-        "지역": { "기호": "S", "아래": "지역" },
-        "보정작업": { "기호": "S", "아래": "보정작업" }
-      }
-    },
     {
       "키": "GC001146",
       "원문번호": "8-2-2",
@@ -1228,6 +1158,7 @@
       "이름": "리퍼(유압식) 시간당 파쇄량 — 건설 공통 8-2-2",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["유압식 리퍼"] },
       "개정": [2025],
       "소유": "공용",
       "비고": "cm = 0.05ℓ + 0.25(원문 산정식) · 탄성파속도는 작업효율 표에 있는 값(규격별)",
@@ -1269,6 +1200,7 @@
       "이름": "굴착기 시간당 작업량 — 건설 공통 8-2-3",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-3",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "버킷용량" },
       "개정": [2004, 2007, 2009, 2025],
       "소유": "공용",
       "비고": "Q = 3,600·q·K·f·E/cm · 협소현장 = 주⑦ 상하수도관로부설 등 별도 E 표 · 싸이클입력 0 = 표(규격 · 선회각도)",
@@ -1337,96 +1269,6 @@
         "보정": { "기호": "r", "아래": "보정" }
       }
     },
-    {
-      "키": "GC001148",
-      "원문번호": "8-2-3",
-      "구분": "건설품셈 공통",
-      "상세구분": "08장 건설기계",
-      "이름": "굴착기(무한궤도) 작업량당 기계경비 — 건설 공통 8-2-3",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-3 · 건설품셈 공통 8-1-4",
-      "개정": [2004, 2007, 2009, 2025],
-      "소유": "공용",
-      "비고": "시간당 기계경비(GC000267) × 1/Q — Q = 8-2-3 굴착기 시간당 작업량 로직",
-      "시험입력": {
-        "버킷용량": 1,
-        "규격구분": "1.0∼1.2",
-        "선회각도": 135,
-        "버킷조건": "위의 토질보다 약간 단단한 토질로서 버킷에 거의 가득 채울 수 있는 모래, 보통토 및 조건이 좋은 점토인 경우",
-        "현장조건": "흐트러진 상태",
-        "등급": "보통",
-        "토질명": "모래, 사질토",
-        "E보정": "해당 없음",
-        "협소현장": "해당 없음",
-        "f": 0.7,
-        "E입력": 0,
-        "싸이클입력": 0,
-        "기계": "0201-0012"
-      },
-      "입력": [
-        { "이름": "버킷용량", "설명": "버킷용량(q)", "단위": "㎥", "출처": "건설품셈 공통 8-2-3" },
-        { "이름": "규격구분", "설명": "싸이클시간 표의 규격 칸", "단위": "㎥", "고르기": ["0.12∼0.4", "0.6∼0.8", "1.0∼1.2", "2.0"], "출처": "건설품셈 공통 8-2-3 3" },
-        { "이름": "선회각도", "설명": "선회 각도", "단위": "도", "고르기": [45, 90, 135, 180], "출처": "건설품셈 공통 8-2-3 3" },
-        {
-          "이름": "버킷조건",
-          "설명": "버킷계수(K) 현장조건",
-          "고르기": [
-            "용이하게 굴착할 수 있는 연한 토질로서 버킷에 산적으로 가득찰 때가 많은 조건이 좋은 모래, 보통토인 경우",
-            "위의 토질보다 약간 단단한 토질로서 버킷에 거의 가득 채울 수 있는 모래, 보통토 및 조건이 좋은 점토인 경우",
-            "버킷에 가득 채우기가 어렵거나 가벼운 발파를 필요로 하는 것으로서 단단한 점토질, 점토, 역토질인 경우",
-            "버킷에 넣기 어렵고 불규칙한 공극이 생기는 것으로서 발파 또는 리퍼작업 등에 의하여 얻어진 암과 파쇄암, 호박돌, 역 등인 경우"
-          ],
-          "출처": "건설품셈 공통 8-2-3 1"
-        },
-        { "이름": "현장조건", "설명": "흙 상태", "고르기": ["자연상태", "흐트러진 상태"], "출처": "건설품셈 공통 8-2-3 2" },
-        { "이름": "등급", "설명": "작업 조건 등급", "고르기": ["양호", "보통", "불량"], "출처": "건설품셈 공통 8-2-3 2" },
-        { "이름": "토질명", "설명": "토질", "고르기": ["모래, 사질토", "자갈섞인 흙, 점성토", "파쇄암"], "출처": "건설품셈 공통 8-2-3 2" },
-        { "이름": "E보정", "설명": "작업효율에서 뺄 경우", "고르기": ["해당 없음", "터파기"], "출처": "건설품셈 공통 8-2-3 2 주" },
-        { "이름": "협소현장", "설명": "주택가 상하수도관로부설 등 협소현장(주⑦)", "고르기": ["해당 없음", "상하수도관로부설 등 협소현장"], "출처": "건설품셈 공통 8-2-3 2 주⑦" },
-        { "이름": "f", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4" },
-        { "이름": "E입력", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "범위": [0, 1], "출처": "건설품셈 공통 8-2-3" },
-        { "이름": "싸이클입력", "설명": "1회 싸이클시간을 직접 넣을 때 — 0 이면 표", "단위": "sec", "범위": [0, 30], "출처": "건설품셈 공통 8-2-3 3" },
-        {
-          "이름": "기계",
-          "설명": "굴착기(무한궤도) 규격",
-          "고르기": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"]
-        },
-        {
-          "이름": "지역",
-          "고르기": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"],
-          "출처": "건설품셈 공통 8-1-7 5"
-        },
-        { "이름": "보정작업", "고르기": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "출처": "건설품셈 공통 8-1-7 1" }
-      ],
-      "중간": [
-        {
-          "이름": "작업량",
-          "식": "로직(GC001147, 버킷용량=버킷용량, 규격구분=규격구분, 선회각도=선회각도, 버킷조건=버킷조건, 현장조건=현장조건, 등급=등급, 토질명=토질명, E보정=E보정, 협소현장=협소현장, f=f, E입력=E입력, 싸이클입력=싸이클입력)",
-          "단위": "㎥/hr"
-        }
-      ],
-      "호표": [{ "종류": "로직", "요소": "로직(GC000267, 기계=기계, 지역=지역, 보정작업=보정작업)", "이름": "굴착기(무한궤도)", "단위": "시간", "수량": "1 / 작업량", "출처": "건설품셈 공통 8-1-4" }],
-      "덧줄": [],
-      "끝수": null,
-      "변수표": {
-        "버킷용량": { "기호": "q" },
-        "f": { "이름": "체적환산계수" },
-        "작업량": { "이름": "시간당 작업량", "기호": "Q" },
-        "규격구분": { "기호": "S", "아래": "규격구분" },
-        "선회각도": { "기호": "θ", "아래": "선회" },
-        "버킷조건": { "기호": "S", "아래": "버킷조건" },
-        "현장조건": { "기호": "S", "아래": "현장조건" },
-        "등급": { "기호": "S", "아래": "등급" },
-        "토질명": { "기호": "S", "아래": "토질명" },
-        "E보정": { "기호": "E", "아래": "보정" },
-        "협소현장": { "기호": "S", "아래": "협소현장" },
-        "E입력": { "기호": "E", "아래": "입력" },
-        "싸이클입력": { "기호": "X", "아래": "싸이클" },
-        "기계": { "기호": "S", "아래": "기계" },
-        "지역": { "기호": "S", "아래": "지역" },
-        "보정작업": { "기호": "S", "아래": "보정작업" }
-      }
-    },
     {
       "키": "GC001149",
       "원문번호": "8-2-4",
@@ -1435,6 +1277,7 @@
       "이름": "트랜처 시간당 작업량 — 건설 공통 8-2-4",
       "결과단위": "m/hr",
       "출처": "건설품셈 공통 8-2-4",
+      "부품": { "갈래": "작업량 틀", "기종": ["트랜처"] },
       "소유": "공용",
       "비고": "cm = t1 + (L1/V1 + L2/V2) + t3 · 작업보조인부 4인 1조(주①)",
       "시험입력": { "작업거리": 100, "전진거리": 0, "후진거리": 0, "굴착심도": 0.7, "토질": "사질토", "작업조건": "보통", "E입력": 0 },
@@ -1483,6 +1326,7 @@
       "이름": "로더 운전시간당 작업량 — 건설 공통 8-2-5",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-5",
+      "부품": { "갈래": "작업량 틀", "기종": ["로더"], "규격": "버킷용량" },
       "개정": [2007, 2020],
       "소유": "공용",
       "비고": "cm = m·ℓ + t1 + t2 · K 표 둘(산적상태 적재 · 자연상태·기타 적재) · 주행거리 0 = 표준 8m",
@@ -1563,100 +1407,6 @@
         "보정": { "기호": "r", "아래": "보정" }
       }
     },
-    {
-      "키": "GC001151",
-      "원문번호": "8-2-5",
-      "구분": "건설품셈 공통",
-      "상세구분": "08장 건설기계",
-      "이름": "로더 작업량당 기계경비 — 건설 공통 8-2-5",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-5 · 건설품셈 공통 8-1-4",
-      "개정": [2007, 2020],
-      "소유": "공용",
-      "비고": "시간당 기계경비(GC000269) × 1/Q — Q = 8-2-5 로더 시간당 작업량 로직",
-      "시험입력": {
-        "기종": "타이어식",
-        "버킷용량": 1.34,
-        "작업방법": "산적상태에서 담을 때",
-        "적재조건": "보통인 경우",
-        "K표": "산적상태 적재",
-        "K조건": "굴착기계로 깎거나 쌓아모은 산적상태에서 적재하는 것으로 굴착력을 필요로 하지 않고 쉽게 버킷에 산적할 수 있는 것, 즉 조건이 좋은 모래, 보통토 등",
-        "주행거리": 0,
-        "현장조건": "흐트러진 상태",
-        "등급": "양호",
-        "토질명": "모래, 사질토",
-        "E보정": "해당 없음",
-        "f": 1,
-        "E입력": 0,
-        "기계": "0301-0057"
-      },
-      "입력": [
-        { "이름": "기종", "설명": "로더 기종", "고르기": ["무한궤도식", "타이어식"], "출처": "건설품셈 공통 8-2-5 1" },
-        { "이름": "버킷용량", "설명": "버킷용량(q)", "단위": "㎥", "출처": "건설품셈 공통 8-2-5" },
-        { "이름": "작업방법", "설명": "버킷에 담는 방법", "고르기": ["산적상태에서 담을 때", "지면부터 굴착 집토하여 담을 때"], "출처": "건설품셈 공통 8-2-5 1" },
-        { "이름": "적재조건", "설명": "t1 현장조건", "고르기": ["용이한 경우", "보통인 경우", "약간곤란한 경우", "곤란한 경우"], "출처": "건설품셈 공통 8-2-5 1" },
-        { "이름": "K표", "설명": "버킷계수 표 갈래", "고르기": ["산적상태 적재", "자연상태·기타 적재"], "출처": "건설품셈 공통 8-2-5 2" },
-        {
-          "이름": "K조건",
-          "설명": "버킷계수 현장조건(고른 표의 줄)",
-          "고르기": [
-            "굴착기계로 깎거나 쌓아모은 산적상태에서 적재하는 것으로 굴착력을 필요로 하지 않고 쉽게 버킷에 산적할 수 있는 것, 즉 조건이 좋은 모래, 보통토 등",
-            "흐트러진 산적상태에서 적재하는 것으로 위 상태보다 약간 삽날이 들어가기 어려운 토질로서 버킷에 가득 채울 수 있는 것, 즉 점토, 역질토",
-            "모래, 사력보통토, 점토, 역질토 등 직접 자연상태에서 굴착적재 할 수 있는 여건으로 버킷에 평적에 약간 미달되게 채울 수 있는 것",
-            "버킷에 가득 채울 수 없는 것으로 다른 기계로 쌓아 모아놓은 부순돌 및 점질토나 역질토로서 굳어진 덩어리상태로 되어 있는 것",
-            "버킷에 넣기 어렵고 허술하며 불규칙한 공극이 생긴 것, 예를 들면 발파 또는 리퍼로 깎은 암괴, 호박돌, 역 등"
-          ],
-          "출처": "건설품셈 공통 8-2-5 2"
-        },
-        { "이름": "주행거리", "설명": "편도주행거리(ℓ) — 0 이면 표준 8m", "단위": "m", "출처": "건설품셈 공통 8-2-5" },
-        { "이름": "현장조건", "설명": "흙 상태", "고르기": ["자연상태", "흐트러진 상태"], "출처": "건설품셈 공통 8-2-5 3" },
-        { "이름": "등급", "설명": "작업 조건 등급", "고르기": ["양호", "보통", "불량"], "출처": "건설품셈 공통 8-2-5 3" },
-        { "이름": "토질명", "설명": "토질", "고르기": ["모래, 사질토", "자갈섞인 흙, 점성토", "파쇄암"], "출처": "건설품셈 공통 8-2-5 3" },
-        { "이름": "E보정", "설명": "작업효율에서 뺄 경우", "고르기": ["해당 없음", "터파기"], "출처": "건설품셈 공통 8-2-5 3 주" },
-        { "이름": "f", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4" },
-        { "이름": "E입력", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "범위": [0, 1], "출처": "건설품셈 공통 8-2-5" },
-        {
-          "이름": "기계",
-          "설명": "로더 규격",
-          "고르기": ["0301-0057", "0301-0076", "0301-0095", "0301-0115", "0301-0134", "0301-0153", "0301-0172", "0301-0287", "0302-0057", "0302-0095", "0302-0134"]
-        },
-        {
-          "이름": "지역",
-          "고르기": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"],
-          "출처": "건설품셈 공통 8-1-7 5"
-        },
-        { "이름": "보정작업", "고르기": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "출처": "건설품셈 공통 8-1-7 1" }
-      ],
-      "중간": [
-        {
-          "이름": "작업량",
-          "식": "로직(GC001150, 기종=기종, 버킷용량=버킷용량, 작업방법=작업방법, 적재조건=적재조건, K표=K표, K조건=K조건, 주행거리=주행거리, 현장조건=현장조건, 등급=등급, 토질명=토질명, E보정=E보정, f=f, E입력=E입력)",
-          "단위": "㎥/hr"
-        }
-      ],
-      "호표": [{ "종류": "로직", "요소": "로직(GC000269, 기계=기계, 지역=지역, 보정작업=보정작업)", "이름": "로더", "단위": "시간", "수량": "1 / 작업량", "출처": "건설품셈 공통 8-1-4" }],
-      "덧줄": [],
-      "끝수": null,
-      "변수표": {
-        "버킷용량": { "기호": "q" },
-        "주행거리": { "기호": "ℓ" },
-        "f": { "이름": "체적환산계수" },
-        "작업량": { "이름": "운전시간당 작업량", "기호": "Q" },
-        "기종": { "기호": "S", "아래": "기종" },
-        "작업방법": { "기호": "S", "아래": "작업방법" },
-        "적재조건": { "기호": "S", "아래": "적재조건" },
-        "K표": { "기호": "K", "아래": "표" },
-        "K조건": { "기호": "K", "아래": "조건" },
-        "현장조건": { "기호": "S", "아래": "현장조건" },
-        "등급": { "기호": "S", "아래": "등급" },
-        "토질명": { "기호": "S", "아래": "토질명" },
-        "E보정": { "기호": "E", "아래": "보정" },
-        "E입력": { "기호": "E", "아래": "입력" },
-        "기계": { "기호": "S", "아래": "기계" },
-        "지역": { "기호": "S", "아래": "지역" },
-        "보정작업": { "기호": "S", "아래": "보정작업" }
-      }
-    },
     {
       "키": "GC001152",
       "원문번호": "8-2-6",
@@ -1665,6 +1415,7 @@
       "이름": "모터 스크레이퍼 시간당 작업량 — 건설 공통 8-2-6",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-6",
+      "부품": { "갈래": "작업량 틀", "기종": ["스크레이퍼"] },
       "소유": "공용",
       "비고": "q = 적재함용적 × K · cm = L1/V1 + L2/V2 + t",
       "시험입력": { "적재함용적": 10, "적재주행거리": 300, "공차주행거리": 300, "푸쉬도우저": "사용", "f": 1, "E입력": 0 },
@@ -1743,6 +1494,7 @@
       "이름": "모터 그레이더 1시간당 작업면적 — 건설 공통 8-2-7",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-7",
+      "부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] },
       "개정": [2025],
       "소유": "공용",
       "비고": "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈",
@@ -1808,6 +1560,7 @@
       "이름": "모터 그레이더 1시간당 작업토량 — 건설 공통 8-2-7",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-7",
+      "부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] },
       "개정": [2025],
       "소유": "공용",
       "비고": "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈",
@@ -1881,6 +1634,7 @@
       "이름": "덤프트럭 1시간당 작업량 — 건설 공통 8-2-8",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-8",
+      "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"], "규격": "적재용량" },
       "개정": [2017],
       "소유": "공용",
       "비고": "q = T/γt × L · cm = t1 + … + t6 · 적재기계 t1 = cms·n/(60·Es) · n = q/(qs·k)(2자리) · 인력 t1 = 적재시간(분/㎥) × q · t2 = 거리/속도 × 60(분)",
@@ -1997,126 +1751,6 @@
         "E입력": { "기호": "E", "아래": "입력" }
       }
     },
-    {
-      "키": "GC001156",
-      "원문번호": "8-2-8",
-      "구분": "건설품셈 공통",
-      "상세구분": "08장 건설기계",
-      "이름": "덤프트럭 작업량당 기계경비 — 건설 공통 8-2-8",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-8 · 건설품셈 공통 8-1-4",
-      "개정": [2017],
-      "소유": "공용",
-      "비고": "시간당 기계경비(GC000268) × 1/Q — Q = 8-2-8 덤프트럭 시간당 작업량 로직",
-      "시험입력": {
-        "적재용량": 15,
-        "단위중량": 1.8,
-        "체적변화율": 1.25,
-        "f": 0.7,
-        "운반거리": 0.08,
-        "도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
-        "적하토질": "모래, 역, 호박돌",
-        "적하조건": "불량",
-        "적재장소": "적재장소가 넓지는 않으나 목적장소에 불편없이 진입할 수 있을 때",
-        "덮개": "해당 없음",
-        "세륜": "안 함",
-        "적재방법": "적재기계",
-        "적재싸이클": 21,
-        "적재버킷": 1,
-        "버킷계수": 0.9,
-        "적재효율": 0.75,
-        "인력종류": "토사류",
-        "적재시간입력": 0,
-        "E입력": 0,
-        "기계": "0602-0025"
-      },
-      "입력": [
-        { "이름": "적재용량", "설명": "덤프트럭의 적재용량(T)", "단위": "ton", "출처": "건설품셈 공통 8-2-8" },
-        { "이름": "단위중량", "설명": "자연상태 토석의 단위중량(γt · 습윤밀도)", "단위": "ton/㎥", "출처": "건설품셈 공통 8-2-8" },
-        { "이름": "체적변화율", "설명": "체적환산계수에서의 체적변화율(L = 흐트러진/자연)", "출처": "건설품셈 공통 8-2-8" },
-        { "이름": "f", "설명": "체적환산계수", "출처": "건설품셈 공통 8-2-8" },
-        { "이름": "운반거리", "설명": "운반거리(편도)", "단위": "㎞", "출처": "건설품셈 공통 8-2-8 2" },
-        {
-          "이름": "도로상태",
-          "설명": "운반도로 상태",
-          "고르기": [
-            "토취장 또는 토사장 등 열악한 조건의 도로",
-            "교차가 힘든 산간지도로 및 제방 등의 도로",
-            "교차가 가능한 산간지도로 및 제방도로, 미포장도로",
-            "2차로 이상의 공사용도로",
-            "2차로 교통량 및 교통대기가 많은 시가지 포장도로(7,000대/일 이상)",
-            "4차로 이상의 교통량 및 교통대기가 많은 시가지 포장도로(40,000대/일 이상)",
-            "2차로 시가지 포장도로(7,000∼2,000대/일)",
-            "4차로 이상의 시가지 포장도로(40,000대/일 미만)",
-            "2차로 교외 포장도로(2,000대/일 이상)",
-            "4차로 이상의 교외 포장도로(40,000대/일 이상)",
-            "2차로 교외 포장도로(2,000대/일 미만)",
-            "4차로 이상의 교외 포장도로(40,000대/일 미만)",
-            "2차로 고속도로 또는 교통량(편도) 1일 40,000대 이상의 4차로 고속도로",
-            "4차로 고속도로(편도 교통량 1일 40,000대 미만)"
-          ],
-          "출처": "건설품셈 공통 8-2-8 3"
-        },
-        { "이름": "적하토질", "설명": "적하시간 표의 토질", "고르기": ["모래, 역, 호박돌", "점질토, 점토"], "출처": "건설품셈 공통 8-2-8 4" },
-        { "이름": "적하조건", "설명": "적하 작업조건", "고르기": ["양호", "보통", "불량"], "출처": "건설품셈 공통 8-2-8 4" },
-        {
-          "이름": "적재장소",
-          "설명": "적재장소 진입 조건(t4)",
-          "고르기": ["적재장소가 넓어서 트럭이 자유로이 목적장소에 진입할 수 있을 때", "적재장소가 넓지는 않으나 목적장소에 불편없이 진입할 수 있을 때", "적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때"],
-          "출처": "건설품셈 공통 8-2-8 5"
-        },
-        { "이름": "덮개", "설명": "적재함 덮개 설치 · 해체(t5)", "고르기": ["해당 없음", "인력에 의한 경우", "자동덮개시설의 경우"], "출처": "건설품셈 공통 8-2-8 6" },
-        { "이름": "세륜", "설명": "세륜기 통과(t6)", "고르기": ["안 함", "함"], "출처": "건설품셈 공통 8-2-8 7" },
-        { "이름": "적재방법", "설명": "적재시간(t1) 산출 갈래", "고르기": ["적재기계", "인력", "직접 입력"], "출처": "건설품셈 공통 8-2-8 1 · 8 · 9" },
-        { "이름": "적재싸이클", "설명": "적재기계의 1회 싸이클시간(cms)", "단위": "sec", "출처": "건설품셈 공통 8-2-8 8" },
-        { "이름": "적재버킷", "설명": "적재기계의 버킷용량(q)", "단위": "㎥", "출처": "건설품셈 공통 8-2-8 8" },
-        { "이름": "버킷계수", "설명": "적재기계의 버킷계수(k)", "출처": "건설품셈 공통 8-2-8 8" },
-        { "이름": "적재효율", "설명": "적재기계의 작업효율(Es)", "출처": "건설품셈 공통 8-2-8 8" },
-        { "이름": "인력종류", "설명": "인력 적재 종류", "고르기": ["토사류", "석재류"], "출처": "건설품셈 공통 8-2-8 9" },
-        { "이름": "적재시간입력", "설명": "적재시간(t1)을 직접 넣을 때(적재방법 「직접 입력」)", "단위": "분", "출처": "건설품셈 공통 8-2-8 1" },
-        { "이름": "E입력", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 0.9", "범위": [0, 1], "출처": "건설품셈 공통 8-2-8" },
-        { "이름": "기계", "설명": "덤프트럭 규격", "고르기": ["0602-0025", "0602-0045", "0602-0060", "0602-0105", "0602-0150"] },
-        {
-          "이름": "지역",
-          "고르기": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"],
-          "출처": "건설품셈 공통 8-1-7 5"
-        }
-      ],
-      "중간": [
-        {
-          "이름": "작업량",
-          "식": "로직(GC001155, 적재용량=적재용량, 단위중량=단위중량, 체적변화율=체적변화율, f=f, 운반거리=운반거리, 도로상태=도로상태, 적하토질=적하토질, 적하조건=적하조건, 적재장소=적재장소, 덮개=덮개, 세륜=세륜, 적재방법=적재방법, 적재싸이클=적재싸이클, 적재버킷=적재버킷, 버킷계수=버킷계수, 적재효율=적재효율, 인력종류=인력종류, 적재시간입력=적재시간입력, E입력=E입력)",
-          "단위": "㎥/hr"
-        }
-      ],
-      "호표": [{ "종류": "로직", "요소": "로직(GC000268, 기계=기계, 지역=지역)", "이름": "덤프트럭", "단위": "시간", "수량": "1 / 작업량", "출처": "건설품셈 공통 8-1-4" }],
-      "덧줄": [],
-      "끝수": null,
-      "변수표": {
-        "적재용량": { "기호": "T" },
-        "체적변화율": { "기호": "L" },
-        "f": { "이름": "체적환산계수" },
-        "적재싸이클": { "기호": "cms" },
-        "적재버킷": { "기호": "q" },
-        "버킷계수": { "기호": "k" },
-        "적재효율": { "기호": "Es" },
-        "작업량": { "이름": "1시간당 작업량", "기호": "Q" },
-        "단위중량": { "기호": "W", "아래": "단위" },
-        "운반거리": { "기호": "L", "아래": "운반" },
-        "도로상태": { "기호": "S", "아래": "도로상태" },
-        "적하토질": { "기호": "S", "아래": "적하토질" },
-        "적하조건": { "기호": "S", "아래": "적하조건" },
-        "적재장소": { "기호": "S", "아래": "적재장소" },
-        "덮개": { "기호": "S", "아래": "덮개" },
-        "세륜": { "기호": "S", "아래": "세륜" },
-        "적재방법": { "기호": "S", "아래": "적재방법" },
-        "인력종류": { "기호": "S", "아래": "인력종류" },
-        "적재시간입력": { "기호": "T", "아래": "적재" },
-        "E입력": { "기호": "E", "아래": "입력" },
-        "기계": { "기호": "S", "아래": "기계" },
-        "지역": { "기호": "S", "아래": "지역" }
-      }
-    },
     {
       "키": "GC001157",
       "원문번호": "8-2-9",
@@ -2125,6 +1759,7 @@
       "이름": "롤러 시간당 다짐토량 — 건설 공통 8-2-9",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-9",
+      "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
       "개정": [2004, 2017, 2025],
       "소유": "공용",
       "비고": "Q = 1,000·V·W·D·E·f/N · 소요다짐횟수 · 두께는 2 표(CC000063) 참고 입력",
@@ -2184,6 +1819,7 @@
       "이름": "롤러 시간당 다짐면적 — 건설 공통 8-2-9",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-9",
+      "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
       "개정": [2004, 2017, 2025],
       "소유": "공용",
       "비고": "A = 1,000·V·W·E·1/N",
@@ -2231,77 +1867,6 @@
         "E입력": { "기호": "E", "아래": "입력" }
       }
     },
-    {
-      "키": "GC001159",
-      "원문번호": "8-2-9",
-      "구분": "건설품셈 공통",
-      "상세구분": "08장 건설기계",
-      "이름": "롤러 작업량당 기계경비 — 건설 공통 8-2-9",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-9 · 건설품셈 공통 8-1-4",
-      "개정": [2004, 2017, 2025],
-      "소유": "공용",
-      "비고": "시간당 기계경비(GC000268) × 1/Q — Q = 8-2-9 롤러토량 시간당 작업량 로직",
-      "시험입력": {
-        "다짐기계": "타이어롤러",
-        "규격": "8∼15",
-        "다짐층": "노체, 축제, 노상",
-        "다짐횟수": 4,
-        "E공종": "노체, 축제, 노상",
-        "E기계": "불도저",
-        "현장조건": "보통",
-        "E입력": 0,
-        "두께": 0.3,
-        "f": 1,
-        "기계": "1106-0010"
-      },
-      "입력": [
-        { "이름": "다짐기계", "설명": "다짐기계", "고르기": ["머캐덤롤러", "탠덤롤러", "타이어롤러", "불도저", "자주식, 양족식 롤러", "진동롤러(자주식)"], "출처": "건설품셈 공통 8-2-9 1" },
-        {
-          "이름": "규격",
-          "설명": "다짐기계 규격(ton)",
-          "고르기": ["6∼8", "8∼10", "10∼12", "12∼15", "5∼8", "10∼14", "8∼15", "15∼25", "12", "19", "2.5", "4.4", "6.0", "10.0"],
-          "출처": "건설품셈 공통 8-2-9 1"
-        },
-        { "이름": "다짐층", "설명": "표준다짐속도 칸", "고르기": ["노체, 축제, 노상", "보조기층, 기층", "표층"], "출처": "건설품셈 공통 8-2-9 1" },
-        { "이름": "다짐횟수", "설명": "소요다짐횟수(N)", "단위": "회", "출처": "건설품셈 공통 8-2-9 2" },
-        { "이름": "E공종", "설명": "작업효율 표의 공종", "고르기": ["표층", "기층, 보조기층", "노체, 축제, 노상"], "출처": "건설품셈 공통 8-2-9 3" },
-        { "이름": "E기계", "설명": "작업효율 표의 다짐기계", "고르기": ["머캐덤롤러", "타이어롤러", "탠덤롤러", "진동롤러", "불도저", "양족식롤러(자주식)"], "출처": "건설품셈 공통 8-2-9 3" },
-        { "이름": "현장조건", "설명": "작업 조건", "고르기": ["양호", "보통", "불량"], "출처": "건설품셈 공통 8-2-9 3" },
-        { "이름": "E입력", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "범위": [0, 1], "출처": "건설품셈 공통 8-2-9" },
-        { "이름": "두께", "설명": "펴는 흙의 두께(D · 다져진 상태)", "단위": "m", "출처": "건설품셈 공통 8-2-9 2 주②" },
-        { "이름": "f", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4" },
-        {
-          "이름": "기계",
-          "설명": "롤러 규격",
-          "고르기": ["1106-0010", "1106-0012", "1206-0008", "1305-0007", "1306-0025", "1306-0100", "1306-0120", "1406-0008", "1406-0015", "1506-0032"]
-        },
-        {
-          "이름": "지역",
-          "고르기": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"],
-          "출처": "건설품셈 공통 8-1-7 5"
-        }
-      ],
-      "중간": [{ "이름": "작업량", "식": "로직(GC001157, 다짐기계=다짐기계, 규격=규격, 다짐층=다짐층, 다짐횟수=다짐횟수, E공종=E공종, E기계=E기계, 현장조건=현장조건, E입력=E입력, 두께=두께, f=f)", "단위": "㎥/hr" }],
-      "호표": [{ "종류": "로직", "요소": "로직(GC000268, 기계=기계, 지역=지역)", "이름": "롤러", "단위": "시간", "수량": "1 / 작업량", "출처": "건설품셈 공통 8-1-4" }],
-      "덧줄": [],
-      "끝수": null,
-      "변수표": {
-        "다짐횟수": { "기호": "N" },
-        "두께": { "기호": "D" },
-        "f": { "이름": "체적환산계수" },
-        "작업량": { "이름": "시간당 다짐토량", "기호": "Q" },
-        "다짐기계": { "기호": "S", "아래": "다짐기계" },
-        "규격": { "기호": "S", "아래": "규격" },
-        "다짐층": { "기호": "S", "아래": "다짐층" },
-        "E공종": { "기호": "E", "아래": "공종" },
-        "E기계": { "기호": "E", "아래": "기계" },
-        "현장조건": { "기호": "S", "아래": "현장조건" },
-        "E입력": { "기호": "E", "아래": "입력" },
-        "기계": { "기호": "S", "아래": "기계" },
-        "지역": { "기호": "S", "아래": "지역" }
-      }
-    },
     {
       "키": "GC001160",
       "원문번호": "8-2-10",
@@ -2310,6 +1875,7 @@
       "이름": "아스팔트 플랜트 시간당 생산능력 — 건설 공통 8-2-10",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-10",
+      "부품": { "갈래": "작업량 틀", "기종": ["아스팔트 믹싱플랜트"] },
       "소유": "공용",
       "비고": "기계효율 80% 반영값 · 작업효율 적용 안 함 · 일생산 6시간(2)",
       "시험입력": { "플랜트규격": 60, "혼합재": "B" },
@@ -2330,6 +1896,7 @@
       "이름": "스테이빌라이저(노상안정기) 시간당 작업량 — 건설 공통 8-2-11",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-11",
+      "부품": { "갈래": "작업량 틀", "기종": ["스테이빌라이저"] },
       "소유": "공용",
       "비고": "A = W·V·E/P · W = Rotor 폭 − 0.4m",
       "시험입력": { "로터폭": 2.4, "작업조건": "보통의 경우", "혼합횟수": 0, "E입력": 0 },
@@ -2365,6 +1932,7 @@
       "이름": "죠 크러셔 시간당 생산능력 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": { "갈래": "작업량 틀", "기종": ["죠 크러셔"] },
       "소유": "공용",
       "비고": "양호 = 최대치 · 보통 = 평균치 · 불량 = 최소치(주④) · 단위용적중량 1.6ton/㎥ 기준",
       "시험입력": { "규격": "025060", "출구간격": 40, "작업조건": "보통" },
@@ -2389,6 +1957,7 @@
       "이름": "롤 크러셔 시간당 생산능력 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": { "갈래": "작업량 틀", "기종": ["롤 크러셔"] },
       "소유": "공용",
       "비고": "효율 양호 65% · 보통 50% · 불량 35%(주③)",
       "시험입력": { "규격": "076063", "출구간격": 25, "작업조건": "보통" },
@@ -2410,6 +1979,7 @@
       "이름": "이동식 크러셔 시간당 생산능력 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": { "갈래": "작업량 틀", "기종": ["크러셔"] },
       "소유": "공용",
       "비고": "괄호 값도 원문 칸 그대로 씀",
       "시험입력": { "규격": 100, "출구간격": 25, "작업조건": "보통" },
@@ -2431,6 +2001,7 @@
       "이름": "스크린 전체 통과량 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": { "갈래": "작업량 틀", "기종": ["스크린"] },
       "소유": "공용",
       "비고": "통과량 = 930㎠당 통과능력 × A×B×C×D×E × 체적면적 × 1/930(주⑤ 예시)",
       "시험입력": { "체규격": 25, "조합방법": "1회통과식", "택의수": 1, "B골재량": 40, "C규격": 28.0, "D골재량": 30, "체면적": 930 },
@@ -2477,41 +2048,6 @@
         "통과능력": { "기호": "q", "아래": "통과" }
       }
     },
-    {
-      "키": "GC001166",
-      "원문번호": "8-2-13",
-      "구분": "건설품셈 공통",
-      "상세구분": "08장 건설기계",
-      "이름": "대형브레이커 작업량당 기계경비 — 건설 공통 8-2-13",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-13 2",
-      "개정": [2014, 2017, 2025],
-      "소유": "공용",
-      "비고": "작업능력 = 구조물 헐기(CC000065) · 굴착(CC000067) 표 범위 안에서 — 적용방법 다: 넓고 장해물 없음 상한치 · 약간 지장 평균치 · 협소 하한치 · 굴착기 0.4㎥ 조합 하한치(주⑤) · 보통인부 1인 · 치즐은 따로",
-      "시험입력": { "작업능력": 3.3, "기계": "0201-0070", "브레이커": "0230-0007" },
-      "입력": [
-        { "이름": "작업능력", "설명": "대형브레이커 작업능력(Q · 표 범위 안 값)", "단위": "㎥/hr", "출처": "건설품셈 공통 8-2-13 2" },
-        { "이름": "기계", "고르기": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"] },
-        { "이름": "브레이커", "고르기": ["0230-0002", "0230-0004", "0230-0006", "0230-0007", "0230-0008", "0230-0010"] },
-        {
-          "이름": "지역",
-          "고르기": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"],
-          "출처": "건설품셈 공통 8-1-7 5"
-        },
-        { "이름": "보정작업", "고르기": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "출처": "건설품셈 공통 8-1-7 1" }
-      ],
-      "중간": [],
-      "호표": [{ "종류": "로직", "요소": "로직(GC000271, 기계=기계, 브레이커=브레이커, 지역=지역, 보정작업=보정작업)", "이름": "굴착기+대형브레이커", "단위": "시간", "수량": "1 / 작업능력", "출처": "건설품셈 공통 8-2-13 2" }],
-      "덧줄": [],
-      "끝수": null,
-      "변수표": {
-        "작업능력": { "기호": "q", "아래": "작업" },
-        "기계": { "기호": "S", "아래": "기계" },
-        "브레이커": { "기호": "S", "아래": "브레이커" },
-        "지역": { "기호": "S", "아래": "지역" },
-        "보정작업": { "기호": "S", "아래": "보정작업" }
-      }
-    },
     {
       "키": "GC001167",
       "원문번호": "8-2-14",
@@ -2520,6 +2056,7 @@
       "이름": "압쇄기(콘크리트 소할용) 시간당 작업량 — 건설 공통 8-2-14",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-14",
+      "부품": { "갈래": "작업량 틀", "기종": ["압쇄기"] },
       "개정": [2004],
       "소유": "공용",
       "비고": "Q = q × E",
@@ -2538,6 +2075,7 @@
       "이름": "법면다짐기 시간당 작업량 — 건설 공통 8-2-15",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-15",
+      "부품": { "갈래": "작업량 틀", "기종": ["유압식 진동콤팩터"] },
       "소유": "공용",
       "비고": "유압식 진동콤팩터 + 굴착기 0.7㎥ · 법면다짐판 + 굴착기 1.0㎥(1)",
       "시험입력": { "구분": "유압식 진동콤팩터" },
@@ -2555,6 +2093,7 @@
       "이름": "골재세척설비 시간당 작업량 — 건설 공통 8-2-16",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-16",
+      "부품": { "갈래": "작업량 틀", "기종": ["골재세척설비"] },
       "개정": [2001],
       "소유": "공용",
       "비고": "Q = q × E",
@@ -2573,6 +2112,7 @@
       "이름": "콘크리트 믹서 시간당 생산량 — 건설 공통 8-2-17",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-17",
+      "부품": { "갈래": "작업량 틀", "기종": ["콘크리트 믹서"], "규격": "믹서용량" },
       "소유": "공용",
       "비고": "Q = 60/4 · q · E",
       "시험입력": { "믹서용량": 0.5, "E입력": 0 },
@@ -2593,6 +2133,7 @@
       "이름": "콘크리트 배치플랜트(강제 혼합식) 시간당 작업량 — 건설 공통 8-2-18",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-18",
+      "부품": { "갈래": "작업량 틀", "기종": ["콘크리트 배치플랜트"] },
       "개정": [2000, 2002, 2011],
       "소유": "공용",
       "비고": "Q = 60·q·E/cm · 터널 숏크리트 매우 불량은 E입력 0.40(주②)",
@@ -2637,6 +2178,7 @@
       "이름": "콘크리트 믹서트럭 시간당 운반량 — 건설 공통 8-2-19",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-19",
+      "부품": { "갈래": "작업량 틀", "기종": ["콘크리트 믹서트럭"], "규격": "적재용량" },
       "소유": "공용",
       "비고": "cm = t1 + t2 + t3 + t4 · t1 = w/q·cmc · t2 = 거리/속도 × 60(분) · 범위(배출 2∼3 · 3∼4 · 대기 5∼10)는 가운데 기본",
       "시험입력": { "적재용량": 6, "플랜트실용량": 1, "플랜트싸이클": 0, "운반거리": 5, "적재속도": 30, "공차속도": 35, "슬럼프": "5㎝ 이상", "펌프조합": "아니오", "배출시간입력": 0, "대기시간입력": 0, "E입력": 0 },
@@ -2696,6 +2238,7 @@
       "이름": "콘크리트 덤프트럭 시간당 운반량 — 건설 공통 8-2-19",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-19",
+      "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"] },
       "소유": "공용",
       "비고": "cm = cm1 + cm2 · cm1 = 3L + 5(±5) · cm2 = w/q·cmc + t1 + t2",
       "시험입력": { "규격": 10.5, "플랜트실용량": 1, "플랜트싸이클": 0, "운반거리": 5, "하역시간입력": 0, "대기시간입력": 0, "E입력": 0 },
@@ -2745,6 +2288,7 @@
       "이름": "기관차 시간당 작업량 — 건설 공통 8-2-20",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-20",
+      "부품": { "갈래": "작업량 틀", "기종": ["디젤 기관차"] },
       "소유": "공용",
       "비고": "Q = C·N·f·E · N = 60/(t1 + L/V1 + L/V2 + t2) · C = n × q",
       "시험입력": { "기관차": "5t", "대차용량": 1.5, "운반거리": 500, "재료": "토사류", "f": 1, "E": 0.8 },
@@ -2789,6 +2333,7 @@
       "이름": "경운기 시간당 작업량 — 건설 공통 8-2-21",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-21",
+      "부품": { "갈래": "작업량 틀", "기종": ["경운기"] },
       "소유": "공용",
       "비고": "cm = L/V1 + L/V2 + t · 공차 속도 = 원문 「적하」 칸",
       "시험입력": { "적재량": 0.5, "거리": 100, "종류": "토사류", "작업로": "보통", "f": 1, "E입력": 0 },
@@ -2831,6 +2376,7 @@
       "이름": "디젤 파일 해머 파일 1본당 시공시간 — 강관파일 — 건설 공통 8-2-22",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-22",
+      "부품": { "갈래": "작업량 틀", "기종": ["디젤 파일 해머"] },
       "소유": "공용",
       "비고": "Tc = (Tb+Tw+Ts+Tt+Te)/F · Tb = 0.05·α·β·L(N+2) — 원문 강관 식 글에 β 글자가 빠져 있으나 기호 풀이(β 해머 계수) · 표 · 콘크리트 식대로 β 곱함",
       "시험입력": {
@@ -2925,6 +2471,7 @@
       "이름": "디젤 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC) — 건설 공통 8-2-22",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-22",
+      "부품": { "갈래": "작업량 틀", "기종": ["디젤 파일 해머"] },
       "소유": "공용",
       "비고": "Tc = (Tb+Ts+Tt+Te)/F · Tb = 0.08α·β·L(N+2) · 용접 없음",
       "시험입력": { "토질": "실트･로움･모래", "α입력": 0, "파일경": 400, "해머": "2.2ton 급", "관입길이": 12, "평균N": 10, "세우기횟수": 1, "평탄성": "양호", "현장": "현장이 넓으며 작업에 장애물이 없는 경우" },
@@ -2988,6 +2535,7 @@
       "이름": "유압 파일 해머 파일 1본당 시공시간 — 강관파일 — 건설 공통 8-2-23",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-23",
+      "부품": { "갈래": "작업량 틀", "기종": ["유압 파일 해머"] },
       "소유": "공용",
       "비고": "Tc = α·β·Ta · 용접시간 포함(주④)",
       "시험입력": { "평균N": 15, "항타길이": "17∼32", "판두께": "12", "파일경": "500∼800" },
@@ -3024,6 +2572,7 @@
       "이름": "유압 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC · PHC) — 건설 공통 8-2-23",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-23",
+      "부품": { "갈래": "작업량 틀", "기종": ["유압 파일 해머"] },
       "소유": "공용",
       "비고": "Tc = α·Ta",
       "시험입력": { "평균N": 25, "항타길이": "16∼22", "파일경": "300∼600" },
@@ -3054,6 +2603,7 @@
       "이름": "진동파일 해머 파일 1본당 시공시간 — H파일 — 건설 공통 8-2-24",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-24",
+      "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] },
       "개정": [1996, 2026],
       "소유": "공용",
       "비고": "Tc = (Ts+Tb)/F · Tb = r×ℓ×k · r = (r1ℓ1 + r2ℓ2)/(ℓ1+ℓ2) · F = F0 + (f1+f2+f3+f4)",
@@ -3119,6 +2669,7 @@
       "이름": "진동파일 해머 파일 1본당 시공시간 — 강널말뚝 — 건설 공통 8-2-24",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-24",
+      "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] },
       "개정": [1996, 2026],
       "소유": "공용",
       "비고": "Tc = {(0.75+γ·Nmax)·ℓ+α}·K/F · K = 원문 항타 · 인발 두 줄에 걸친 한 칸(항타 줄 값) · 인발 F0 = 원문 「항발」 칸",
@@ -3164,6 +2715,7 @@
       "이름": "진동파일해머(워터제트 병용 압입공) 파일 1본당 시공시간 — 건설 공통 8-2-25",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-25",
+      "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머", "워터젯트"] },
       "소유": "공용",
       "비고": "Tc = To×α/F · To = 0.05L(N+42.5)+9.6 · F = F0 + (f1+f2+f3+f4)",
       "시험입력": { "근입길이": 12, "평균N": 40, "토질": "점성토", "α입력": 0, "f1": 0, "f2": 0, "f3": 0, "f4": 0 },
@@ -3206,6 +2758,7 @@
       "이름": "유압식 압입 인발기 강널말뚝 1본당 시공시간 — 건설 공통 8-2-26",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-26",
+      "부품": { "갈래": "작업량 틀", "기종": ["유압식 압입 인발기"] },
       "소유": "공용",
       "비고": "압입 Tc = (Ts+Tb)/F · 인발 Tc = (1.10ℓ+4.76)/F",
       "시험입력": { "작업": "압입", "파일길이": 12, "압입길이": 10, "Nmax": 20, "f1": 0, "f2": 0, "f3": 0 },
@@ -3247,7 +2800,7 @@
       "원문번호": "8-2-27",
       "구분": "건설품셈 공통",
       "상세구분": "08장 건설기계",
-      "이름": "수중펌프 설치 및 해체(1개소당) — 건설 공통 8-2-27",
+      "이름": "수중펌프 설치 및 해체",
       "결과단위": "원/개소",
       "출처": "건설품셈 공통 8-2-27 5",
       "소유": "공용",
@@ -3268,6 +2821,7 @@
       "이름": "터널전단면 굴착기(TBM) 1시간당 작업량 — 건설 공통 8-2-28",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-28",
+      "부품": { "갈래": "작업량 틀", "기종": ["터널전단면 굴착기"] },
       "소유": "공용",
       "비고": "A = πD²/4 · cm = T1 + T2 · T1 = ℓ/(R×Pe)×100",
       "시험입력": { "굴착직경": 4.5, "작업거리": 1.2, "회전속도": 8, "투과깊이": 0.5, "현장조건": "보통", "E입력": 0 },
@@ -3308,6 +2862,7 @@
       "이름": "펌프식 준설선 1시간당 준설능력 — 건설 공통 8-2-29",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-29",
+      "부품": { "갈래": "작업량 틀", "기종": ["펌프 준설선"] },
       "개정": [2010, 2011],
       "소유": "공용",
       "비고": "Q = q·bo·E/746 · E = E1×E2×E3×E4 · bo = 디젤 공칭 × 0.8 · 터빈 × 0.9",
@@ -3387,6 +2942,7 @@
       "이름": "그래브 준설선 1시간당 준설량 — 건설 공통 8-2-30",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-30",
+      "부품": { "갈래": "작업량 틀", "기종": ["그래브 준설선"] },
       "개정": [2010, 2011],
       "소유": "공용",
       "비고": "Q = 3,600·q·k·f·E/cm · E = E1×E2 · 수심 10m 기준 1m 증감마다 2초 증감 · 표의 괄호 값 = 쇄암 · 발파후 준설",
@@ -3463,6 +3019,7 @@
       "이름": "쇄암선(중추식) 시간당 작업능력 — 건설 공통 8-2-31",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-31",
+      "부품": { "갈래": "작업량 틀", "기종": [] },
       "개정": [2011],
       "소유": "공용",
       "비고": "Q = 60·d·S·E/(t + n/p)",
@@ -3496,6 +3053,7 @@
       "이름": "이동식 임목파쇄기 시간당 파쇄능력 — 건설 공통 8-2-32",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-32",
+      "부품": { "갈래": "작업량 틀", "기종": ["이동식 임목파쇄기"] },
       "개정": [2007, 2011],
       "소유": "공용",
       "비고": "93.25㎾ Q = 6.0 · 354.35∼402.84㎾ Q = q·K·S·E",
@@ -3521,6 +3079,7 @@
       "이름": "하천골재채취선 시간당 준설량 — 건설 공통 8-2-33",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-33",
+      "부품": { "갈래": "작업량 틀", "기종": ["하천골재채취선"] },
       "개정": [2005],
       "소유": "공용",
       "비고": "Q = q·b·E/746",

resources/master_data/로직_건설품셈_09장_기타공사.json

@@ -85,7 +85,7 @@
       "원문번호": "9-2-1",
       "구분": "건설품셈 기계설비",
       "상세구분": "09장 기타공사",
-      "이름": "바탕만들기(블라스트 · 공구 · 와이어브러시)",
+      "이름": "바탕만들기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 기계설비 9-2-1",
       "소유": "공용",
@@ -270,7 +270,7 @@
       "원문번호": "9-4-1",
       "구분": "건설품셈 기계설비",
       "상세구분": "09장 기타공사",
-      "이름": "가스배관 기밀시험",
+      "이름": "기밀시험",
       "결과단위": "원/회",
       "출처": "건설품셈 기계설비 9-4-1",
       "개정": [2015, 2019],

resources/master_data/로직_건설품셈_13장_플랜트설비공사.json

@@ -1317,7 +1317,7 @@
       "원문번호": "13-2-6",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "응력제거(Ring Burner · 전기저항)",
+      "이름": "응력제거(Ring Burner, Electric, Resistence Heating)",
       "결과단위": "원/개소",
       "출처": "건설품셈 기계설비 13-2-6",
       "소유": "공용",
@@ -1884,7 +1884,7 @@
       "원문번호": "13-5-1",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "화력 보일러 설치(공정별)",
+      "이름": "화력 보일러 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-1",
       "소유": "공용",
@@ -2059,7 +2059,7 @@
       "원문번호": "13-5-2",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "보일러 드럼 설치(공정별)",
+      "이름": "보일러 드럼 설치",
       "결과단위": "원/대",
       "출처": "건설품셈 기계설비 13-5-2",
       "소유": "공용",
@@ -2275,7 +2275,7 @@
       "원문번호": "13-5-4",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "덕트 설치(공정별)",
+      "이름": "덕트 설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-5-4",
       "소유": "공용",
@@ -2360,7 +2360,7 @@
       "원문번호": "13-5-5",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "공기예열기(Preheater) 설치(공정별)",
+      "이름": "공기예열기(Preheater) 설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-5-5",
       "소유": "공용",
@@ -2555,7 +2555,7 @@
       "원문번호": "13-5-8",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "터빈 설치(공정별)",
+      "이름": "터빈 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-8",
       "소유": "공용",
@@ -2716,7 +2716,7 @@
       "원문번호": "13-5-9",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "발전기 설치(공정별)",
+      "이름": "발전기 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-9",
       "소유": "공용",
@@ -2842,7 +2842,7 @@
       "원문번호": "13-5-10",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "복수기 설치(공정별)",
+      "이름": "복수기 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-10",
       "소유": "공용",
@@ -3350,7 +3350,7 @@
       "원문번호": "13-6-1",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "수차 설치(Kaplan · Francis · Propeller)",
+      "이름": "수차 설치",
       "결과단위": "원/ton",
       "출처": "건설품셈 기계설비 13-6-1",
       "소유": "공용",
@@ -6728,7 +6728,7 @@
       "원문번호": "13-7-19",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "Mill Line 기기류 조립설치(공정별)",
+      "이름": "Mill Line 기기류 조립설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-7-19",
       "소유": "공용",
@@ -6772,7 +6772,7 @@
       "원문번호": "13-7-20",
       "구분": "건설품셈 기계설비",
       "상세구분": "13장 플랜트설비공사",
-      "이름": "Roller Table 조립설치(공정별)",
+      "이름": "Roller Table 조립설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-7-20",
       "소유": "공용",
@@ -8793,6 +8793,7 @@
       "이름": "아세틸렌량의 환산(ℓ → ㎏)",
       "결과단위": "㎏",
       "출처": "건설품셈 기계설비 13-2-7",
+      "부품": { "갈래": "계수식" },
       "소유": "공용",
       "비고": "아세틸렌(㎏) = 아세틸렌(ℓ) × 26g/22.4ℓ ÷ 1,000 · 26g = 1mol당 분자량 · 22.4ℓ = 표준상태 1mol당량",
       "시험입력": { "아세틸렌부피": 1000 },

resources/master_data/로직_산림품셈_03장_작업장_관리.json

@@ -83,6 +83,7 @@
       "이름": "임산물 운반로 신설 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 3-4-2 1",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "해석: 원문 단가산출 예시의 값(q 0.2 · K 0.7 · f 0.71 · E 0.45 · Cm 18)을 표준 값으로 씀",
@@ -103,7 +104,7 @@
       "원문번호": "3-4-2",
       "구분": "산림품셈",
       "상세구분": "03장 작업장 관리",
-      "이름": "임산물 운반로 및 작업로 신설(굴착기 0.2㎥)",
+      "이름": "임산물 운반로 및 작업로 신설비 산정",
       "결과단위": "원/m",
       "출처": "산림품셈 3-4-2",
       "개정": [2026],

resources/master_data/로직_산림품셈_04장_나무베기.json

@@ -148,7 +148,7 @@
       "원문번호": "4-2-2",
       "구분": "산림품셈",
       "상세구분": "04장 나무베기",
-      "이름": "단목베기(1,000㎡당 · 굴착기 0.2㎥ + 부착용 집게)",
+      "이름": "단목베기(1,000㎡당)",
       "결과단위": "원/1,000㎡",
       "출처": "산림품셈 4-2-2",
       "개정": [2026],
@@ -199,7 +199,7 @@
       "원문번호": "4-3",
       "구분": "산림품셈",
       "상세구분": "04장 나무베기",
-      "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+      "이름": "위험목 베기",
       "결과단위": "원/본",
       "출처": "산림품셈 4-3",
       "개정": [2026],

resources/master_data/로직_산림품셈_05장_식재_및_녹화.json

@@ -1199,6 +1199,7 @@
       "이름": "복사이식 굴착기 시간당 작업량(Q1)",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 5-29 주④",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "해석: q = 주③ 굴착기 용량 1.0㎥ · 주⑤ Q=Q1×T 는 단위가 안 맞아(㎥/시간 × m) 넣지 않음",
@@ -1219,7 +1220,7 @@
       "원문번호": "5-29",
       "구분": "산림품셈",
       "상세구분": "05장 식재 및 녹화",
-      "이름": "복사이식(굴착기 1.0㎥)",
+      "이름": "복사이식",
       "결과단위": "원/㎥",
       "출처": "산림품셈 5-29",
       "개정": [2026],

resources/master_data/로직_산림품셈_08장_방제.json

@@ -362,7 +362,7 @@
       "원문번호": "8-6-3",
       "구분": "산림품셈",
       "상세구분": "08장 방제",
-      "이름": "지상방제 차량살포(동력분무기)",
+      "이름": "지상방제 차량살포",
       "결과단위": "원/일",
       "출처": "산림품셈 8-6-3",
       "개정": [2026],

resources/master_data/로직_산림품셈_09장_토공.json

@@ -46,6 +46,7 @@
       "이름": "토사깍기(기계 · 굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-3-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "E 원문 「0.55∼0.45」 — 설계자 입력 · f 는 주④ 0.77",
@@ -73,7 +74,7 @@
       "원문번호": "9-3-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "토사깍기(기계 · 굴착기 0.7㎥)",
+      "이름": "토사깍기(기계)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-3-2",
       "개정": [2026],
@@ -94,7 +95,7 @@
       "원문번호": "9-4-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "암파쇄(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "암파쇄",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-4-1",
       "개정": [2026],
@@ -158,6 +159,7 @@
       "이름": "암절취 집토(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-4-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "f 원문 「1/1.40」 그대로 계산",
@@ -178,7 +180,7 @@
       "원문번호": "9-4-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "암절취 집토(굴착기 0.7㎥)",
+      "이름": "암절취 집토",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-4-2",
       "개정": [2026],
@@ -235,7 +237,7 @@
       "원문번호": "9-5-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "발파암 깎기 90%(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "발파암 깎기(90%)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-5-2",
       "개정": [2026],
@@ -299,6 +301,7 @@
       "이름": "발파암 집토(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-5-3",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "f 원문 「1/1.625」 그대로 계산",
@@ -319,7 +322,7 @@
       "원문번호": "9-5-3",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "발파암 집토(굴착기 0.7㎥)",
+      "이름": "발파암 집토",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-5-3",
       "개정": [2026],
@@ -340,7 +343,7 @@
       "원문번호": "9-6-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "발파암 기계소할(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "발파암 기계소할(15%)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-6-1",
       "개정": [2026],
@@ -388,6 +391,7 @@
       "이름": "콘크리트 깨기 집토(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-7-1 주⑥",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "입력": [],
@@ -407,7 +411,7 @@
       "원문번호": "9-7-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "콘크리트 깨기 집토(굴착기 0.7㎥)",
+      "이름": "무근콘크리트 깨기 집토",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-7-1 주⑥",
       "개정": [2026],
@@ -428,7 +432,7 @@
       "원문번호": "9-7-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "무근콘크리트 깨기(T=30㎝ 미만) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "무근콘크리트 깨기(T=30㎝ 미만)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-7-1",
       "개정": [2026],
@@ -475,7 +479,7 @@
       "원문번호": "9-7-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "무근콘크리트 깨기(T=30㎝ 이상) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "무근콘크리트 깨기(T=30㎝ 이상)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-7-2",
       "개정": [2026],
@@ -579,7 +583,7 @@
       "원문번호": "9-8-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "철근콘크리트 깨기(T=30㎝ 미만) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "철근콘크리트 깨기(T=30㎝ 미만)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-8-1",
       "개정": [2026],
@@ -626,7 +630,7 @@
       "원문번호": "9-8-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "철근콘크리트 깨기(T=30㎝ 이상) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "철근콘크리트 깨기(T=30㎝ 이상)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-8-2",
       "개정": [2026],
@@ -691,7 +695,7 @@
       "원문번호": "9-10-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "기존포장 깨기 콘크리트 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "기존포장 깨기 콘크리트",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-10-1",
       "개정": [2026],
@@ -738,7 +742,7 @@
       "원문번호": "9-10-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "기존포장 깨기 아스팔트 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "기존포장 깨기 아스팔트",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-10-2",
       "개정": [2026],
@@ -825,6 +829,7 @@
       "이름": "측구터파기 토사 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-12-1",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "입력": [],
@@ -2028,6 +2033,7 @@
       "이름": "되메우기 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-14-1",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "입력": [],
@@ -2080,6 +2086,7 @@
       "이름": "다짐(플레이트콤펙터) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-14-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["플레이트 콤팩터"] },
       "개정": [2026],
       "소유": "공용",
       "비고": "돈 로직 GF000249",
@@ -2101,7 +2108,7 @@
       "원문번호": "9-14-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "다짐(플레이트콤펙터 1.5ton)",
+      "이름": "다짐(플레이트콤펙터)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-14-2",
       "개정": [2026],
@@ -2121,6 +2128,7 @@
       "이름": "표토제거 답(畓)구간(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎡/hr",
       "출처": "산림품셈 9-15-1",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "T(표토두께) 설계자 입력 · Q=Q1/T · f 원문 「1/1.30」 그대로 계산",
@@ -2141,7 +2149,7 @@
       "원문번호": "9-15-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "표토제거 답(畓)구간(굴착기 0.7㎥)",
+      "이름": "표토제거 답(畓)구간",
       "결과단위": "원/㎡",
       "출처": "산림품셈 9-15-1",
       "개정": [2026],
@@ -2165,6 +2173,7 @@
       "이름": "표토제거 답(畓)외구간(불도저 19ton) 시간당 작업량",
       "결과단위": "㎡/hr",
       "출처": "산림품셈 9-15-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
       "개정": [2026],
       "소유": "공용",
       "비고": "돈 로직 GF000250 · f 원문 「1/1.3」 그대로 계산",
@@ -2201,7 +2210,7 @@
       "원문번호": "9-15-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "표토제거 답(畓)외구간(불도저 19ton)",
+      "이름": "표토제거 답(畓)외구간",
       "결과단위": "원/㎡",
       "출처": "산림품셈 9-15-2",
       "개정": [2026],
@@ -2224,6 +2233,7 @@
       "이름": "노체포설 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-16-1 주②",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"] },
       "개정": [2026],
       "소유": "공용",
       "입력": [],
@@ -2243,7 +2253,7 @@
       "원문번호": "9-16-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+      "이름": "노체포설",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-16-1",
       "개정": [2026],
@@ -2270,6 +2280,7 @@
       "이름": "노체다짐 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-16-2 주②",
+      "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
       "개정": [2026],
       "소유": "공용",
       "입력": [],
@@ -2341,6 +2352,7 @@
       "이름": "비다짐(정지 · 불도저 19ton) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-17-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
       "개정": [2026],
       "소유": "공용",
       "비고": "돈 로직 GF000251 · E 원문 「(0.55-0.1)」 · f 원문 「1/1.3」 그대로 계산",
@@ -2372,7 +2384,7 @@
       "원문번호": "9-17-2",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "비다짐(정지 · 불도저 19ton)",
+      "이름": "비다짐(정지)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-17-2",
       "개정": [2026],
@@ -2395,6 +2407,7 @@
       "이름": "층따기(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-18",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "f 원문 「1/1.3」 그대로 계산",
@@ -2415,7 +2428,7 @@
       "원문번호": "9-18",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "층따기(굴착기 0.7㎥)",
+      "이름": "층따기",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-18",
       "개정": [2026],
@@ -2478,7 +2491,7 @@
       "원문번호": "9-19-1",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "토사면 성토면 고르기(기계시공 · 굴착기 0.6㎥)",
+      "이름": "토사면 성토면 고르기(기계시공)",
       "결과단위": "원/10㎡",
       "출처": "산림품셈 9-19-1",
       "개정": [2026],
@@ -2641,6 +2654,7 @@
       "이름": "섞기(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-22",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "f 원문 「1/1.25」 그대로 계산 · 주③ Q=Q1*T 는 단위가 맞지 않아 Q1 까지만",
@@ -2661,7 +2675,7 @@
       "원문번호": "9-22",
       "구분": "산림품셈",
       "상세구분": "09장 토공",
-      "이름": "섞기(굴착기 0.7㎥)",
+      "이름": "섞기",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-22",
       "개정": [2026],

resources/master_data/로직_산림품셈_10장_자재․장비_운반.json

@@ -12,6 +12,7 @@
       "이름": "골재운반 덤프트럭 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 10-3-1 주",
+      "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"] },
       "개정": [2026],
       "소유": "공용",
       "비고": "원문은 식만(Q=60×qt×f×E/㎝) — qt · f · E · ㎝ 값 없음 · 설계자 입력",
@@ -26,7 +27,7 @@
       "원문번호": "10-3-1",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "골재운반 모래(덤프 15ton)",
+      "이름": "골재운반 모래",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-3-1",
       "개정": [2026],
@@ -61,7 +62,7 @@
       "원문번호": "10-3-2",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "골재운반 잡석(덤프 15ton)",
+      "이름": "골재운반 잡석",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-3-2",
       "개정": [2026],
@@ -96,7 +97,7 @@
       "원문번호": "10-3-3",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "골재운반 혼합골재(덤프 15ton)",
+      "이름": "골재운반 혼합골재",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-3-3",
       "개정": [2026],
@@ -131,7 +132,7 @@
       "원문번호": "10-4",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "중기운반 트레일러(20ton)",
+      "이름": "중기운반",
       "결과단위": "원/회",
       "출처": "산림품셈 10-4",
       "개정": [2026],
@@ -518,6 +519,7 @@
       "이름": "4륜구동 1톤 덤프트럭 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "산림품셈 10-9",
+      "부품": { "갈래": "기계경비식" },
       "개정": [2026],
       "소유": "공용",
       "비고": "손료·운전경비는 2.5톤(0602-0025) · 주연료 2.5톤의 80% · 중기가격 조달청 등재가격은 요소 없음 · 작업량(건설품셈 덤프트럭 식)·10-9-1 운반량 쓰는 식 요소 없음 · 주② 제잡비 비율 원문에 없음",
@@ -565,7 +567,7 @@
       "원문번호": "10-9-1",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "덤프트럭 자재 운반(1회 표준 운반량)",
+      "이름": "덤프트럭 운반(자재의 1회당 표준 운반량)",
       "결과단위": "원/ton",
       "출처": "산림품셈 10-9-1",
       "개정": [2026],
@@ -673,6 +675,7 @@
       "이름": "불도저 운반 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 10-11 주②",
+      "부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
       "개정": [2026],
       "소유": "공용",
       "비고": "해석: 파쇄암·발파암의 E 는 「암석」 줄",
@@ -729,7 +732,7 @@
       "원문번호": "10-12-1",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "덤프운반(굴착기 0.7㎥ 적재 · 덤프트럭 15ton)",
+      "이름": "덤프운반 토사",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-12-1",
       "개정": [2026],
@@ -861,7 +864,7 @@
       "원문번호": "10-1",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "시멘트운반(구역화물 운임 + 하차비)",
+      "이름": "시멘트운반",
       "결과단위": "원/포",
       "출처": "산림품셈 10-1",
       "개정": [2026],
@@ -964,7 +967,7 @@
       "원문번호": "10-2",
       "구분": "산림품셈",
       "상세구분": "10장 자재․장비 운반",
-      "이름": "철근운반(구역화물 운임 + 하차비)",
+      "이름": "철근운반",
       "결과단위": "원/ton",
       "출처": "산림품셈 10-2",
       "개정": [2026],

resources/master_data/로직_산림품셈_11장_가설.json

@@ -93,6 +93,7 @@
       "이름": "쇄석·혼합석 부설 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 11-4 주①",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "해석: 원문 식 「3600×90×k×f×E/㎝」의 90 을 q(버킷용량)로 봄",
@@ -113,7 +114,7 @@
       "원문번호": "11-4",
       "구분": "산림품셈",
       "상세구분": "11장 가설",
-      "이름": "쇄석·혼합석 부설(굴착기 0.7㎥)",
+      "이름": "쇄석·혼합석 부설",
       "결과단위": "원/㎥",
       "출처": "산림품셈 11-4",
       "개정": [2026],

resources/master_data/로직_산림품셈_13장_구조물.json

@@ -1323,6 +1323,7 @@
       "이름": "토양개량제 부설 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 13-13-2",
+      "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
       "개정": [2026],
       "소유": "공용",
       "비고": "식은 9장 같은 꼴 표(9-12-1 등)와 같이 Q=3600×q×k×f×E/㎝",

resources/master_data/수식문서/수식_건설품셈_01장_공통.json

@@ -704,7 +704,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC001013",
-      "이름": "약제살포(동력분무기)",
+      "이름": "약제살포(기계)",
       "결과단위": "원/ℓ",
       "출처": "건설품셈 유지관리 1-2-16",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_01장_도로포장공사.json

@@ -889,7 +889,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000300",
-      "이름": "콘크리트 페이버 조립 및 해체",
+      "이름": "기계포설 장비조립 및 해체",
       "결과단위": "원/회",
       "출처": "건설품셈 토목 1-6-5",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_01장_적용기준.json

@@ -6,7 +6,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC001140",
-      "이름": "인력운반(지게) — 건설 공통 1-2-7",
+      "이름": "지게운반",
       "결과단위": "원/자재 단위",
       "출처": "건설품셈 공통 1-2-7 2 · 3",
       "변수": [
@@ -55,7 +55,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC001141",
-      "이름": "인력운반(기계설비) — 건설 공통 1-2-7",
+      "이름": "인력운반(기계설비)",
       "결과단위": "원/자재 단위",
       "출처": "건설품셈 공통 1-2-7 5",
       "변수": [
@@ -102,7 +102,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC001142",
-      "이름": "벽돌운반 — 건설 공통 1-2-7",
+      "이름": "벽돌운반",
       "결과단위": "원/1,000매",
       "출처": "건설품셈 공통 1-2-7 4",
       "변수": [
@@ -128,6 +128,9 @@
       "이름": "건설폐기물 발생량 — 건설 공통 1-5-4",
       "결과단위": "ton",
       "출처": "건설품셈 공통 1-5-4 2",
+      "부품": {
+        "갈래": "계수식"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "공사", "기호": "S", "아래": "공사", "위": "", "이름": "공사", "단위": "", "설명": "신축 · 해체", "출처": "건설품셈 공통 1-5-4 2", "연결": {"갈래": "선택", "목록": ["신축", "해체"], "값": "신축"}},
@@ -157,6 +160,9 @@
       "이름": "공사용수 — 건설 공통 1-5-6",
       "결과단위": "㎥",
       "출처": "건설품셈 공통 1-5-6 3",
+      "부품": {
+        "갈래": "계수식"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "구분", "기호": "S", "아래": "구분", "위": "", "이름": "구분", "단위": "", "설명": "용수 구분", "출처": "건설품셈 공통 1-5-6 3", "연결": {"갈래": "선택", "목록": ["거푸집씻기", "콘크리트혼합 및 양생", "경량콘크리트혼합 및 양생", "보통벽돌쌓기", "돌쌓기모르타르", "돌씻기", "미장", "타일붙임모르타르", "타일씻기"], "값": "콘크리트혼합 및 양생"}},

resources/master_data/수식문서/수식_건설품셈_01장_철골공사.json

@@ -6,7 +6,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000559",
-      "이름": "철골 공장가공조립(기본철골공수)",
+      "이름": "철골 가공 조립 기본철골공수",
       "결과단위": "원/ton",
       "출처": "건설품셈 건축 1-1-1",
       "변수": [
@@ -51,7 +51,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000560",
-      "이름": "철골 공장용접(기본용접공수)",
+      "이름": "철골 가공 조립 기본용접공수",
       "결과단위": "원/ton",
       "출처": "건설품셈 건축 1-1-3",
       "변수": [
@@ -302,7 +302,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000567",
-      "이름": "타워크레인 가설 · 해체 · 수직이동",
+      "이름": "철골세우기용 장비의 가설 및 해체이동",
       "결과단위": "원/대",
       "출처": "건설품셈 건축 1-2-7",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_03장_토공사.json

@@ -641,6 +641,55 @@
         "끝전": "비목버림"
       }
     },
+    {
+      "꼴": "수식문서",
+      "판": 1,
+      "키": "GC000100",
+      "이름": "암파쇄(유압식 할암공법)",
+      "결과단위": "원/㎥",
+      "출처": "건설품셈 공통 3-3-8",
+      "변수": [
+        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
+        {"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "선택", "목록": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "값": "해당 없음"}},
+        {"열쇠": "드릴경비", "기호": "C", "아래": "드릴", "위": "", "이름": "드릴경비", "단위": "", "연결": {"갈래": "식"}},
+        {"열쇠": "브레이커경비", "기호": "C", "아래": "브레이커", "위": "", "이름": "브레이커경비", "단위": "", "연결": {"갈래": "식"}},
+        {"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(손료 보정 없는 기종)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000268", "입력": {"기계": "'5405-0110'", "지역": "S_지역"}, "칸": "계"}},
+        {"열쇠": "Q_유압식크롤드^표", "기호": "Q", "아래": "유압식크롤드", "위": "표", "이름": "암파쇄(유압식 할암공법).유압식크롤러드릴", "단위": "hr", "연결": {"갈래": "표", "표": "QC000201", "조건": {}, "칸": "유압식크롤러드릴"}},
+        {"열쇠": "P_굴착기무한궤", "기호": "P", "아래": "굴착기무한궤", "위": "", "이름": "굴착기(무한궤도)+대형브레이커 시간당 기계경비", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000271", "입력": {"기계": "'0201-0100'", "브레이커": "'0230-0010'", "지역": "S_지역", "보정작업": "S_보정작업"}, "칸": "계"}},
+        {"열쇠": "Q_굴착기대형브^표", "기호": "Q", "아래": "굴착기대형브", "위": "표", "이름": "암파쇄(유압식 할암공법).굴착기_대형브레이커", "단위": "hr", "연결": {"갈래": "표", "표": "QC000201", "조건": {}, "칸": "굴착기_대형브레이커"}},
+        {"열쇠": "Q_기계설비공^표", "기호": "Q", "아래": "기계설비공", "위": "표", "이름": "암파쇄(유압식 할암공법).기계설비공", "단위": "인", "연결": {"갈래": "표", "표": "QC000201", "조건": {}, "칸": "기계설비공"}},
+        {"열쇠": "w_기계설비공", "기호": "w", "아래": "기계설비공", "위": "", "이름": "기계설비공노임", "단위": "", "연결": {"갈래": "요소", "키": "LB000051"}},
+        {"열쇠": "Q_특별인부^표", "기호": "Q", "아래": "특별인부", "위": "표", "이름": "암파쇄(유압식 할암공법).특별인부", "단위": "인", "연결": {"갈래": "표", "표": "QC000201", "조건": {}, "칸": "특별인부"}},
+        {"열쇠": "w_특별인부", "기호": "w", "아래": "특별인부", "위": "", "이름": "특별인부노임", "단위": "", "연결": {"갈래": "요소", "키": "LB000003"}},
+        {"열쇠": "P_기계시간당2", "기호": "P", "아래": "기계시간당2", "위": "", "이름": "기계 시간당 기계경비(손료 보정 없는 기종)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000268", "입력": {"기계": "'5405-0110'", "지역": "S_지역"}}},
+        {"열쇠": "Q_발전기^표", "기호": "Q", "아래": "발전기", "위": "표", "이름": "암파쇄(유압식 할암공법).발전기", "단위": "hr", "연결": {"갈래": "표", "표": "QC000201", "조건": {}, "칸": "발전기"}},
+        {"열쇠": "P_기계시간당3", "기호": "P", "아래": "기계시간당3", "위": "", "이름": "기계 시간당 기계경비(손료 보정 없는 기종)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000268", "입력": {"기계": "'7505-0025'", "지역": "S_지역"}}},
+        {"열쇠": "Q_유압식할암기^표", "기호": "Q", "아래": "유압식할암기", "위": "표", "이름": "암파쇄(유압식 할암공법).유압식할암기", "단위": "hr", "연결": {"갈래": "표", "표": "QC000201", "조건": {}, "칸": "유압식할암기"}},
+        {"열쇠": "P_기계시간당4", "기호": "P", "아래": "기계시간당4", "위": "", "이름": "기계 시간당 손료(연료·조종원 없는 기종)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000273", "입력": {"기계": "'5501-0080'"}}},
+        {"열쇠": "P_굴착기무한2", "기호": "P", "아래": "굴착기무한2", "위": "", "이름": "굴착기(무한궤도)+대형브레이커 시간당 기계경비", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000271", "입력": {"기계": "'0201-0100'", "브레이커": "'0230-0010'", "지역": "S_지역", "보정작업": "S_보정작업"}}},
+        {"열쇠": "Q_기계경비의^표", "기호": "Q", "아래": "기계경비의", "위": "표", "이름": "소모자재 요율.기계경비의", "단위": "%", "연결": {"갈래": "표", "표": "QC000202", "조건": {"장비": "'유압식 크롤러드릴'"}, "칸": "기계경비의"}},
+        {"열쇠": "Q_기계경비의2^표", "기호": "Q", "아래": "기계경비의2", "위": "표", "이름": "소모자재 요율.기계경비의", "단위": "%", "연결": {"갈래": "표", "표": "QC000202", "조건": {"장비": "'굴착기+대형브레이커'"}, "칸": "기계경비의"}}
+      ],
+      "식": [
+        {"기호": "C_드릴", "식": "P_기계시간당 × Q_유압식크롤드^표"},
+        {"기호": "C_브레이커", "식": "P_굴착기무한궤 × Q_굴착기대형브^표"}
+      ],
+      "금액": [
+        {"이름": "기계설비공", "단위": "인", "비목": "노무비", "수량": "Q_기계설비공^표", "단가": "w_기계설비공", "묶음": "인력"},
+        {"이름": "특별인부", "단위": "인", "비목": "노무비", "수량": "Q_특별인부^표", "단가": "w_특별인부", "묶음": "인력"},
+        {"이름": "유압식 크롤러드릴 110㎾", "단위": "시간", "비목": "묶음", "수량": "Q_유압식크롤드^표", "단가": "P_기계시간당2", "묶음": "유압식 크롤러드릴 110㎾"},
+        {"이름": "발전기 25㎾", "단위": "시간", "비목": "묶음", "수량": "Q_발전기^표", "단가": "P_기계시간당3", "묶음": "발전기 25㎾"},
+        {"이름": "유압식할암기 ∅80", "단위": "시간", "비목": "묶음", "수량": "Q_유압식할암기^표", "단가": "P_기계시간당4", "묶음": "유압식할암기 ∅80"},
+        {"이름": "굴착기+대형브레이커 1.0㎥", "단위": "시간", "비목": "묶음", "수량": "Q_굴착기대형브^표", "단가": "P_굴착기무한2", "묶음": "굴착기+대형브레이커 1.0㎥"},
+        {"이름": "소모자재(크롤러드릴)", "단위": "식", "비목": "재료비", "단가": "C_드릴 × Q_기계경비의^표 ÷ 100", "출처": "건설품셈 공통 3-3-8 주④", "묶음": "소모자재(크롤러드릴) · 소모자재(대형브레이커)"},
+        {"이름": "소모자재(대형브레이커)", "단위": "식", "비목": "재료비", "단가": "C_브레이커 × Q_기계경비의2^표 ÷ 100", "출처": "건설품셈 공통 3-3-8 주④", "묶음": "소모자재(크롤러드릴) · 소모자재(대형브레이커)"}
+      ],
+      "끝수": {
+        "줄": {"방법": "버림", "자리": 1},
+        "비목": {"방법": "버림", "자리": 0},
+        "끝전": "비목버림"
+      }
+    },
     {
       "꼴": "수식문서",
       "판": 1,

resources/master_data/수식문서/수식_건설품셈_05장_기초공사.json

@@ -285,7 +285,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000169",
-      "이름": "앵커 천공(크롤러형 보링장비)",
+      "이름": "앵커 천공",
       "결과단위": "원/공",
       "출처": "건설품셈 공통 5-1-7",
       "변수": [
@@ -1029,7 +1029,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000184",
-      "이름": "PBD천공기 조립 및 해체",
+      "이름": "PBD 장비조립 및 해체",
       "결과단위": "원/회",
       "출처": "건설품셈 공통 5-2-3",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_06장_방수공사.json

@@ -33,7 +33,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000631",
-      "이름": "방수프라이머 바름(롤러 1회)",
+      "이름": "방수프라이머 바름",
       "결과단위": "원/㎡",
       "출처": "건설품셈 건축 6-1-2",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_07장_돌공사.json

@@ -6,7 +6,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000260",
-      "이름": "메쌓기(굴착기+부착용 집게)",
+      "이름": "메쌓기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-1-1",
       "변수": [
@@ -39,7 +39,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000261",
-      "이름": "찰쌓기(굴착기+부착용 집게)",
+      "이름": "찰쌓기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-1-2",
       "변수": [
@@ -72,7 +72,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000262",
-      "이름": "메붙임(굴착기+부착용 집게)",
+      "이름": "메붙임",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-2-1",
       "변수": [
@@ -105,7 +105,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000263",
-      "이름": "찰붙임(굴착기+부착용 집게)",
+      "이름": "찰붙임",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-2-2",
       "변수": [
@@ -138,7 +138,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000264",
-      "이름": "전석쌓기(굴착기+부착용 집게)",
+      "이름": "전석쌓기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-3-1",
       "변수": [
@@ -177,7 +177,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000265",
-      "이름": "전석깔기(굴착기+부착용 집게)",
+      "이름": "전석깔기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 공통 7-3-2",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_08장_건설기계.json

@@ -9,6 +9,9 @@
       "이름": "굴착기(무한궤도) 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"], "값": "0201-0012"}},
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
@@ -55,6 +58,9 @@
       "이름": "기계 시간당 기계경비(손료 보정 없는 기종)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["1730-0015", "7204-0055", "0602-0150", "2702-0020", "0101-0007", "0101-0010", "0101-0012", "0101-0019", "0101-0032", "2105-0005", "2104-0010", "2104-0015", "2104-0020", "2104-0025", "2104-0030", "2104-0035", "2104-0040", "2104-0045", "2104-0050", "2104-0060", "2104-0070", "2104-0080", "2104-0100", "2104-0130", "2104-0160", "2104-0200", "2104-0220", "2104-0250", "2104-0300", "4504-0032", "4504-0036", "4504-0041", "4504-0043", "4504-0047", "4504-0052", "4205-0010", "4205-0017", "4205-0020", "4205-0030", "4205-0040", "4205-0045", "2105-0002", "2105-0003", "2105-0010", "2105-0015", "2105-0018", "2502-0025", "0602-0025", "2502-0050", "2101-0010", "2101-0015", "2101-0020", "2101-0025", "2101-0030", "2101-0035", "2101-0040", "2101-0050", "2101-0070", "2101-0080", "2101-0100", "2101-0150", "2101-0220", "2101-0280", "2101-0300", "7204-0018", "7204-0160", "5205-0210", "5405-0110", "7505-0450", "5205-0255", "7505-0150", "5205-0103", "6701-0147", "6701-0184", "5205-0170", "7505-0350", "0302-0134", "7505-0100", "7505-0050", "5205-0071", "7505-0025", "0502-0036", "1306-0100", "1506-0032", "0121-0004", "1305-0007", "7204-0038", "7204-0065", "0302-0057", "5701-0020", "0302-0095", "3201-0003", "1106-0012", "1406-0015", "1206-0008", "3601-0102", "1306-0025", "0211-0018", "0602-0045", "0602-0060", "0602-0105", "1630-0080", "3901-0300", "7505-0250", "2502-0035", "1306-0120", "1106-0010", "3201-0001", "1406-0008", "3601-0202", "3601-0402", "3611-0142", "2502-0020", "2502-0075", "5205-0035", "2702-0030", "2702-0060"], "값": "1730-0015"}},
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
@@ -97,6 +103,9 @@
       "이름": "기계 시간당 기계경비(8-1-7 손료 보정)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["1730-0015", "7204-0055", "0602-0150", "2702-0020", "0101-0007", "0101-0010", "0101-0012", "0101-0019", "0101-0032", "2105-0005", "2104-0010", "2104-0015", "2104-0020", "2104-0025", "2104-0030", "2104-0035", "2104-0040", "2104-0045", "2104-0050", "2104-0060", "2104-0070", "2104-0080", "2104-0100", "2104-0130", "2104-0160", "2104-0200", "2104-0220", "2104-0250", "2104-0300", "4504-0032", "4504-0036", "4504-0041", "4504-0043", "4504-0047", "4504-0052", "4205-0010", "4205-0017", "4205-0020", "4205-0030", "4205-0040", "4205-0045", "2105-0002", "2105-0003", "2105-0010", "2105-0015", "2105-0018", "2502-0025", "0602-0025", "2502-0050", "2101-0010", "2101-0015", "2101-0020", "2101-0025", "2101-0030", "2101-0035", "2101-0040", "2101-0050", "2101-0070", "2101-0080", "2101-0100", "2101-0150", "2101-0220", "2101-0280", "2101-0300", "7204-0018", "7204-0160", "5205-0210", "5405-0110", "7505-0450", "5205-0255", "7505-0150", "5205-0103", "6701-0147", "6701-0184", "5205-0170", "7505-0350", "0302-0134", "7505-0100", "7505-0050", "5205-0071", "7505-0025", "0502-0036", "1306-0100", "1506-0032", "0121-0004", "1305-0007", "7204-0038", "7204-0065", "0302-0057", "5701-0020", "0302-0095", "3201-0003", "1106-0012", "1406-0015", "1206-0008", "3601-0102", "1306-0025", "0211-0018", "0602-0045", "3901-0300", "7505-0250", "2502-0035", "1306-0120", "1106-0010", "3201-0001", "1406-0008", "3601-0202", "3601-0402", "3611-0142", "2502-0020", "2502-0075", "5205-0035", "2702-0030", "2702-0060", "0102-0015", "0102-0028", "0102-0033", "0121-0013", "0301-0057", "0301-0076", "0301-0095", "0301-0115", "0301-0134", "0301-0153", "0301-0172", "0301-0287", "0602-0060", "0602-0080", "0602-0105"], "값": "1730-0015"}},
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
@@ -145,6 +154,9 @@
       "이름": "굴착기(무한궤도)+부착용 집게 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7 · 8-4-8 주⑤",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["0201-0060", "0201-0080", "0201-0020", "0201-0040", "0201-0070", "0201-0100"], "값": "0201-0060"}},
         {"열쇠": "집게", "기호": "S", "아래": "집게", "위": "", "이름": "집게", "단위": "", "연결": {"갈래": "선택", "목록": ["7206-0070", "7206-0020", "7206-0100"], "값": "7206-0070"}},
@@ -199,6 +211,9 @@
       "이름": "굴착기(무한궤도)+대형브레이커 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7 · 8-4-8 주⑤",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"], "값": "0201-0012"}},
         {"열쇠": "브레이커", "기호": "S", "아래": "브레이커", "위": "", "이름": "브레이커", "단위": "", "연결": {"갈래": "선택", "목록": ["0230-0002", "0230-0004", "0230-0006", "0230-0007", "0230-0008", "0230-0010"], "값": "0230-0002"}},
@@ -253,6 +268,9 @@
       "이름": "기계 시간당 기계경비(조종원 없는 기종)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["4611-0350", "7812-0015", "4506-0200", "4506-0400", "1730-0015", "1630-0080", "1305-0007", "2106-0002", "2106-0003", "2106-0005", "7210-0485", "7360-0090", "6540-0131", "3302-0038", "4430-0400", "7505-0100"], "값": "4611-0350"}},
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
@@ -345,6 +363,9 @@
       "이름": "기계 시간당 기계경비(조종원직종 입력)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["2106-0002", "2106-0003", "2106-0005", "6802-0040", "6802-0060", "6802-0100", "6802-0120", "6802-0135", "6802-0160", "6801-0010", "6803-0100", "6803-0120", "4430-0400", "3302-0038", "3801-0795", "7330-0010", "7954-1119", "7110-0025", "7110-0013", "7120-0746", "7101-0450"], "값": "2106-0002"}},
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
@@ -387,6 +408,9 @@
       "이름": "기계 시간당 기계경비(연료 없는 기종)",
       "결과단위": "원/시간",
       "출처": "건설품셈 공통 8-1-5 · 8-1-6",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["5401-0017"], "값": "5401-0017"}},
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
@@ -423,6 +447,9 @@
       "이름": "시공능력 산정 기본식 Q = n·q·f·E — 건설 공통 8-1-4",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-1-4",
+      "부품": {
+        "갈래": "계수식"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "싸이클시간", "기호": "cm", "아래": "", "위": "", "이름": "싸이클시간", "단위": "", "설명": "1회 작업싸이클 시간(cm)", "출처": "건설품셈 공통 8-1-4 주⑤", "연결": {"갈래": "입력", "값": 21}},
@@ -451,6 +478,10 @@
       "이름": "불도저 시간당 작업량 — 건설 공통 8-2-1",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-1",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["불도저"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "종별", "기호": "S", "아래": "종별", "위": "", "이름": "종별", "단위": "", "설명": "불도저 종별", "출처": "건설품셈 공통 8-2-1 1 가", "연결": {"갈래": "선택", "목록": ["무한궤도", "타이어"], "값": "무한궤도"}},
@@ -500,42 +531,6 @@
         "끝전": "비목버림"
       }
     },
-    {
-      "꼴": "수식문서",
-      "판": 1,
-      "키": "GC001145",
-      "이름": "불도저 작업량당 기계경비 — 건설 공통 8-2-1",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-1 · 건설품셈 공통 8-1-4",
-      "변수": [
-        {"열쇠": "종별", "기호": "S", "아래": "종별", "위": "", "이름": "종별", "단위": "", "설명": "불도저 종별", "출처": "건설품셈 공통 8-2-1 1 가", "연결": {"갈래": "선택", "목록": ["무한궤도", "타이어"], "값": "무한궤도"}},
-        {"열쇠": "급수", "기호": "S", "아래": "급수", "위": "", "이름": "급수", "단위": "", "설명": "불도저 급수(ton)", "출처": "건설품셈 공통 8-2-1 1 가", "연결": {"갈래": "선택", "목록": ["4(초습지)", "7", "10", "12", "13(습지)", "19", "32", "15", "28", "33"], "값": "19"}},
-        {"열쇠": "운반거리", "기호": "L", "아래": "", "위": "", "이름": "운반거리", "단위": "m", "설명": "운반거리(L)", "출처": "건설품셈 공통 8-2-1 2", "연결": {"갈래": "입력", "값": 30}},
-        {"열쇠": "거리구분", "기호": "S", "아래": "거리구분", "위": "", "이름": "거리구분", "단위": "", "설명": "운반거리계수(e) 표의 거리 칸", "출처": "건설품셈 공통 8-2-1 1 나", "연결": {"갈래": "선택", "목록": ["10이하", "20", "30", "40", "50", "60", "70", "80"], "값": "30"}},
-        {"열쇠": "현장조건", "기호": "S", "아래": "현장조건", "위": "", "이름": "현장조건", "단위": "", "설명": "흙 상태", "출처": "건설품셈 공통 8-2-1 1 다", "연결": {"갈래": "선택", "목록": ["자연상태", "흐트러진 상태"], "값": "자연상태"}},
-        {"열쇠": "등급", "기호": "S", "아래": "등급", "위": "", "이름": "등급", "단위": "", "설명": "작업 조건 등급", "출처": "건설품셈 공통 8-2-1 1 다", "연결": {"갈래": "선택", "목록": ["양호", "보통", "불량"], "값": "보통"}},
-        {"열쇠": "토질명", "기호": "S", "아래": "토질명", "위": "", "이름": "토질명", "단위": "", "설명": "토질", "출처": "건설품셈 공통 8-2-1 1 다", "연결": {"갈래": "선택", "목록": ["모래, 사질토", "자갈섞인 흙, 점성토", "파쇄암"], "값": "모래, 사질토"}},
-        {"열쇠": "E보정", "기호": "E", "아래": "보정", "위": "", "이름": "E보정", "단위": "", "설명": "작업효율에서 뺄 경우", "출처": "건설품셈 공통 8-2-1 1 다 주", "연결": {"갈래": "선택", "목록": ["해당 없음", "정지작업을 겸하는 경우", "터파기"], "값": "해당 없음"}},
-        {"열쇠": "전진단", "기호": "S", "아래": "전진단", "위": "", "이름": "전진단", "단위": "", "설명": "전진 기어 단", "출처": "건설품셈 공통 8-2-1 2 주", "연결": {"갈래": "선택", "목록": [1, 2, 3, 4], "값": 1}},
-        {"열쇠": "후진단", "기호": "S", "아래": "후진단", "위": "", "이름": "후진단", "단위": "", "설명": "후진 기어 단", "출처": "건설품셈 공통 8-2-1 2 주", "연결": {"갈래": "선택", "목록": [1, 2, 3], "값": 1}},
-        {"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4", "연결": {"갈래": "입력", "값": 1}},
-        {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "출처": "건설품셈 공통 8-2-1", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
-        {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "설명": "불도저 규격", "연결": {"갈래": "선택", "목록": ["0101-0007", "0101-0010", "0101-0012", "0101-0019", "0101-0032", "0102-0015", "0102-0028", "0102-0033", "0121-0004", "0121-0013"], "값": "0101-0007"}},
-        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
-        {"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "선택", "목록": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "값": "해당 없음"}},
-        {"열쇠": "작업량", "기호": "Q", "아래": "", "위": "", "이름": "시간당 작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GC001144", "입력": {"종별": "S_종별", "급수": "S_급수", "운반거리": "L", "거리구분": "S_거리구분", "현장조건": "S_현장조건", "등급": "S_등급", "토질명": "S_토질명", "E보정": "E_보정", "전진단": "S_전진단", "후진단": "S_후진단", "f": "f", "E입력": "E_입력"}}},
-        {"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(8-1-7 손료 보정)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000269", "입력": {"기계": "S_기계", "지역": "S_지역", "보정작업": "S_보정작업"}}}
-      ],
-      "식": [],
-      "금액": [
-        {"이름": "불도저", "단위": "시간", "비목": "묶음", "수량": "1 ÷ Q", "단가": "P_기계시간당", "출처": "건설품셈 공통 8-1-4"}
-      ],
-      "끝수": {
-        "줄": {"방법": "버림", "자리": 1},
-        "비목": {"방법": "버림", "자리": 0},
-        "끝전": "비목버림"
-      }
-    },
     {
       "꼴": "수식문서",
       "판": 1,
@@ -543,6 +538,10 @@
       "이름": "리퍼(유압식) 시간당 파쇄량 — 건설 공통 8-2-2",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["유압식 리퍼"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "트랙터 규격(ton)", "출처": "건설품셈 공통 8-2-2 1", "연결": {"갈래": "선택", "목록": [20, 30], "값": 20}},
@@ -579,6 +578,11 @@
       "이름": "굴착기 시간당 작업량 — 건설 공통 8-2-3",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-3",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "버킷용량"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "버킷용량", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "㎥", "설명": "버킷용량(q)", "출처": "건설품셈 공통 8-2-3", "연결": {"갈래": "입력", "값": 1}},
@@ -616,42 +620,6 @@
         "끝전": "비목버림"
       }
     },
-    {
-      "꼴": "수식문서",
-      "판": 1,
-      "키": "GC001148",
-      "이름": "굴착기(무한궤도) 작업량당 기계경비 — 건설 공통 8-2-3",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-3 · 건설품셈 공통 8-1-4",
-      "변수": [
-        {"열쇠": "버킷용량", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "㎥", "설명": "버킷용량(q)", "출처": "건설품셈 공통 8-2-3", "연결": {"갈래": "입력", "값": 1}},
-        {"열쇠": "규격구분", "기호": "S", "아래": "규격구분", "위": "", "이름": "규격구분", "단위": "㎥", "설명": "싸이클시간 표의 규격 칸", "출처": "건설품셈 공통 8-2-3 3", "연결": {"갈래": "선택", "목록": ["0.12∼0.4", "0.6∼0.8", "1.0∼1.2", "2.0"], "값": "1.0∼1.2"}},
-        {"열쇠": "선회각도", "기호": "θ", "아래": "선회", "위": "", "이름": "선회각도", "단위": "도", "설명": "선회 각도", "출처": "건설품셈 공통 8-2-3 3", "연결": {"갈래": "선택", "목록": [45, 90, 135, 180], "값": 135}},
-        {"열쇠": "버킷조건", "기호": "S", "아래": "버킷조건", "위": "", "이름": "버킷조건", "단위": "", "설명": "버킷계수(K) 현장조건", "출처": "건설품셈 공통 8-2-3 1", "연결": {"갈래": "선택", "목록": ["용이하게 굴착할 수 있는 연한 토질로서 버킷에 산적으로 가득찰 때가 많은 조건이 좋은 모래, 보통토인 경우", "위의 토질보다 약간 단단한 토질로서 버킷에 거의 가득 채울 수 있는 모래, 보통토 및 조건이 좋은 점토인 경우", "버킷에 가득 채우기가 어렵거나 가벼운 발파를 필요로 하는 것으로서 단단한 점토질, 점토, 역토질인 경우", "버킷에 넣기 어렵고 불규칙한 공극이 생기는 것으로서 발파 또는 리퍼작업 등에 의하여 얻어진 암과 파쇄암, 호박돌, 역 등인 경우"], "값": "위의 토질보다 약간 단단한 토질로서 버킷에 거의 가득 채울 수 있는 모래, 보통토 및 조건이 좋은 점토인 경우"}},
-        {"열쇠": "현장조건", "기호": "S", "아래": "현장조건", "위": "", "이름": "현장조건", "단위": "", "설명": "흙 상태", "출처": "건설품셈 공통 8-2-3 2", "연결": {"갈래": "선택", "목록": ["자연상태", "흐트러진 상태"], "값": "흐트러진 상태"}},
-        {"열쇠": "등급", "기호": "S", "아래": "등급", "위": "", "이름": "등급", "단위": "", "설명": "작업 조건 등급", "출처": "건설품셈 공통 8-2-3 2", "연결": {"갈래": "선택", "목록": ["양호", "보통", "불량"], "값": "보통"}},
-        {"열쇠": "토질명", "기호": "S", "아래": "토질명", "위": "", "이름": "토질명", "단위": "", "설명": "토질", "출처": "건설품셈 공통 8-2-3 2", "연결": {"갈래": "선택", "목록": ["모래, 사질토", "자갈섞인 흙, 점성토", "파쇄암"], "값": "모래, 사질토"}},
-        {"열쇠": "E보정", "기호": "E", "아래": "보정", "위": "", "이름": "E보정", "단위": "", "설명": "작업효율에서 뺄 경우", "출처": "건설품셈 공통 8-2-3 2 주", "연결": {"갈래": "선택", "목록": ["해당 없음", "터파기"], "값": "해당 없음"}},
-        {"열쇠": "협소현장", "기호": "S", "아래": "협소현장", "위": "", "이름": "협소현장", "단위": "", "설명": "주택가 상하수도관로부설 등 협소현장(주⑦)", "출처": "건설품셈 공통 8-2-3 2 주⑦", "연결": {"갈래": "선택", "목록": ["해당 없음", "상하수도관로부설 등 협소현장"], "값": "해당 없음"}},
-        {"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4", "연결": {"갈래": "입력", "값": 0.7}},
-        {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "출처": "건설품셈 공통 8-2-3", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
-        {"열쇠": "싸이클입력", "기호": "X", "아래": "싸이클", "위": "", "이름": "싸이클입력", "단위": "sec", "설명": "1회 싸이클시간을 직접 넣을 때 — 0 이면 표", "출처": "건설품셈 공통 8-2-3 3", "연결": {"갈래": "입력", "값": 0, "범위": [0, 30]}},
-        {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "설명": "굴착기(무한궤도) 규격", "연결": {"갈래": "선택", "목록": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"], "값": "0201-0012"}},
-        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
-        {"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "선택", "목록": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "값": "해당 없음"}},
-        {"열쇠": "작업량", "기호": "Q", "아래": "", "위": "", "이름": "시간당 작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GC001147", "입력": {"버킷용량": "q", "규격구분": "S_규격구분", "선회각도": "θ_선회", "버킷조건": "S_버킷조건", "현장조건": "S_현장조건", "등급": "S_등급", "토질명": "S_토질명", "E보정": "E_보정", "협소현장": "S_협소현장", "f": "f", "E입력": "E_입력", "싸이클입력": "X_싸이클"}}},
-        {"열쇠": "P_굴착기무한궤", "기호": "P", "아래": "굴착기무한궤", "위": "", "이름": "굴착기(무한궤도) 시간당 기계경비", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000267", "입력": {"기계": "S_기계", "지역": "S_지역", "보정작업": "S_보정작업"}}}
-      ],
-      "식": [],
-      "금액": [
-        {"이름": "굴착기(무한궤도)", "단위": "시간", "비목": "묶음", "수량": "1 ÷ Q", "단가": "P_굴착기무한궤", "출처": "건설품셈 공통 8-1-4"}
-      ],
-      "끝수": {
-        "줄": {"방법": "버림", "자리": 1},
-        "비목": {"방법": "버림", "자리": 0},
-        "끝전": "비목버림"
-      }
-    },
     {
       "꼴": "수식문서",
       "판": 1,
@@ -659,6 +627,10 @@
       "이름": "트랜처 시간당 작업량 — 건설 공통 8-2-4",
       "결과단위": "m/hr",
       "출처": "건설품셈 공통 8-2-4",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["트랜처"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "작업거리", "기호": "L", "아래": "", "위": "", "이름": "작업거리", "단위": "m", "설명": "1열 실작업거리(L · 편도)", "출처": "건설품셈 공통 8-2-4 2", "연결": {"갈래": "입력", "값": 100}},
@@ -701,6 +673,11 @@
       "이름": "로더 운전시간당 작업량 — 건설 공통 8-2-5",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-5",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["로더"],
+        "규격": "버킷용량"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "기종", "기호": "S", "아래": "기종", "위": "", "이름": "기종", "단위": "", "설명": "로더 기종", "출처": "건설품셈 공통 8-2-5 1", "연결": {"갈래": "선택", "목록": ["무한궤도식", "타이어식"], "값": "타이어식"}},
@@ -746,43 +723,6 @@
         "끝전": "비목버림"
       }
     },
-    {
-      "꼴": "수식문서",
-      "판": 1,
-      "키": "GC001151",
-      "이름": "로더 작업량당 기계경비 — 건설 공통 8-2-5",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-5 · 건설품셈 공통 8-1-4",
-      "변수": [
-        {"열쇠": "기종", "기호": "S", "아래": "기종", "위": "", "이름": "기종", "단위": "", "설명": "로더 기종", "출처": "건설품셈 공통 8-2-5 1", "연결": {"갈래": "선택", "목록": ["무한궤도식", "타이어식"], "값": "타이어식"}},
-        {"열쇠": "버킷용량", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "㎥", "설명": "버킷용량(q)", "출처": "건설품셈 공통 8-2-5", "연결": {"갈래": "입력", "값": 1.34}},
-        {"열쇠": "작업방법", "기호": "S", "아래": "작업방법", "위": "", "이름": "작업방법", "단위": "", "설명": "버킷에 담는 방법", "출처": "건설품셈 공통 8-2-5 1", "연결": {"갈래": "선택", "목록": ["산적상태에서 담을 때", "지면부터 굴착 집토하여 담을 때"], "값": "산적상태에서 담을 때"}},
-        {"열쇠": "적재조건", "기호": "S", "아래": "적재조건", "위": "", "이름": "적재조건", "단위": "", "설명": "t1 현장조건", "출처": "건설품셈 공통 8-2-5 1", "연결": {"갈래": "선택", "목록": ["용이한 경우", "보통인 경우", "약간곤란한 경우", "곤란한 경우"], "값": "보통인 경우"}},
-        {"열쇠": "K표", "기호": "K", "아래": "표", "위": "", "이름": "K표", "단위": "", "설명": "버킷계수 표 갈래", "출처": "건설품셈 공통 8-2-5 2", "연결": {"갈래": "선택", "목록": ["산적상태 적재", "자연상태·기타 적재"], "값": "산적상태 적재"}},
-        {"열쇠": "K조건", "기호": "K", "아래": "조건", "위": "", "이름": "K조건", "단위": "", "설명": "버킷계수 현장조건(고른 표의 줄)", "출처": "건설품셈 공통 8-2-5 2", "연결": {"갈래": "선택", "목록": ["굴착기계로 깎거나 쌓아모은 산적상태에서 적재하는 것으로 굴착력을 필요로 하지 않고 쉽게 버킷에 산적할 수 있는 것, 즉 조건이 좋은 모래, 보통토 등", "흐트러진 산적상태에서 적재하는 것으로 위 상태보다 약간 삽날이 들어가기 어려운 토질로서 버킷에 가득 채울 수 있는 것, 즉 점토, 역질토", "모래, 사력보통토, 점토, 역질토 등 직접 자연상태에서 굴착적재 할 수 있는 여건으로 버킷에 평적에 약간 미달되게 채울 수 있는 것", "버킷에 가득 채울 수 없는 것으로 다른 기계로 쌓아 모아놓은 부순돌 및 점질토나 역질토로서 굳어진 덩어리상태로 되어 있는 것", "버킷에 넣기 어렵고 허술하며 불규칙한 공극이 생긴 것, 예를 들면 발파 또는 리퍼로 깎은 암괴, 호박돌, 역 등"], "값": "굴착기계로 깎거나 쌓아모은 산적상태에서 적재하는 것으로 굴착력을 필요로 하지 않고 쉽게 버킷에 산적할 수 있는 것, 즉 조건이 좋은 모래, 보통토 등"}},
-        {"열쇠": "주행거리", "기호": "ℓ", "아래": "", "위": "", "이름": "주행거리", "단위": "m", "설명": "편도주행거리(ℓ) — 0 이면 표준 8m", "출처": "건설품셈 공통 8-2-5", "연결": {"갈래": "입력", "값": 0}},
-        {"열쇠": "현장조건", "기호": "S", "아래": "현장조건", "위": "", "이름": "현장조건", "단위": "", "설명": "흙 상태", "출처": "건설품셈 공통 8-2-5 3", "연결": {"갈래": "선택", "목록": ["자연상태", "흐트러진 상태"], "값": "흐트러진 상태"}},
-        {"열쇠": "등급", "기호": "S", "아래": "등급", "위": "", "이름": "등급", "단위": "", "설명": "작업 조건 등급", "출처": "건설품셈 공통 8-2-5 3", "연결": {"갈래": "선택", "목록": ["양호", "보통", "불량"], "값": "양호"}},
-        {"열쇠": "토질명", "기호": "S", "아래": "토질명", "위": "", "이름": "토질명", "단위": "", "설명": "토질", "출처": "건설품셈 공통 8-2-5 3", "연결": {"갈래": "선택", "목록": ["모래, 사질토", "자갈섞인 흙, 점성토", "파쇄암"], "값": "모래, 사질토"}},
-        {"열쇠": "E보정", "기호": "E", "아래": "보정", "위": "", "이름": "E보정", "단위": "", "설명": "작업효율에서 뺄 경우", "출처": "건설품셈 공통 8-2-5 3 주", "연결": {"갈래": "선택", "목록": ["해당 없음", "터파기"], "값": "해당 없음"}},
-        {"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4", "연결": {"갈래": "입력", "값": 1}},
-        {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "출처": "건설품셈 공통 8-2-5", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
-        {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "설명": "로더 규격", "연결": {"갈래": "선택", "목록": ["0301-0057", "0301-0076", "0301-0095", "0301-0115", "0301-0134", "0301-0153", "0301-0172", "0301-0287", "0302-0057", "0302-0095", "0302-0134"], "값": "0301-0057"}},
-        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
-        {"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "선택", "목록": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "값": "해당 없음"}},
-        {"열쇠": "작업량", "기호": "Q", "아래": "", "위": "", "이름": "운전시간당 작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GC001150", "입력": {"기종": "S_기종", "버킷용량": "q", "작업방법": "S_작업방법", "적재조건": "S_적재조건", "K표": "K_표", "K조건": "K_조건", "주행거리": "ℓ", "현장조건": "S_현장조건", "등급": "S_등급", "토질명": "S_토질명", "E보정": "E_보정", "f": "f", "E입력": "E_입력"}}},
-        {"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(8-1-7 손료 보정)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000269", "입력": {"기계": "S_기계", "지역": "S_지역", "보정작업": "S_보정작업"}}}
-      ],
-      "식": [],
-      "금액": [
-        {"이름": "로더", "단위": "시간", "비목": "묶음", "수량": "1 ÷ Q", "단가": "P_기계시간당", "출처": "건설품셈 공통 8-1-4"}
-      ],
-      "끝수": {
-        "줄": {"방법": "버림", "자리": 1},
-        "비목": {"방법": "버림", "자리": 0},
-        "끝전": "비목버림"
-      }
-    },
     {
       "꼴": "수식문서",
       "판": 1,
@@ -790,6 +730,10 @@
       "이름": "모터 스크레이퍼 시간당 작업량 — 건설 공통 8-2-6",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-6",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["스크레이퍼"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "적재함용적", "기호": "V", "아래": "적재함", "위": "", "이름": "적재함용적", "단위": "㎥", "설명": "적재함 용적", "출처": "건설품셈 공통 8-2-6", "연결": {"갈래": "입력", "값": 10}},
@@ -834,6 +778,10 @@
       "이름": "모터 그레이더 1시간당 작업면적 — 건설 공통 8-2-7",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-7",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["모터그레이더"]
+      },
       "결과": "A",
       "변수": [
         {"열쇠": "작업거리", "기호": "D", "아래": "", "위": "", "이름": "작업거리", "단위": "m", "설명": "1회의 작업거리(D · 편도)", "출처": "건설품셈 공통 8-2-7", "연결": {"갈래": "입력", "값": 100}},
@@ -874,6 +822,10 @@
       "이름": "모터 그레이더 1시간당 작업토량 — 건설 공통 8-2-7",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-7",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["모터그레이더"]
+      },
       "결과": "A",
       "변수": [
         {"열쇠": "작업거리", "기호": "D", "아래": "", "위": "", "이름": "작업거리", "단위": "m", "설명": "1회의 작업거리(D · 편도)", "출처": "건설품셈 공통 8-2-7", "연결": {"갈래": "입력", "값": 100}},
@@ -917,6 +869,11 @@
       "이름": "덤프트럭 1시간당 작업량 — 건설 공통 8-2-8",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-8",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["덤프트럭"],
+        "규격": "적재용량"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "적재용량", "기호": "T", "아래": "", "위": "", "이름": "적재용량", "단위": "ton", "설명": "덤프트럭의 적재용량(T)", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "입력", "값": 15}},
@@ -974,48 +931,6 @@
         "끝전": "비목버림"
       }
     },
-    {
-      "꼴": "수식문서",
-      "판": 1,
-      "키": "GC001156",
-      "이름": "덤프트럭 작업량당 기계경비 — 건설 공통 8-2-8",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-8 · 건설품셈 공통 8-1-4",
-      "변수": [
-        {"열쇠": "적재용량", "기호": "T", "아래": "", "위": "", "이름": "적재용량", "단위": "ton", "설명": "덤프트럭의 적재용량(T)", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "입력", "값": 15}},
-        {"열쇠": "단위중량", "기호": "W", "아래": "단위", "위": "", "이름": "단위중량", "단위": "ton/㎥", "설명": "자연상태 토석의 단위중량(γt · 습윤밀도)", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "입력", "값": 1.8}},
-        {"열쇠": "체적변화율", "기호": "L", "아래": "", "위": "", "이름": "체적변화율", "단위": "", "설명": "체적환산계수에서의 체적변화율(L = 흐트러진/자연)", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "입력", "값": 1.25}},
-        {"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "설명": "체적환산계수", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "입력", "값": 0.7}},
-        {"열쇠": "운반거리", "기호": "L", "아래": "운반", "위": "", "이름": "운반거리", "단위": "㎞", "설명": "운반거리(편도)", "출처": "건설품셈 공통 8-2-8 2", "연결": {"갈래": "입력", "값": 0.08}},
-        {"열쇠": "도로상태", "기호": "S", "아래": "도로상태", "위": "", "이름": "도로상태", "단위": "", "설명": "운반도로 상태", "출처": "건설품셈 공통 8-2-8 3", "연결": {"갈래": "선택", "목록": ["토취장 또는 토사장 등 열악한 조건의 도로", "교차가 힘든 산간지도로 및 제방 등의 도로", "교차가 가능한 산간지도로 및 제방도로, 미포장도로", "2차로 이상의 공사용도로", "2차로 교통량 및 교통대기가 많은 시가지 포장도로(7,000대/일 이상)", "4차로 이상의 교통량 및 교통대기가 많은 시가지 포장도로(40,000대/일 이상)", "2차로 시가지 포장도로(7,000∼2,000대/일)", "4차로 이상의 시가지 포장도로(40,000대/일 미만)", "2차로 교외 포장도로(2,000대/일 이상)", "4차로 이상의 교외 포장도로(40,000대/일 이상)", "2차로 교외 포장도로(2,000대/일 미만)", "4차로 이상의 교외 포장도로(40,000대/일 미만)", "2차로 고속도로 또는 교통량(편도) 1일 40,000대 이상의 4차로 고속도로", "4차로 고속도로(편도 교통량 1일 40,000대 미만)"], "값": "교차가 힘든 산간지도로 및 제방 등의 도로"}},
-        {"열쇠": "적하토질", "기호": "S", "아래": "적하토질", "위": "", "이름": "적하토질", "단위": "", "설명": "적하시간 표의 토질", "출처": "건설품셈 공통 8-2-8 4", "연결": {"갈래": "선택", "목록": ["모래, 역, 호박돌", "점질토, 점토"], "값": "모래, 역, 호박돌"}},
-        {"열쇠": "적하조건", "기호": "S", "아래": "적하조건", "위": "", "이름": "적하조건", "단위": "", "설명": "적하 작업조건", "출처": "건설품셈 공통 8-2-8 4", "연결": {"갈래": "선택", "목록": ["양호", "보통", "불량"], "값": "불량"}},
-        {"열쇠": "적재장소", "기호": "S", "아래": "적재장소", "위": "", "이름": "적재장소", "단위": "", "설명": "적재장소 진입 조건(t4)", "출처": "건설품셈 공통 8-2-8 5", "연결": {"갈래": "선택", "목록": ["적재장소가 넓어서 트럭이 자유로이 목적장소에 진입할 수 있을 때", "적재장소가 넓지는 않으나 목적장소에 불편없이 진입할 수 있을 때", "적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때"], "값": "적재장소가 넓지는 않으나 목적장소에 불편없이 진입할 수 있을 때"}},
-        {"열쇠": "덮개", "기호": "S", "아래": "덮개", "위": "", "이름": "덮개", "단위": "", "설명": "적재함 덮개 설치 · 해체(t5)", "출처": "건설품셈 공통 8-2-8 6", "연결": {"갈래": "선택", "목록": ["해당 없음", "인력에 의한 경우", "자동덮개시설의 경우"], "값": "해당 없음"}},
-        {"열쇠": "세륜", "기호": "S", "아래": "세륜", "위": "", "이름": "세륜", "단위": "", "설명": "세륜기 통과(t6)", "출처": "건설품셈 공통 8-2-8 7", "연결": {"갈래": "선택", "목록": ["안 함", "함"], "값": "안 함"}},
-        {"열쇠": "적재방법", "기호": "S", "아래": "적재방법", "위": "", "이름": "적재방법", "단위": "", "설명": "적재시간(t1) 산출 갈래", "출처": "건설품셈 공통 8-2-8 1 · 8 · 9", "연결": {"갈래": "선택", "목록": ["적재기계", "인력", "직접 입력"], "값": "적재기계"}},
-        {"열쇠": "적재싸이클", "기호": "cms", "아래": "", "위": "", "이름": "적재싸이클", "단위": "sec", "설명": "적재기계의 1회 싸이클시간(cms)", "출처": "건설품셈 공통 8-2-8 8", "연결": {"갈래": "입력", "값": 21}},
-        {"열쇠": "적재버킷", "기호": "q", "아래": "", "위": "", "이름": "적재버킷", "단위": "㎥", "설명": "적재기계의 버킷용량(q)", "출처": "건설품셈 공통 8-2-8 8", "연결": {"갈래": "입력", "값": 1}},
-        {"열쇠": "버킷계수", "기호": "k", "아래": "", "위": "", "이름": "버킷계수", "단위": "", "설명": "적재기계의 버킷계수(k)", "출처": "건설품셈 공통 8-2-8 8", "연결": {"갈래": "입력", "값": 0.9}},
-        {"열쇠": "적재효율", "기호": "Es", "아래": "", "위": "", "이름": "적재효율", "단위": "", "설명": "적재기계의 작업효율(Es)", "출처": "건설품셈 공통 8-2-8 8", "연결": {"갈래": "입력", "값": 0.75}},
-        {"열쇠": "인력종류", "기호": "S", "아래": "인력종류", "위": "", "이름": "인력종류", "단위": "", "설명": "인력 적재 종류", "출처": "건설품셈 공통 8-2-8 9", "연결": {"갈래": "선택", "목록": ["토사류", "석재류"], "값": "토사류"}},
-        {"열쇠": "적재시간입력", "기호": "T", "아래": "적재", "위": "", "이름": "적재시간입력", "단위": "분", "설명": "적재시간(t1)을 직접 넣을 때(적재방법 「직접 입력」)", "출처": "건설품셈 공통 8-2-8 1", "연결": {"갈래": "입력", "값": 0}},
-        {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 0.9", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
-        {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "설명": "덤프트럭 규격", "연결": {"갈래": "선택", "목록": ["0602-0025", "0602-0045", "0602-0060", "0602-0105", "0602-0150"], "값": "0602-0025"}},
-        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
-        {"열쇠": "작업량", "기호": "Q", "아래": "", "위": "", "이름": "1시간당 작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GC001155", "입력": {"적재용량": "T", "단위중량": "W_단위", "체적변화율": "L", "f": "f", "운반거리": "L_운반", "도로상태": "S_도로상태", "적하토질": "S_적하토질", "적하조건": "S_적하조건", "적재장소": "S_적재장소", "덮개": "S_덮개", "세륜": "S_세륜", "적재방법": "S_적재방법", "적재싸이클": "cms", "적재버킷": "q", "버킷계수": "k", "적재효율": "Es", "인력종류": "S_인력종류", "적재시간입력": "T_적재", "E입력": "E_입력"}}},
-        {"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(손료 보정 없는 기종)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000268", "입력": {"기계": "S_기계", "지역": "S_지역"}}}
-      ],
-      "식": [],
-      "금액": [
-        {"이름": "덤프트럭", "단위": "시간", "비목": "묶음", "수량": "1 ÷ Q", "단가": "P_기계시간당", "출처": "건설품셈 공통 8-1-4"}
-      ],
-      "끝수": {
-        "줄": {"방법": "버림", "자리": 1},
-        "비목": {"방법": "버림", "자리": 0},
-        "끝전": "비목버림"
-      }
-    },
     {
       "꼴": "수식문서",
       "판": 1,
@@ -1023,6 +938,10 @@
       "이름": "롤러 시간당 다짐토량 — 건설 공통 8-2-9",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-9",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "다짐기계", "기호": "S", "아래": "다짐기계", "위": "", "이름": "다짐기계", "단위": "", "설명": "다짐기계", "출처": "건설품셈 공통 8-2-9 1", "연결": {"갈래": "선택", "목록": ["머캐덤롤러", "탠덤롤러", "타이어롤러", "불도저", "자주식, 양족식 롤러", "진동롤러(자주식)"], "값": "타이어롤러"}},
@@ -1065,6 +984,10 @@
       "이름": "롤러 시간당 다짐면적 — 건설 공통 8-2-9",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-9",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "다짐기계", "기호": "S", "아래": "다짐기계", "위": "", "이름": "다짐기계", "단위": "", "설명": "다짐기계", "출처": "건설품셈 공통 8-2-9 1", "연결": {"갈래": "선택", "목록": ["머캐덤롤러", "탠덤롤러", "타이어롤러", "불도저", "자주식, 양족식 롤러", "진동롤러(자주식)"], "값": "타이어롤러"}},
@@ -1098,39 +1021,6 @@
         "끝전": "비목버림"
       }
     },
-    {
-      "꼴": "수식문서",
-      "판": 1,
-      "키": "GC001159",
-      "이름": "롤러 작업량당 기계경비 — 건설 공통 8-2-9",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-9 · 건설품셈 공통 8-1-4",
-      "변수": [
-        {"열쇠": "다짐기계", "기호": "S", "아래": "다짐기계", "위": "", "이름": "다짐기계", "단위": "", "설명": "다짐기계", "출처": "건설품셈 공통 8-2-9 1", "연결": {"갈래": "선택", "목록": ["머캐덤롤러", "탠덤롤러", "타이어롤러", "불도저", "자주식, 양족식 롤러", "진동롤러(자주식)"], "값": "타이어롤러"}},
-        {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "다짐기계 규격(ton)", "출처": "건설품셈 공통 8-2-9 1", "연결": {"갈래": "선택", "목록": ["6∼8", "8∼10", "10∼12", "12∼15", "5∼8", "10∼14", "8∼15", "15∼25", "12", "19", "2.5", "4.4", "6.0", "10.0"], "값": "8∼15"}},
-        {"열쇠": "다짐층", "기호": "S", "아래": "다짐층", "위": "", "이름": "다짐층", "단위": "", "설명": "표준다짐속도 칸", "출처": "건설품셈 공통 8-2-9 1", "연결": {"갈래": "선택", "목록": ["노체, 축제, 노상", "보조기층, 기층", "표층"], "값": "노체, 축제, 노상"}},
-        {"열쇠": "다짐횟수", "기호": "N", "아래": "", "위": "", "이름": "다짐횟수", "단위": "회", "설명": "소요다짐횟수(N)", "출처": "건설품셈 공통 8-2-9 2", "연결": {"갈래": "입력", "값": 4}},
-        {"열쇠": "E공종", "기호": "E", "아래": "공종", "위": "", "이름": "E공종", "단위": "", "설명": "작업효율 표의 공종", "출처": "건설품셈 공통 8-2-9 3", "연결": {"갈래": "선택", "목록": ["표층", "기층, 보조기층", "노체, 축제, 노상"], "값": "노체, 축제, 노상"}},
-        {"열쇠": "E기계", "기호": "E", "아래": "기계", "위": "", "이름": "E기계", "단위": "", "설명": "작업효율 표의 다짐기계", "출처": "건설품셈 공통 8-2-9 3", "연결": {"갈래": "선택", "목록": ["머캐덤롤러", "타이어롤러", "탠덤롤러", "진동롤러", "불도저", "양족식롤러(자주식)"], "값": "불도저"}},
-        {"열쇠": "현장조건", "기호": "S", "아래": "현장조건", "위": "", "이름": "현장조건", "단위": "", "설명": "작업 조건", "출처": "건설품셈 공통 8-2-9 3", "연결": {"갈래": "선택", "목록": ["양호", "보통", "불량"], "값": "보통"}},
-        {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 표 값", "출처": "건설품셈 공통 8-2-9", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
-        {"열쇠": "두께", "기호": "D", "아래": "", "위": "", "이름": "두께", "단위": "m", "설명": "펴는 흙의 두께(D · 다져진 상태)", "출처": "건설품셈 공통 8-2-9 2 주②", "연결": {"갈래": "입력", "값": 0.3}},
-        {"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "설명": "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", "출처": "건설품셈 공통 8-1-4", "연결": {"갈래": "입력", "값": 1}},
-        {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "설명": "롤러 규격", "연결": {"갈래": "선택", "목록": ["1106-0010", "1106-0012", "1206-0008", "1305-0007", "1306-0025", "1306-0100", "1306-0120", "1406-0008", "1406-0015", "1506-0032"], "값": "1106-0010"}},
-        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
-        {"열쇠": "작업량", "기호": "Q", "아래": "", "위": "", "이름": "시간당 다짐토량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GC001157", "입력": {"다짐기계": "S_다짐기계", "규격": "S_규격", "다짐층": "S_다짐층", "다짐횟수": "N", "E공종": "E_공종", "E기계": "E_기계", "현장조건": "S_현장조건", "E입력": "E_입력", "두께": "D", "f": "f"}}},
-        {"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(손료 보정 없는 기종)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000268", "입력": {"기계": "S_기계", "지역": "S_지역"}}}
-      ],
-      "식": [],
-      "금액": [
-        {"이름": "롤러", "단위": "시간", "비목": "묶음", "수량": "1 ÷ Q", "단가": "P_기계시간당", "출처": "건설품셈 공통 8-1-4"}
-      ],
-      "끝수": {
-        "줄": {"방법": "버림", "자리": 1},
-        "비목": {"방법": "버림", "자리": 0},
-        "끝전": "비목버림"
-      }
-    },
     {
       "꼴": "수식문서",
       "판": 1,
@@ -1138,6 +1028,10 @@
       "이름": "아스팔트 플랜트 시간당 생산능력 — 건설 공통 8-2-10",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-10",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["아스팔트 믹싱플랜트"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "플랜트규격", "기호": "S", "아래": "플랜트규격", "위": "", "이름": "플랜트규격", "단위": "", "설명": "플랜트 규격(ton)", "출처": "건설품셈 공통 8-2-10 1", "연결": {"갈래": "선택", "목록": [40, 60, 80, 100, 120], "값": 60}},
@@ -1162,6 +1056,10 @@
       "이름": "스테이빌라이저(노상안정기) 시간당 작업량 — 건설 공통 8-2-11",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-11",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["스테이빌라이저"]
+      },
       "결과": "A",
       "변수": [
         {"열쇠": "로터폭", "기호": "B", "아래": "로터", "위": "", "이름": "로터폭", "단위": "m", "설명": "Rotor 폭", "출처": "건설품셈 공통 8-2-11 1", "연결": {"갈래": "입력", "값": 2.4}},
@@ -1197,6 +1095,10 @@
       "이름": "죠 크러셔 시간당 생산능력 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["죠 크러셔"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "죠 크러셔 규격", "출처": "건설품셈 공통 8-2-12 1 다", "연결": {"갈래": "선택", "목록": ["025040", "025060", "045091", "063101", "106121"], "값": "025060"}},
@@ -1223,6 +1125,10 @@
       "이름": "롤 크러셔 시간당 생산능력 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["롤 크러셔"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "롤 크러셔 규격", "출처": "건설품셈 공통 8-2-12 1 라", "연결": {"갈래": "선택", "목록": ["139076", "101063", "104076", "076076", "076045", "076063", "060040", "040040"], "값": "076063"}},
@@ -1249,6 +1155,10 @@
       "이름": "이동식 크러셔 시간당 생산능력 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["크러셔"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "이동식 크러셔 규격(ton)", "출처": "건설품셈 공통 8-2-12 2", "연결": {"갈래": "선택", "목록": [50, 100, 150, 200], "값": 100}},
@@ -1275,6 +1185,10 @@
       "이름": "스크린 전체 통과량 — 건설 공통 8-2-12",
       "결과단위": "ton/hr",
       "출처": "건설품셈 공통 8-2-12",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["스크린"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "체규격", "기호": "S", "아래": "체규격", "위": "", "이름": "체규격", "단위": "㎜", "설명": "체의 규격", "출처": "건설품셈 공통 8-2-12 1 마", "연결": {"갈래": "선택", "목록": [2.5, 5, 6, 10, 13, 16, 19, 22, 25, 30, 40, 45, 50, 65, 80, 90, 100], "값": 25}},
@@ -1303,31 +1217,6 @@
         "끝전": "비목버림"
       }
     },
-    {
-      "꼴": "수식문서",
-      "판": 1,
-      "키": "GC001166",
-      "이름": "대형브레이커 작업량당 기계경비 — 건설 공통 8-2-13",
-      "결과단위": "원/㎥",
-      "출처": "건설품셈 공통 8-2-13 2",
-      "변수": [
-        {"열쇠": "작업능력", "기호": "q", "아래": "작업", "위": "", "이름": "작업능력", "단위": "㎥/hr", "설명": "대형브레이커 작업능력(Q · 표 범위 안 값)", "출처": "건설품셈 공통 8-2-13 2", "연결": {"갈래": "입력", "값": 3.3}},
-        {"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["0201-0012", "0201-0020", "0201-0040", "0201-0060", "0201-0070", "0201-0080", "0201-0100", "0201-0120", "0201-0200"], "값": "0201-0070"}},
-        {"열쇠": "브레이커", "기호": "S", "아래": "브레이커", "위": "", "이름": "브레이커", "단위": "", "연결": {"갈래": "선택", "목록": ["0230-0002", "0230-0004", "0230-0006", "0230-0007", "0230-0008", "0230-0010"], "값": "0230-0007"}},
-        {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
-        {"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "선택", "목록": ["해당 없음", "암석작업(연암･보통암･경암)", "전석섞인토사"], "값": "해당 없음"}},
-        {"열쇠": "P_굴착기무한궤", "기호": "P", "아래": "굴착기무한궤", "위": "", "이름": "굴착기(무한궤도)+대형브레이커 시간당 기계경비", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000271", "입력": {"기계": "S_기계", "브레이커": "S_브레이커", "지역": "S_지역", "보정작업": "S_보정작업"}}}
-      ],
-      "식": [],
-      "금액": [
-        {"이름": "굴착기+대형브레이커", "단위": "시간", "비목": "묶음", "수량": "1 ÷ q_작업", "단가": "P_굴착기무한궤", "출처": "건설품셈 공통 8-2-13 2"}
-      ],
-      "끝수": {
-        "줄": {"방법": "버림", "자리": 1},
-        "비목": {"방법": "버림", "자리": 0},
-        "끝전": "비목버림"
-      }
-    },
     {
       "꼴": "수식문서",
       "판": 1,
@@ -1335,6 +1224,10 @@
       "이름": "압쇄기(콘크리트 소할용) 시간당 작업량 — 건설 공통 8-2-14",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-14",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["압쇄기"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 값", "출처": "건설품셈 공통 8-2-14", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
@@ -1361,6 +1254,10 @@
       "이름": "법면다짐기 시간당 작업량 — 건설 공통 8-2-15",
       "결과단위": "㎡/hr",
       "출처": "건설품셈 공통 8-2-15",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["유압식 진동콤팩터"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "구분", "기호": "S", "아래": "구분", "위": "", "이름": "구분", "단위": "", "설명": "장비", "출처": "건설품셈 공통 8-2-15 2", "연결": {"갈래": "선택", "목록": ["유압식 진동콤팩터", "법면다짐판"], "값": "유압식 진동콤팩터"}},
@@ -1384,6 +1281,10 @@
       "이름": "골재세척설비 시간당 작업량 — 건설 공통 8-2-16",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-16",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["골재세척설비"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "설명": "작업효율을 직접 넣을 때 — 0 이면 원문 값", "출처": "건설품셈 공통 8-2-16", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
@@ -1410,6 +1311,11 @@
       "이름": "콘크리트 믹서 시간당 생산량 — 건설 공통 8-2-17",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-17",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["콘크리트 믹서"],
+        "규격": "믹서용량"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "믹서용량", "기호": "q", "아래": "", "위": "", "이름": "믹서용량", "단위": "㎥", "설명": "콘크리트 믹서용량(q)", "출처": "건설품셈 공통 8-2-17", "연결": {"갈래": "입력", "값": 0.5}},
@@ -1437,6 +1343,10 @@
       "이름": "콘크리트 배치플랜트(강제 혼합식) 시간당 작업량 — 건설 공통 8-2-18",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-18",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["콘크리트 배치플랜트"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "배치플랜트 규격", "출처": "건설품셈 공통 8-2-18 1", "연결": {"갈래": "선택", "목록": ["60㎥/h (96㎾)", "90㎥/h (144㎾)", "120㎥/h (160㎾)", "150㎥/h (177㎾))", "180㎥/h (213㎾))", "210㎥/h (233㎾))"], "값": "60㎥/h (96㎾)"}},
@@ -1472,6 +1382,11 @@
       "이름": "콘크리트 믹서트럭 시간당 운반량 — 건설 공통 8-2-19",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-19",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["콘크리트 믹서트럭"],
+        "규격": "적재용량"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "적재용량", "기호": "W", "아래": "", "위": "", "이름": "적재용량", "단위": "㎥", "설명": "믹서트럭 적재용량(W)", "출처": "건설품셈 공통 8-2-19 1", "연결": {"갈래": "입력", "값": 6}},
@@ -1527,6 +1442,10 @@
       "이름": "콘크리트 덤프트럭 시간당 운반량 — 건설 공통 8-2-19",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-19",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["덤프트럭"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "덤프트럭 규격(톤)", "출처": "건설품셈 공통 8-2-19 2 가", "연결": {"갈래": "선택", "목록": [8, 10.5, 15], "값": 10.5}},
@@ -1574,6 +1493,10 @@
       "이름": "기관차 시간당 작업량 — 건설 공통 8-2-20",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-20",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["디젤 기관차"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "기관차", "기호": "S", "아래": "기관차", "위": "", "이름": "기관차", "단위": "", "설명": "기관차 규격", "출처": "건설품셈 공통 8-2-20", "연결": {"갈래": "선택", "목록": ["5t", "7t"], "값": "5t"}},
@@ -1616,6 +1539,10 @@
       "이름": "경운기 시간당 작업량 — 건설 공통 8-2-21",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-21",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["경운기"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "적재량", "기호": "q", "아래": "", "위": "", "이름": "적재량", "단위": "㎥", "설명": "흐트러진 상태의 1회 적재량(q)", "출처": "건설품셈 공통 8-2-21", "연결": {"갈래": "입력", "값": 0.5}},
@@ -1651,6 +1578,10 @@
       "이름": "디젤 파일 해머 파일 1본당 시공시간 — 강관파일 — 건설 공통 8-2-22",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-22",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["디젤 파일 해머"]
+      },
       "결과": "Tc",
       "변수": [
         {"열쇠": "토질", "기호": "S", "아래": "토질", "위": "", "이름": "토질", "단위": "", "설명": "토질계수(α) 표의 토질", "출처": "건설품셈 공통 8-2-22 1 가 (1)", "연결": {"갈래": "선택", "목록": ["점토･부식토", "실트･로움･모래", "자갈"], "값": "실트･로움･모래"}},
@@ -1712,6 +1643,10 @@
       "이름": "디젤 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC) — 건설 공통 8-2-22",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-22",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["디젤 파일 해머"]
+      },
       "결과": "Tc",
       "변수": [
         {"열쇠": "토질", "기호": "S", "아래": "토질", "위": "", "이름": "토질", "단위": "", "설명": "토질계수(α) 표의 토질", "출처": "건설품셈 공통 8-2-22 1 가 (1)", "연결": {"갈래": "선택", "목록": ["점토･부식토", "실트･로움･모래", "자갈"], "값": "실트･로움･모래"}},
@@ -1762,6 +1697,10 @@
       "이름": "유압 파일 해머 파일 1본당 시공시간 — 강관파일 — 건설 공통 8-2-23",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-23",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["유압 파일 해머"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "평균N", "기호": "X", "아래": "평균N", "위": "", "이름": "평균N", "단위": "", "설명": "타입층의 평균 N치", "출처": "건설품셈 공통 8-2-23 1 가 (1)", "연결": {"갈래": "입력", "값": 15}},
@@ -1795,6 +1734,10 @@
       "이름": "유압 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC · PHC) — 건설 공통 8-2-23",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-23",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["유압 파일 해머"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "평균N", "기호": "X", "아래": "평균N", "위": "", "이름": "평균N", "단위": "", "설명": "타입층의 평균 N치", "출처": "건설품셈 공통 8-2-23 1 가 (1)", "연결": {"갈래": "입력", "값": 25}},
@@ -1824,6 +1767,10 @@
       "이름": "진동파일 해머 파일 1본당 시공시간 — H파일 — 건설 공통 8-2-24",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-24",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["진동파일 해머"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "작업", "기호": "S", "아래": "작업", "위": "", "이름": "작업", "단위": "", "설명": "항타 · 항발", "출처": "건설품셈 공통 8-2-24 1", "연결": {"갈래": "선택", "목록": ["항타", "항발"], "값": "항타"}},
@@ -1876,6 +1823,10 @@
       "이름": "진동파일 해머 파일 1본당 시공시간 — 강널말뚝 — 건설 공통 8-2-24",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-24",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["진동파일 해머"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "종류", "기호": "S", "아래": "종류", "위": "", "이름": "종류", "단위": "", "설명": "강널말뚝 종류", "출처": "건설품셈 공통 8-2-24 2 나 (1)", "연결": {"갈래": "선택", "목록": ["II-Type (400×100×10.5)", "III-Type (400×150×13)", "IV-Type (400×170×15.5)"], "값": "III-Type (400×150×13)"}},
@@ -1915,6 +1866,10 @@
       "이름": "진동파일해머(워터제트 병용 압입공) 파일 1본당 시공시간 — 건설 공통 8-2-25",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-25",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["진동파일 해머", "워터젯트"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "근입길이", "기호": "L", "아래": "", "위": "", "이름": "근입길이", "단위": "m", "설명": "근입길이(L)", "출처": "건설품셈 공통 8-2-25 2 가", "연결": {"갈래": "입력", "값": 12}},
@@ -1955,6 +1910,10 @@
       "이름": "유압식 압입 인발기 강널말뚝 1본당 시공시간 — 건설 공통 8-2-26",
       "결과단위": "분/본",
       "출처": "건설품셈 공통 8-2-26",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["유압식 압입 인발기"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "작업", "기호": "S", "아래": "작업", "위": "", "이름": "작업", "단위": "", "설명": "압입 · 인발", "출처": "건설품셈 공통 8-2-26 2", "연결": {"갈래": "선택", "목록": ["압입", "인발"], "값": "압입"}},
@@ -1997,7 +1956,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC001184",
-      "이름": "수중펌프 설치 및 해체(1개소당) — 건설 공통 8-2-27",
+      "이름": "수중펌프 설치 및 해체",
       "결과단위": "원/개소",
       "출처": "건설품셈 공통 8-2-27 5",
       "변수": [
@@ -2024,6 +1983,10 @@
       "이름": "터널전단면 굴착기(TBM) 1시간당 작업량 — 건설 공통 8-2-28",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-28",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["터널전단면 굴착기"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "굴착직경", "기호": "D", "아래": "", "위": "", "이름": "굴착직경", "단위": "m", "설명": "굴착직경(D)", "출처": "건설품셈 공통 8-2-28 1", "연결": {"갈래": "입력", "값": 4.5}},
@@ -2061,6 +2024,10 @@
       "이름": "펌프식 준설선 1시간당 준설능력 — 건설 공통 8-2-29",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-29",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["펌프 준설선"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "토질", "기호": "S", "아래": "토질", "위": "", "이름": "토질", "단위": "", "설명": "토질 분류", "출처": "건설품셈 공통 8-2-29 2", "연결": {"갈래": "선택", "목록": ["점성토", "사질토"], "값": "사질토"}},
@@ -2101,6 +2068,10 @@
       "이름": "그래브 준설선 1시간당 준설량 — 건설 공통 8-2-30",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-30",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["그래브 준설선"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "버킷용량", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "㎥", "설명": "버킷용량(q)", "출처": "건설품셈 공통 8-2-30 3", "연결": {"갈래": "선택", "목록": [0.65, 1.0, 1.5, 3.0, 5.0, 6.0, 7.5, 12.5, 16.0, 25.0], "값": 3.0}},
@@ -2149,6 +2120,10 @@
       "이름": "쇄암선(중추식) 시간당 작업능력 — 건설 공통 8-2-31",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-31",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": []
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "분류", "기호": "S", "아래": "분류", "위": "", "이름": "분류", "단위": "", "설명": "토질분류", "출처": "건설품셈 공통 8-2-31 1", "연결": {"갈래": "선택", "목록": ["자갈섞인 토사", "암반"], "값": "암반"}},
@@ -2179,6 +2154,10 @@
       "이름": "이동식 임목파쇄기 시간당 파쇄능력 — 건설 공통 8-2-32",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-32",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["이동식 임목파쇄기"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "규격", "기호": "S", "아래": "규격", "위": "", "이름": "규격", "단위": "", "설명": "임목파쇄기 규격", "출처": "건설품셈 공통 8-2-32 1 · 2", "연결": {"갈래": "선택", "목록": ["93.25㎾", "354.35㎾", "402.84㎾"], "값": "354.35㎾"}},
@@ -2208,6 +2187,10 @@
       "이름": "하천골재채취선 시간당 준설량 — 건설 공통 8-2-33",
       "결과단위": "㎥/hr",
       "출처": "건설품셈 공통 8-2-33",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["하천골재채취선"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "분류", "기호": "S", "아래": "분류", "위": "", "이름": "분류", "단위": "", "설명": "구분", "출처": "건설품셈 공통 8-2-33 2", "연결": {"갈래": "선택", "목록": ["모래질토사", "자갈섞인 모래질토사"], "값": "모래질토사"}},

resources/master_data/수식문서/수식_건설품셈_09장_기타공사.json

@@ -78,7 +78,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000822",
-      "이름": "바탕만들기(블라스트 · 공구 · 와이어브러시)",
+      "이름": "바탕만들기",
       "결과단위": "원/㎡",
       "출처": "건설품셈 기계설비 9-2-1",
       "변수": [
@@ -245,7 +245,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000827",
-      "이름": "가스배관 기밀시험",
+      "이름": "기밀시험",
       "결과단위": "원/회",
       "출처": "건설품셈 기계설비 9-4-1",
       "변수": [

resources/master_data/수식문서/수식_건설품셈_13장_플랜트설비공사.json

@@ -873,7 +873,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000900",
-      "이름": "응력제거(Ring Burner · 전기저항)",
+      "이름": "응력제거(Ring Burner, Electric, Resistence Heating)",
       "결과단위": "원/개소",
       "출처": "건설품셈 기계설비 13-2-6",
       "변수": [
@@ -1357,7 +1357,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000912",
-      "이름": "화력 보일러 설치(공정별)",
+      "이름": "화력 보일러 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-1",
       "변수": [
@@ -1479,7 +1479,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000914",
-      "이름": "보일러 드럼 설치(공정별)",
+      "이름": "보일러 드럼 설치",
       "결과단위": "원/대",
       "출처": "건설품셈 기계설비 13-5-2",
       "변수": [
@@ -1619,7 +1619,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000916",
-      "이름": "덕트 설치(공정별)",
+      "이름": "덕트 설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-5-4",
       "변수": [
@@ -1690,7 +1690,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000917",
-      "이름": "공기예열기(Preheater) 설치(공정별)",
+      "이름": "공기예열기(Preheater) 설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-5-5",
       "변수": [
@@ -1841,7 +1841,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000920",
-      "이름": "터빈 설치(공정별)",
+      "이름": "터빈 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-8",
       "변수": [
@@ -1929,7 +1929,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000921",
-      "이름": "발전기 설치(공정별)",
+      "이름": "발전기 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-9",
       "변수": [
@@ -2003,7 +2003,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000922",
-      "이름": "복수기 설치(공정별)",
+      "이름": "복수기 설치",
       "결과단위": "원/기",
       "출처": "건설품셈 기계설비 13-5-10",
       "변수": [
@@ -2357,7 +2357,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000931",
-      "이름": "수차 설치(Kaplan · Francis · Propeller)",
+      "이름": "수차 설치",
       "결과단위": "원/ton",
       "출처": "건설품셈 기계설비 13-6-1",
       "변수": [
@@ -4950,7 +4950,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000967",
-      "이름": "Mill Line 기기류 조립설치(공정별)",
+      "이름": "Mill Line 기기류 조립설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-7-19",
       "변수": [
@@ -4993,7 +4993,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GC000968",
-      "이름": "Roller Table 조립설치(공정별)",
+      "이름": "Roller Table 조립설치",
       "결과단위": "원/식",
       "출처": "건설품셈 기계설비 13-7-20",
       "변수": [
@@ -6505,6 +6505,9 @@
       "이름": "아세틸렌량의 환산(ℓ → ㎏)",
       "결과단위": "㎏",
       "출처": "건설품셈 기계설비 13-2-7",
+      "부품": {
+        "갈래": "계수식"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "아세틸렌부피", "기호": "V", "아래": "아세틸렌", "위": "", "이름": "아세틸렌부피", "단위": "ℓ", "설명": "아세틸렌 부피", "출처": "건설품셈 기계설비 13-2-7", "연결": {"갈래": "입력", "값": 1000}},

resources/master_data/수식문서/수식_산림품셈_03장_작업장_관리.json

@@ -69,6 +69,11 @@
       "이름": "임산물 운반로 신설 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 3-4-2 1",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "QF000028", "조건": {"구분": "'q(버킷용량)'"}, "칸": "값"}},
@@ -92,7 +97,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000004",
-      "이름": "임산물 운반로 및 작업로 신설(굴착기 0.2㎥)",
+      "이름": "임산물 운반로 및 작업로 신설비 산정",
       "결과단위": "원/m",
       "출처": "산림품셈 3-4-2",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_04장_나무베기.json

@@ -142,7 +142,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000288",
-      "이름": "단목베기(1,000㎡당 · 굴착기 0.2㎥ + 부착용 집게)",
+      "이름": "단목베기(1,000㎡당)",
       "결과단위": "원/1,000㎡",
       "출처": "산림품셈 4-2-2",
       "변수": [
@@ -181,7 +181,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000289",
-      "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+      "이름": "위험목 베기",
       "결과단위": "원/본",
       "출처": "산림품셈 4-3",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_05장_식재_및_녹화.json

@@ -1096,6 +1096,11 @@
       "이름": "복사이식 굴착기 시간당 작업량(Q1)",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 5-29 주④",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "출처": "산림품셈 5-29 주③ 1.0㎥", "연결": {"갈래": "표", "표": "QF000146", "조건": {"구분": "'적용 굴착기(무한궤도형)'"}, "칸": "값"}},
@@ -1119,7 +1124,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000043",
-      "이름": "복사이식(굴착기 1.0㎥)",
+      "이름": "복사이식",
       "결과단위": "원/㎥",
       "출처": "산림품셈 5-29",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_08장_방제.json

@@ -313,7 +313,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000321",
-      "이름": "지상방제 차량살포(동력분무기)",
+      "이름": "지상방제 차량살포",
       "결과단위": "원/일",
       "출처": "산림품셈 8-6-3",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_09장_토공.json

@@ -53,6 +53,11 @@
       "이름": "토사깍기(기계 · 굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-3-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "E입력", "단위": "", "출처": "산림품셈 9-3-2", "연결": {"갈래": "입력", "값": 0.45, "범위": [0.45, 0.55]}},
@@ -78,7 +83,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000089",
-      "이름": "토사깍기(기계 · 굴착기 0.7㎥)",
+      "이름": "토사깍기(기계)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-3-2",
       "변수": [
@@ -102,7 +107,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000252",
-      "이름": "암파쇄(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "암파쇄",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-4-1",
       "변수": [
@@ -143,6 +148,11 @@
       "이름": "암절취 집토(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-4-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000123", "조건": {"구분": "'무한궤도 굴착기'"}, "칸": "적용"}},
@@ -166,7 +176,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000091",
-      "이름": "암절취 집토(굴착기 0.7㎥)",
+      "이름": "암절취 집토",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-4-2",
       "변수": [
@@ -239,7 +249,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000253",
-      "이름": "발파암 깎기 90%(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "발파암 깎기(90%)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-5-2",
       "변수": [
@@ -280,6 +290,11 @@
       "이름": "발파암 집토(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-5-3",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000124", "조건": {"구분": "'무한궤도 굴착기'"}, "칸": "적용"}},
@@ -303,7 +318,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000093",
-      "이름": "발파암 집토(굴착기 0.7㎥)",
+      "이름": "발파암 집토",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-5-3",
       "변수": [
@@ -326,7 +341,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000255",
-      "이름": "발파암 기계소할(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "발파암 기계소할(15%)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-6-1",
       "변수": [
@@ -355,6 +370,11 @@
       "이름": "콘크리트 깨기 집토(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-7-1 주⑥",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000125", "조건": {"구분": "'무한궤도 굴착기'"}, "칸": "적용"}},
@@ -378,7 +398,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000095",
-      "이름": "콘크리트 깨기 집토(굴착기 0.7㎥)",
+      "이름": "무근콘크리트 깨기 집토",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-7-1 주⑥",
       "변수": [
@@ -401,7 +421,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000256",
-      "이름": "무근콘크리트 깨기(T=30㎝ 미만) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "무근콘크리트 깨기(T=30㎝ 미만)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-7-1",
       "변수": [
@@ -432,7 +452,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000257",
-      "이름": "무근콘크리트 깨기(T=30㎝ 이상) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "무근콘크리트 깨기(T=30㎝ 이상)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-7-2",
       "변수": [
@@ -495,7 +515,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000258",
-      "이름": "철근콘크리트 깨기(T=30㎝ 미만) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "철근콘크리트 깨기(T=30㎝ 미만)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-8-1",
       "변수": [
@@ -526,7 +546,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000259",
-      "이름": "철근콘크리트 깨기(T=30㎝ 이상) 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "철근콘크리트 깨기(T=30㎝ 이상)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-8-2",
       "변수": [
@@ -581,7 +601,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000260",
-      "이름": "기존포장 깨기 콘크리트 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "기존포장 깨기 콘크리트",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-10-1",
       "변수": [
@@ -612,7 +632,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000261",
-      "이름": "기존포장 깨기 아스팔트 깨기(대형브레이커 · 굴착기 0.7㎥)",
+      "이름": "기존포장 깨기 아스팔트",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-10-2",
       "변수": [
@@ -675,6 +695,11 @@
       "이름": "측구터파기 토사 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-12-1",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000126", "조건": {"구분": "'굴착기 버킷'"}, "칸": "적용"}},
@@ -1546,6 +1571,11 @@
       "이름": "되메우기 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-14-1",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000129", "조건": {"구분": "'굴착기 버킷'"}, "칸": "적용"}},
@@ -1600,6 +1630,10 @@
       "이름": "다짐(플레이트콤펙터) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-14-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["플레이트 콤팩터"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "A", "기호": "A", "아래": "", "위": "", "이름": "A", "단위": "", "연결": {"갈래": "표", "표": "QF000289", "조건": {"기호": "'A'"}, "칸": "적용"}},
@@ -1624,7 +1658,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000249",
-      "이름": "다짐(플레이트콤펙터 1.5ton)",
+      "이름": "다짐(플레이트콤펙터)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-14-2",
       "변수": [
@@ -1649,6 +1683,11 @@
       "이름": "표토제거 답(畓)구간(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎡/hr",
       "출처": "산림품셈 9-15-1",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "T", "기호": "T", "아래": "", "위": "", "이름": "표토두께", "단위": "m", "출처": "산림품셈 9-15-1 주②", "연결": {"갈래": "입력", "값": 1}},
@@ -1673,7 +1712,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000116",
-      "이름": "표토제거 답(畓)구간(굴착기 0.7㎥)",
+      "이름": "표토제거 답(畓)구간",
       "결과단위": "원/㎡",
       "출처": "산림품셈 9-15-1",
       "변수": [
@@ -1700,6 +1739,10 @@
       "이름": "표토제거 답(畓)외구간(불도저 19ton) 시간당 작업량",
       "결과단위": "㎡/hr",
       "출처": "산림품셈 9-15-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["불도저"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "T", "기호": "T", "아래": "", "위": "", "이름": "표토두께", "단위": "", "연결": {"갈래": "표", "표": "QF000291", "조건": {"구분": "'T(표토두께)'"}, "칸": "적용"}},
@@ -1729,7 +1772,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000250",
-      "이름": "표토제거 답(畓)외구간(불도저 19ton)",
+      "이름": "표토제거 답(畓)외구간",
       "결과단위": "원/㎡",
       "출처": "산림품셈 9-15-2",
       "변수": [
@@ -1755,6 +1798,10 @@
       "이름": "노체포설 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-16-1 주②",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q0", "기호": "q", "아래": "0", "위": "", "이름": "q0", "단위": "", "연결": {"갈래": "표", "표": "CF000098", "조건": {"구분": "'무한궤도 굴착기'"}, "칸": "적용"}},
@@ -1778,7 +1825,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000119",
-      "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+      "이름": "노체포설",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-16-1",
       "변수": [
@@ -1804,6 +1851,10 @@
       "이름": "노체다짐 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-16-2 주②",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "V", "기호": "V", "아래": "", "위": "", "이름": "다짐속도", "단위": "㎞/hr", "연결": {"갈래": "표", "표": "CF000099", "조건": {"구분": "'V(다짐속도,km/hr)'"}, "칸": "적용"}},
@@ -1874,6 +1925,10 @@
       "이름": "비다짐(정지 · 불도저 19ton) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-17-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["불도저"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "L", "기호": "L", "아래": "", "위": "", "이름": "L", "단위": "", "연결": {"갈래": "표", "표": "QF000292", "조건": {"구분": "'L'"}, "칸": "적용"}},
@@ -1902,7 +1957,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000251",
-      "이름": "비다짐(정지 · 불도저 19ton)",
+      "이름": "비다짐(정지)",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-17-2",
       "변수": [
@@ -1928,6 +1983,11 @@
       "이름": "층따기(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-18",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000131", "조건": {"구분": "'무한궤도 굴착기'"}, "칸": "적용"}},
@@ -1951,7 +2011,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000123",
-      "이름": "층따기(굴착기 0.7㎥)",
+      "이름": "층따기",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-18",
       "변수": [
@@ -2023,7 +2083,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000126",
-      "이름": "토사면 성토면 고르기(기계시공 · 굴착기 0.6㎥)",
+      "이름": "토사면 성토면 고르기(기계시공)",
       "결과단위": "원/10㎡",
       "출처": "산림품셈 9-19-1",
       "변수": [
@@ -2189,6 +2249,11 @@
       "이름": "섞기(굴착기 0.7㎥) 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 9-22",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000132", "조건": {"구분": "'무한궤도 굴착기'"}, "칸": "적용"}},
@@ -2212,7 +2277,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000132",
-      "이름": "섞기(굴착기 0.7㎥)",
+      "이름": "섞기",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-22",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_10장_자재․장비_운반.json

@@ -9,6 +9,10 @@
       "이름": "골재운반 덤프트럭 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 10-3-1 주",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["덤프트럭"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "qt", "기호": "qt", "아래": "", "위": "", "이름": "덤프트럭 1회 적재량", "단위": "㎥", "연결": {"갈래": "입력", "값": 0}},
@@ -31,7 +35,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000134",
-      "이름": "골재운반 모래(덤프 15ton)",
+      "이름": "골재운반 모래",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-3-1",
       "변수": [
@@ -57,7 +61,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000135",
-      "이름": "골재운반 잡석(덤프 15ton)",
+      "이름": "골재운반 잡석",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-3-2",
       "변수": [
@@ -83,7 +87,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000136",
-      "이름": "골재운반 혼합골재(덤프 15ton)",
+      "이름": "골재운반 혼합골재",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-3-3",
       "변수": [
@@ -109,7 +113,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000137",
-      "이름": "중기운반 트레일러(20ton)",
+      "이름": "중기운반",
       "결과단위": "원/회",
       "출처": "산림품셈 10-4",
       "변수": [
@@ -469,6 +473,9 @@
       "이름": "4륜구동 1톤 덤프트럭 시간당 기계경비",
       "결과단위": "원/시간",
       "출처": "산림품셈 10-9",
+      "부품": {
+        "갈래": "기계경비식"
+      },
       "변수": [
         {"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
         {"열쇠": "손료", "기호": "C", "아래": "손료", "위": "", "이름": "손료", "단위": "", "출처": "산림품셈 10-9 · 건설품셈 공통 8-1-5 12", "연결": {"갈래": "식"}},
@@ -507,7 +514,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000283",
-      "이름": "덤프트럭 자재 운반(1회 표준 운반량)",
+      "이름": "덤프트럭 운반(자재의 1회당 표준 운반량)",
       "결과단위": "원/ton",
       "출처": "산림품셈 10-9-1",
       "변수": [
@@ -593,6 +600,10 @@
       "이름": "불도저 운반 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 10-11 주②",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["불도저"]
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "재료", "기호": "S", "아래": "재료", "위": "", "이름": "재료", "단위": "", "연결": {"갈래": "선택", "목록": ["토사", "파쇄암", "발파암"], "값": "토사"}},
@@ -653,7 +664,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000284",
-      "이름": "덤프운반(굴착기 0.7㎥ 적재 · 덤프트럭 15ton)",
+      "이름": "덤프운반 토사",
       "결과단위": "원/㎥",
       "출처": "산림품셈 10-12-1",
       "변수": [
@@ -761,7 +772,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000335",
-      "이름": "시멘트운반(구역화물 운임 + 하차비)",
+      "이름": "시멘트운반",
       "결과단위": "원/포",
       "출처": "산림품셈 10-1",
       "변수": [
@@ -791,7 +802,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000336",
-      "이름": "철근운반(구역화물 운임 + 하차비)",
+      "이름": "철근운반",
       "결과단위": "원/ton",
       "출처": "산림품셈 10-2",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_11장_가설.json

@@ -91,6 +91,11 @@
       "이름": "쇄석·혼합석 부설 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 11-4 주①",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "QF000349", "조건": {"구분": "'q(버킷용량)'"}, "칸": "적용"}},
@@ -114,7 +119,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "GF000154",
-      "이름": "쇄석·혼합석 부설(굴착기 0.7㎥)",
+      "이름": "쇄석·혼합석 부설",
       "결과단위": "원/㎥",
       "출처": "산림품셈 11-4",
       "변수": [

resources/master_data/수식문서/수식_산림품셈_13장_구조물.json

@@ -1082,6 +1082,11 @@
       "이름": "토양개량제 부설 굴착기 시간당 작업량",
       "결과단위": "㎥/hr",
       "출처": "산림품셈 13-13-2",
+      "부품": {
+        "갈래": "작업량 틀",
+        "기종": ["굴착기"],
+        "규격": "q"
+      },
       "결과": "Q",
       "변수": [
         {"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "버킷용량", "단위": "", "연결": {"갈래": "표", "표": "CF000158", "조건": {"구분": "'굴착기 버킷'"}, "칸": "적용"}},

resources/master_data/일위대가조합.json

@@ -10,7 +10,7 @@
       "구분": null,
       "상세구분": null,
       "단위": "식",
-      "담은로직": [{ "로직": "GF000219", "메모": "메쌓기 — 돌쌓기 인력" }, { "로직": "GF000119", "메모": "노체포설 — 굴착기 0.7㎥" }, { "로직": "GF000137", "메모": "운반 — 중기운반 트레일러(20ton)" }],
+      "담은로직": [{ "로직": "GF000219", "메모": "메쌓기 — 돌쌓기 인력" }, { "로직": "GF000119", "메모": "노체포설 — 굴착기 0.7㎥" }, { "로직": "GF000137", "메모": "운반 — 중기운반" }],
       "본뜬키": null,
       "출처": "자체",
       "소유": "현장",

resources/master_template/labor/item3.json

@@ -36,7 +36,7 @@
         "키": "SK-000019"
       },
       "별칭": null,
-      "메모": "운반 — 중기운반 트레일러(20ton)",
+      "메모": "운반 — 중기운반",
       "수량": null
     },
     {
@@ -913,7 +913,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -992,7 +992,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -10625,7 +10625,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -10704,7 +10704,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -19683,7 +19683,7 @@
         "꼴": "수식문서",
         "판": 1,
         "키": "GF000137",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "변수": [
@@ -20333,7 +20333,7 @@
         "꼴": "수식문서",
         "판": 1,
         "키": "GF000119",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "변수": [

resources/master_template/precombo/SC-000001.json

@@ -786,7 +786,7 @@
         "원문번호": "4-3",
         "구분": "산림품셈",
         "상세구분": "04장 나무베기",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "개정": [
@@ -10826,7 +10826,7 @@
         "원문번호": "4-3",
         "구분": "산림품셈",
         "상세구분": "04장 나무베기",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "개정": [
@@ -20114,7 +20114,7 @@
         "꼴": "수식문서",
         "판": 1,
         "키": "GF000289",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "변수": [

resources/master_template/sangeun/SK-000001.json

@@ -772,7 +772,7 @@
         "원문번호": "4-3",
         "구분": "산림품셈",
         "상세구분": "04장 나무베기",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "개정": [
@@ -10822,7 +10822,7 @@
         "원문번호": "4-3",
         "구분": "산림품셈",
         "상세구분": "04장 나무베기",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "개정": [

resources/master_template/sangeun/SK-000002.json

@@ -1,7 +1,7 @@
 {
   "종류": "단가산출",
   "키": "SK-000002",
-  "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+  "이름": "위험목 베기",
   "단위": "본",
   "바탕": {
     "로직": "GF000289"
@@ -772,7 +772,7 @@
         "원문번호": "4-3",
         "구분": "산림품셈",
         "상세구분": "04장 나무베기",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "개정": [
@@ -10823,7 +10823,7 @@
         "원문번호": "4-3",
         "구분": "산림품셈",
         "상세구분": "04장 나무베기",
-        "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+        "이름": "위험목 베기",
         "결과단위": "원/본",
         "출처": "산림품셈 4-3",
         "개정": [
@@ -21000,7 +21000,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "SK-000002",
-      "이름": "위험목 베기(굴착기 우드그랩 0.2㎥ · 크레인 5톤)",
+      "이름": "위험목 베기",
       "결과단위": "원/본",
       "출처": "산림품셈 4-3",
       "변수": [

resources/master_template/sangeun/SK-000017.json

@@ -674,7 +674,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -753,7 +753,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -10392,7 +10392,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -10471,7 +10471,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [

resources/master_template/sangeun/SK-000018.json

@@ -1,7 +1,7 @@
 {
   "종류": "단가산출",
   "키": "SK-000018",
-  "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+  "이름": "노체포설",
   "단위": "㎥",
   "바탕": {
     "로직": "GF000119"
@@ -674,7 +674,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -753,7 +753,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -10391,7 +10391,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -10470,7 +10470,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -19939,7 +19939,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "SK-000018",
-      "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+      "이름": "노체포설",
       "결과단위": "원/㎥",
       "출처": "산림품셈 9-16-1",
       "변수": [

resources/master_template/sangeun/SK-000019.json

@@ -1,7 +1,7 @@
 {
   "종류": "단가산출",
   "키": "SK-000019",
-  "이름": "중기운반 트레일러(20ton)",
+  "이름": "중기운반",
   "단위": "회",
   "바탕": {
     "로직": "GF000137"
@@ -674,7 +674,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -753,7 +753,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -10393,7 +10393,7 @@
         "원문번호": "9-16-1",
         "구분": "산림품셈",
         "상세구분": "09장 토공",
-        "이름": "노체포설(굴착기 0.7㎥ 무한궤도)",
+        "이름": "노체포설",
         "결과단위": "원/㎥",
         "출처": "산림품셈 9-16-1",
         "개정": [
@@ -10472,7 +10472,7 @@
         "원문번호": "10-4",
         "구분": "산림품셈",
         "상세구분": "10장 자재․장비 운반",
-        "이름": "중기운반 트레일러(20ton)",
+        "이름": "중기운반",
         "결과단위": "원/회",
         "출처": "산림품셈 10-4",
         "개정": [
@@ -19878,7 +19878,7 @@
       "꼴": "수식문서",
       "판": 1,
       "키": "SK-000019",
-      "이름": "중기운반 트레일러(20ton)",
+      "이름": "중기운반",
       "결과단위": "원/회",
       "출처": "산림품셈 10-4",
       "변수": [

resources/tester/fixtures/m01_791_1_logic_fingerprint.json

@@ -1140,28 +1140,22 @@
   "GC001142": "a71c65aaf3eaa7fb",
   "GC001143": "67408ddb506d5fff",
   "GC001144": "7b207014a8648623",
-  "GC001145": "c84f872700bca009",
   "GC001146": "d0cb3999201a30ac",
   "GC001147": "a0b23be6a9736a77",
-  "GC001148": "9adaa6b9f1d8c1d0",
   "GC001149": "aeed5c7c9e52efef",
   "GC001150": "1375791d7dd5ce45",
-  "GC001151": "1890f61af6e6e49f",
   "GC001152": "6ae99c99ea7e4c9f",
   "GC001153": "813d46800b48b946",
   "GC001154": "cbbd35887f079546",
   "GC001155": "0b6c9c3dc014fc51",
-  "GC001156": "1e7e8101574b5f87",
   "GC001157": "19c727d732d3c6c2",
   "GC001158": "108ec420791670b2",
-  "GC001159": "f867477915fd53c9",
   "GC001160": "3ca4cdd646f5e7b1",
   "GC001161": "0cb1fa1eeda920fb",
   "GC001162": "c3d278e87f2fded4",
   "GC001163": "c1216e4fdd0db9e4",
   "GC001164": "ac5b787938ec3ca2",
   "GC001165": "798aee41ed132310",
-  "GC001166": "b6940f94ad685bae",
   "GC001167": "ab6999dcf7f7dfe6",
   "GC001168": "29e3a9b048eaf277",
   "GC001169": "6cda5f96e9b1895b",
@@ -1520,5 +1514,5 @@
   "GF000336": "a9b9e0bb0f7da1f0",
   "GX000004": "a3f4c454a5764d6e"
  },
- "마스터": "152f8ebe50d98a4c"
+ "마스터": "e6010f1c04492168"
 }

resources/tester/helper_810_4_sweep.py

@@ -2,7 +2,7 @@
 
 파일마다 프로세스 · 안쪽 산근(형제)은 같은 파일 블록을 우리 단가로 먼저 셈해 묶음 값으로 넣음(저장 층의
 형제 SK 읽기와 같은 값) · 확정은 M01 문서를 찾은 옵션(입력값 꼴)으로 다시 셈해 금액 대조.
-마지막 줄 = JSON {블록, 판정, 근접항, 오류, 확정다시셈다름} · `--rows <pkl>` = 줄 목록 저장(목록 xlsx 용).
+마지막 줄 = JSON {블록, 판정, 근접항, 확정참고, 확정참고블록, 오류, 확정다시셈다름} · `--rows <pkl>` = 줄 목록 저장(목록 xlsx 용).
 """
 
 from __future__ import annotations
@@ -96,9 +96,12 @@ def sweep(arg: tuple[str, str, int]) -> list[dict]:
         row |= {"규격": (doc.get("가져온") or {}).get("규격"), **res}
         if res.get("판정") == dm.SURE:
             again = dm._calc(docs[res["키"]], dm.ml.Links(whole, docs), dict(res["옵션"]))
+            money = res["금액"]  # 다시 셈 = 우리 · 참고 없으면 가져온 = 우리(812-2)
             row["다시셈같음"] = (
-                again is not None and dm._plain(dm._totals(again)) == res["금액"]["가져온"]
-            )  # noqa: E501
+                again is not None
+                and dm._plain(dm._totals(again)) == money["우리"]
+                and (bool(res.get("참고")) or money["우리"] == money["가져온"])
+            )
         row["초"] = round(time.time() - start, 2)
         rows.append(row)
     return rows
@@ -121,6 +124,12 @@ def main() -> None:
         "근접항": dict(
             collections.Counter(d["항"] for r in real if r["판정"] == "근접" for d in r["다른"])
         ),  # noqa: E501
+        "확정참고": dict(
+            collections.Counter(
+                d["항"] for r in real if r["판정"] == "확정" for d in r.get("참고") or []
+            )
+        ),
+        "확정참고블록": sum(1 for r in real if r["판정"] == "확정" and r.get("참고")),
         "오류": sum(1 for r in real if r["판정"] == "오류"),
         "확정다시셈다름": sum(1 for r in real if r.get("다시셈같음") is False),
     }

resources/tester/helper_812_3_layout.cjs

@@ -0,0 +1,52 @@
+/* 812-3 가져온 단가산출 차림 헬퍼 — 줄 쌓기 모델(common_util_line_stack.ts)을 그 자리에서 트랜스파일해 Node 로 돌림.
+ * stdin = [{키, 문서, 파이썬 [{제목, 가나다?, 줄 [{꼴, i | 기호 | 글}]}]}]
+ * stdout = [{키, 같음(문서 → 줄 → 문서 · 칸 차례 무시), 거울(TS stackOf = 파이썬 stack_of), 항목 · 제목 · 공식 · 글 · 쌓기}]
+ * 짝 = test_812_3_native_layout.py · 파이썬 거울 = M02_Doc_NativeLayout.py */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const cache = new Map();
+function load(at) {
+  if (cache.has(at)) return cache.get(at);
+  const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  cache.set(at, box.exports);
+  const need = (p) =>
+    p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
+  new Function("exports", "module", "require", js)(box.exports, box, need);
+  return box.exports;
+}
+const ls = load(path.join(__dirname, "..", "..", "common_util", "common_util_line_stack.ts"));
+
+function canon(v) {
+  if (Array.isArray(v)) return v.map(canon);
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const k of Object.keys(v).sort()) out[k] = canon(v[k]);
+    return out;
+  }
+  return v;
+}
+const same = (a, b) => JSON.stringify(canon(a)) === JSON.stringify(canon(b));
+
+const input = JSON.parse(fs.readFileSync(0, "utf8"));
+const out = input.map(({ 키, 문서, 파이썬 }) => {
+  const items = ls.stackOf(문서);
+  const back = ls.docOf(문서, items);
+  const lines = items.flatMap((it) => it.줄);
+  return {
+    키,
+    같음: same(back, 문서),
+    거울: same(items, 파이썬),
+    항목: items.length,
+    제목: items.filter((it) => it.제목.trim()).length,
+    공식: lines.filter((l) => l.꼴 === "공식" && l.기호.length).length,
+    글: lines.filter((l) => l.꼴 === "글").length,
+    쌓기: "쌓기" in 문서,
+    ...(same(items, 파이썬) ? {} : { ts: items }),
+  };
+});
+process.stdout.write(JSON.stringify(out));

resources/tester/test_157_1_sangeun_steps.py

@@ -76,7 +76,7 @@ def test_돈_하위_로직_산근_호표_번호():
 
     got = st.render_sangeun_text(_whole(["GF000089", "GF000123"], edit), "GF000089", {}, _price_of)
     line = next(t for t in got if t.startswith("참고 = "))
-    assert line.startswith("참고 = 층따기(굴착기 0.7㎥)(산근 3호표).노무비 = ")
+    assert line.startswith("참고 = 층따기(산근 3호표).노무비 = ")
 
 
 def test_만약_걸린_갈래_입력_설명_기계_이름():

resources/tester/test_713_3_list.py

@@ -11,22 +11,22 @@ COLS = {"묶음", "묶음수", "작업량", "부모", "부르는수", "불리는
 def test_목록_줄_수_그대로_덧칸_다_있음() -> None:
     got = router.get_logics()["logics"]
     assert (
-        len(got) == 1519
-    )  # 묶음은 화면 접기만 — 목록 줄은 정본 로직 수 그대로(713-4 1,461 + 782 건설 기초 54 + 794-2b 잔토처리 1 + 794-2a2 셋)
+        len(got) == 1440
+    )  # 묶음은 화면 접기만 — 정본 로직 1,513(713-4 1,461 + 782 건설 기초 54 + 794-2b 1 + 794-2a2 셋 − 813-2 지움 6) − 부품 73(813-2)
     assert all(COLS <= set(x) for x in got)
 
 
 def test_묶음_작업량_부르기() -> None:
     more = store_list.extras()
-    # 한 절에 로직 둘 넘음(조사 12-B ㉯ 323 → 713-4 합침 · 지움 뒤 307 → 782 건설 기초 335 → 794-2b 3-2-1 둘 337)
-    assert sum(1 for v in more.values() if v["묶음"]) == 337
+    # 한 절에 로직 둘 넘음(조사 12-B ㉯ 323 → 713-4 합침 · 지움 뒤 307 → 782 건설 기초 335 → 794-2b 3-2-1 둘 337 → 813-2 작업량당 기계경비 6 지움 328)
+    assert sum(1 for v in more.values() if v["묶음"]) == 328
     work = {k for k, v in more.items() if v["작업량"]}
     assert len(work) == 65  # 27 − 터파기 작업량 6(713-4 · 단가 로직 안에 품음) + 782 시공능력 44
     assert more["GF000098"]["부모"] == ["GF000099"]  # 측구터파기 작업량 → 단가 로직 밑
     assert more["GC000268"]["불리는수"] >= 300  # 기계경비 로직
     assert (
-        sum(1 for v in more.values() if v["부르는수"]) == 513
-    )  # 506 + 782 건설 기초 6 + 794-2a2 채집 GX 1
+        sum(1 for v in more.values() if v["부르는수"]) == 507
+    )  # 506 + 782 건설 기초 6 + 794-2a2 채집 GX 1 − 813-2 작업량당 기계경비 6
     assert more["GC000294"]["관련"] == ["GC000292"]  # 비고 「1-5-6(주③)」
     # 인재경 줄 수 = 712-1 묶음 파생 · 못 가른 「하위」 = 복합 하위 로직 부르기 31(조사 12-B ③4)
     assert sum(v["인재경"]["하위"] for v in more.values()) == 31

resources/tester/test_782_3_capacity_82.py

@@ -189,18 +189,7 @@ def test_롤러_임목파쇄_브레이커(whole):
     assert mean(rows["구조물의 평균두께 30㎝ 미만"]["무근구조물"]) == D("4.6")
     assert mean(rows["구조물의 평균두께 30㎝ 이상"]["철근구조물"]) == D("2.05")
     assert mean(rows["구조물의 평균두께 30㎝ 미만"]["철근구조물"]) == D("2.45")
-    cost = mf.run(
-        whole,
-        "GC001166",
-        {
-            "작업능력": D("3.6"),
-            "기계": "0201-0070",
-            "브레이커": "0230-0007",
-            "지역": "전국평균",
-            "보정작업": "해당 없음",
-        },
-    )
-    assert cost["줄"][0]["수량"] == 1 / D("3.6")
+    # 대형브레이커 작업량당 기계경비(GC001166) = 813-2 지움 — 단가산출에 기계 하나 넣어 만듦
 
 
 def test_기본식_원가로직(whole):
@@ -210,10 +199,7 @@ def test_기본식_원가로직(whole):
         {"싸이클시간": 21, "시간단위": "초", "작업량": D("0.9"), "f": D("0.7"), "E": D("0.75")},
     )
     assert got["중간"]["n"] == D("171.43") and got["결과"] == D("81.001")
-    rows = cm.load([LOGIC])[LOGIC]["줄"]
-    cost = next(r for r in rows if r["키"] == "GC001148")
-    got = mf.run(whole, "GC001148", cm.시험입력(cost))
-    assert got["줄"][0]["수량"] == 1 / D("81.000")
+    # 굴착기 작업량당 기계경비(GC001148) = 813-2 지움 — 기계 넣기 + 작업량 틀(test_813_2_parts)
 
 
 def test_아세틸렌(whole):
@@ -228,7 +214,8 @@ def test_check_master():
     new = [t["키"] for t in files[COEF]["표"] if "CC000349" <= t["키"] <= "CC000494"]
     assert len(new) == 146
     logic = [r["키"] for r in files[LOGIC]["줄"] if r["키"] >= "GC001143"]
-    assert logic == [f"GC00{n}" for n in range(1143, 1191)]
+    gone = (1145, 1148, 1151, 1156, 1159, 1166)  # 813-2 작업량당 기계경비 지움
+    assert logic == [f"GC00{n}" for n in range(1143, 1191) if n not in gone]
     assert files[LOGIC13]["줄"][-1]["키"] == "GC001191"
     for name in (LOGIC, LOGIC13):
         for row in files[name]["줄"]:

resources/tester/test_791_1_engine_semantics.py

@@ -71,7 +71,7 @@ def test_M01_로직_전부_전후_같음():
     if saved["마스터"] != _master_hash():
         pytest.skip("마스터 데이터 바뀜 — 지문 다시 뜸: python resources/tester/test_791_1_…py")
     now = fingerprints()
-    assert len(now) == len(saved["결과"]) >= 1515
+    assert len(now) == len(saved["결과"]) >= 1513  # 813-2 작업량당 기계경비 6 지움
     diff = sorted(k for k in now if now[k] != saved["결과"].get(k))
     assert not diff, f"셈 결과 바뀐 로직 {len(diff)} 개: {diff[:10]}"
 

resources/tester/test_793_1_san_parse.py

@@ -1,171 +0,0 @@
-"""793-1 지킴 — 경쟁사 산근 글 식 파서 · 참조 평가기(`M02_San_*`) · 실무 여덟 파일 금액 그대로.
-
-STmate = 숨은 G 열 원문 식 → 233/233 블록 · 금액 줄 1,315 · 계표시 줄 695 다 맞음.
-EST = 보이는 글 → 식 복원 → 222/222 블록 · 돈 · 값 줄 2,901/2,903 · 모호 단가 토큰 9.
-단가 바뀜 전파 견본 = `_분석_649-G2` 4 장(보통인부 → 180,000).
-엑셀 = `helper_m02_hopyo_golden.FILES`(읽기만) · 없으면 skip(다른 PC).
-"""
-
-from __future__ import annotations
-
-from functools import lru_cache
-
-import helper_m02_hopyo_golden as golden
-import pytest
-
-from M02_MasterTemplete import M02_San_Book as book
-from M02_MasterTemplete import M02_San_Est as est
-from M02_MasterTemplete import M02_San_Eval as ev
-from M02_MasterTemplete import M02_San_Stmate as stm
-
-# 파일: (블록, 금액 줄, 계표시 줄, 끝전)
-STMATE = {
-    "봉화": (62, 349, 184, "비목버림"),
-    "동부청영월": (69, 411, 230, "합버림_큰나머지"),
-    "울진대흥": (47, 261, 128, "비목버림"),
-    "영덕계류": (15, 86, 41, "비목버림"),
-    "울진소광": (40, 208, 112, "비목버림"),
-}
-# 파일: (블록, 돈 · 값 줄, 틀린 줄 상한, 모호 토큰)
-EST = {"북부청임도": (94, 1252, 2, 0), "북부청사방": (67, 849, 0, 7), "거창": (61, 802, 0, 2)}
-LABOR = ("노임", "보통인부", "", "L")
-
-
-@lru_cache(maxsize=8)
-def _load(tag: str) -> dict:
-    path = golden.FILES[tag]
-    if not path.exists():
-        pytest.skip(f"실무 엑셀 없음 {path.name}")
-    return book.load(path)
-
-
-def _stmate_runs(tag: str) -> list[tuple]:
-    data = _load(tag)
-    out = []
-    for blk in data["블록"]:
-        if not any(ln["G"].strip() for ln in blk["몸"]):
-            continue
-        res = ev.stmate_block(blk, stm.parse_block(blk["몸"]), data["단가"], STMATE[tag][3])
-        out.append((blk, res, ev.stmate_check(blk, res)))
-    return out
-
-
-@pytest.mark.parametrize("tag", list(STMATE))
-def test_stmate_blocks_equal_excel(tag: str) -> None:
-    blocks, amount_lines, total_lines, _ = STMATE[tag]
-    runs = _stmate_runs(tag)
-    assert len(runs) == blocks
-    wrong = [b["코드"] for b, _, c in runs if not c["맞음"]]
-    assert not wrong, wrong
-    assert sum(c["금액줄"] for _, _, c in runs) == amount_lines
-    assert [x for _, _, c in runs for x in c["틀린줄"]] == []
-    assert sum(c["계줄"] for _, _, c in runs) == total_lines
-    assert sum(c["계줄맞음"] for _, _, c in runs) == total_lines
-
-
-@pytest.mark.parametrize("tag", list(EST))
-def test_est_blocks_equal_excel(tag: str) -> None:
-    blocks, lines, bad_max, vague = EST[tag]
-    data = _load(tag)
-    n, wrong, got_lines, got_bad, got_vague = 0, [], 0, 0, 0
-    for blk in data["블록"]:
-        want = data["총괄"].get(blk["번"])
-        if not want or not (want["T"] or any(want[c] for c in "LMS")):
-            continue
-        parsed = est.parse_block(blk["글"], data["단가"])
-        chk = ev.est_check(parsed, want)
-        n += 1
-        if not chk["맞음"]:
-            wrong.append(blk["번"])
-        got_lines += chk["줄수"]
-        got_bad += len(chk["틀린줄"])
-        got_vague += sum(1 for L in parsed for r in (L.get("역할") or {}).values() if r.get("모호"))
-    assert (n, wrong) == (blocks, [])
-    assert got_lines == lines
-    assert got_bad <= bad_max
-    assert got_vague == vague
-
-
-@pytest.mark.parametrize(
-    "tag, code, labor, before, after",
-    [
-        ("봉화", "D00102", "L00007", (34119, 11192, 341), (34697, 11192, 346)),
-        ("동부청영월", "D00003", "L00002", (4764, 310, 397), (5097, 309, 397)),
-        ("울진소광", "D01489", "L00016", (182223, 230359, 8152), (185067, 230359, 8209)),
-    ],
-)
-def test_stmate_price_propagates(tag, code, labor, before, after) -> None:
-    data = _load(tag)
-    blk = next(b for b in data["블록"] if b["코드"] == code)
-    nodes = stm.parse_block(blk["몸"])
-    rule = STMATE[tag][3]
-    prices = dict(data["단가"])
-    prices[labor] = {**prices[labor], "T": 180000, "L": 180000}
-    for p, want in ((data["단가"], before), (prices, after)):
-        got = ev.stmate_block(blk, nodes, p, rule)["계"]
-        assert (got["L"], got["M"], got["S"]) == want
-
-
-@pytest.mark.parametrize(
-    "tag, no, after",
-    [
-        ("북부청사방", 31, (14877, 5491, 0)),
-        ("북부청임도", 2, (22774, 3235, 3830)),
-        ("거창", 1, (3485, 832, 1049)),
-        ("북부청사방", 3, (20147, 391, 0)),
-    ],
-)
-def test_est_price_propagates(tag, no, after) -> None:
-    data = _load(tag)
-    blk = next(b for b in data["블록"] if b["번"] == no)
-    parsed = est.parse_block(blk["글"], data["단가"])
-    des = ev.designate(parsed, data["총괄"][no])
-    got = ev.est_block(parsed, des, {LABOR: 180000.0})["금액"]
-    assert (got["L"], got["M"], got["S"]) == after
-
-
-# ── 엑셀 없이 도는 문법 견본(`_분석_648-B` 3-1 봉화 D00102) ──
-def test_stmate_grammar_sample() -> None:
-    prices = {
-        "M00081": {"T": 11468, "L": 0, "M": 11468, "S": 0, "meta": {}},
-        "L00007": {"T": 165545, "L": 165545, "M": 0, "S": 0, "meta": {}},
-        "L00099": {"T": 2, "L": 2, "M": 0, "S": 0, "meta": {"UNT": "L%"}},
-    }
-    text = [
-        "'합판(내수) :'&M00081& * 1.03  * 0.327 :=A01",
-        ";;Q = 2.5 / 3 =",
-        "'보통인부' &L00007& * [Q] / 4 :=A02",
-        "&PA01M:M& * 11'%' =",
-        "&PA02L:S& * 1'%' = // 공구손료",
-        "(=)",
-        "&L00099& * 2 =",
-        "(-=)",
-    ]
-    nodes = stm.parse_block([{"행": i, "G": g} for i, g in enumerate(text)])
-    assert [n["종류"] for n in nodes] == ["참조", "대입", "참조", "율", "율", "계", "참조", "계"]
-    assert nodes[1]["숨김"] and nodes[4]["덧글"] == "공구손료"
-    assert nodes[3]["율"] == {"곱": False, "범위": "A", "번지": ["A01"], "비목": "M", "옮김": "M"}
-    lines, tot = ev.run_stmate(nodes, prices)
-    assert lines[0]["값"]["M"] == 3862.5
-    assert lines[2]["값"]["L"] == 34350.5  # 165,545 × 0.83(Q 반올림) / 4 → 0.1 버림
-    assert lines[3]["값"]["M"] == 424.8  # A01 재료 3,862.5 × 11 %
-    assert lines[4]["값"]["S"] == 343.5  # A02 노무 34,350.5 × 1 % → 경비
-    assert lines[5]["값"] == pytest.approx({"L": 34350.5, "M": 4287.3, "S": 343.5})
-    assert lines[6]["종류"] == "특수" and lines[6]["값"]["L"] == 687.0  # 노무 누계 × 2 %
-    assert lines[7]["값"]["L"] == 687.0  # (-=) 찍되 합에서 뺌
-    assert tot == pytest.approx({"L": 34350.5, "M": 4287.3, "S": 343.5})
-
-
-def test_est_grammar_sample() -> None:
-    prices = [{"종류": "노임", "이름": "보통인부", "규격": "", "비목": "L", "값": 172068.0}]
-    text = [
-        "보통인부 : 172,068 × 0.09 인 = 15,486.1",
-        "공구손료 : 15,486.1 × 3 % = 464.5",
-        "소 계 : 15,950.6",
-        "노무비 : 15,950.6 × 1 = 15,950",
-    ]
-    lines = est.parse_block(text, prices)
-    assert [L.get("종류") for L in lines] == ["단가줄", "참조줄", "값줄", "참조줄"]
-    assert lines[3]["규칙"] == "버림0" and lines[2]["숨은"]["갈래"] == "합"
-    val = ev.run_est(lines, {LABOR: 180000.0})
-    assert val[0] == 16200.0 and val[1] == 486.0 and val[3] == 16686.0