diff --git a/A00_Common/spreadsheet/spreadsheet_links.css b/A00_Common/spreadsheet/spreadsheet_links.css
index e6402728..715161d6 100644
--- a/A00_Common/spreadsheet/spreadsheet_links.css
+++ b/A00_Common/spreadsheet/spreadsheet_links.css
@@ -108,3 +108,29 @@
   padding: 4px 6px;
   color: var(--color-text-muted);
 }
+
+/* 알약으로 이동한 칸 — 굵은 테두리 + 채움 깜빡임(1.6초 · 끝나면 스스로 지워짐) */
+.ss-link-flash {
+  position: absolute;
+  z-index: 4;
+  box-sizing: border-box;
+  border: 3px solid var(--color-accent);
+  pointer-events: none;
+  animation: ss-link-flash 1.6s ease-out 1 both;
+}
+
+@keyframes ss-link-flash {
+  0%,
+  40%,
+  80% {
+    background: color-mix(in srgb, var(--color-accent) 40%, transparent);
+  }
+  20%,
+  60% {
+    background: transparent;
+  }
+  100% {
+    background: transparent;
+    opacity: 0;
+  }
+}
diff --git a/A00_Common/spreadsheet/spreadsheet_links.ts b/A00_Common/spreadsheet/spreadsheet_links.ts
index 44c0d774..72dde7a1 100644
--- a/A00_Common/spreadsheet/spreadsheet_links.ts
+++ b/A00_Common/spreadsheet/spreadsheet_links.ts
@@ -3,6 +3,8 @@
  * 위 알약 막대 — 면적산출(입력값) · 재료산출(자재) 알약을 칸에 연결(PLAN 13장).
  *   칸을 고른 채 밝은 알약을 누르면 그 칸에 연결(알약 흐려짐 + 칸 주소 · 칸 왼아래 작은 세모) ·
  *   흐린 알약을 누르면 연결 칸으로 · 우클릭 [연결 풀기] · 자재 모드는 [자재 더하기] → 고르기 창 → 새 알약.
+ * 자재 모드 알약 목록 = 호스트(M02)가 `항목` 으로 줌(자재 정보 포함 · 저장은 마스터 자재 조합) — [자재 더하기] ·
+ *   우클릭 [목록에서 빼기] 때 `onItemsChange(목록)` 으로 알림(부른 쪽이 마스터에 적음 · 여기는 안 적음).
  * 저장 = 시트 `연결`(계약) · 바꿈은 `시트통째` 명령(되돌리기 짝) · 행열 넣기 · 지우기는 `applyLinked` 가
  * 연결 칸을 옮김(지운 칸이면 빠짐). `createSpreadsheet` 가 `links` 선택 또는 연결 있는 문서일 때만 불러옴(크기 예산).
  * ========================================================================== */
@@ -31,12 +33,16 @@ export interface LinkItem {
   키: string;
   이름: string;
   단위?: string;
+  /** 자재 알약 — 연결하면 이 정보가 칸 연결에 들어감 */
+  자재?: LinkMaterial;
 }
 
 export interface LinkOptions {
   항목: LinkItem[];
-  /** 입력 = 항목이 알약 · 자재 = 연결된 자재 + [자재 더하기] 로 고른 자재 */
+  /** 입력 = 항목이 알약 · 자재 = 항목(자재 정보 포함 · 호스트 목록) + [자재 더하기] 로 더한 자재 */
   모드: "입력" | "자재";
+  /** 자재 모드에서 목록이 바뀔 때(더하기 · 빼기) 새 목록을 알림 — 저장은 부른 쪽 몫 */
+  onItemsChange?: (항목: LinkItem[]) => void;
   /** 자재DB 찾기(빈 글 = 처음 목록) — 자재 모드만 */
   자재찾기?: (글: string) => Promise<LinkMaterial[]>;
 }
@@ -51,12 +57,15 @@ const TEXT = {
   free: "칸을 고른 채 누르면 이 칸에 연결",
   linked: "누르면 연결 칸으로 · 우클릭 연결 풀기",
   unlink: "연결 풀기",
+  remove: "목록에서 빼기",
+  removed: "목록에서 뺌 — 연결도 풀림",
   add: "+ 자재 더하기",
   search: "자재 이름 · 규격 · 코드",
   searching: "찾는 중…",
   none: "맞는 자재 없음",
   fail: "자재 목록을 못 받음",
   picked: "칸을 고른 뒤 새 알약을 누르면 연결",
+  dup: "이미 목록에 있는 자재",
 };
 
 type RowCol = Extract<Command, { 종류: "행넣기" | "행지우기" | "열넣기" | "열지우기" }>;
@@ -102,6 +111,14 @@ export function applyLinked(book: Workbook, command: Command): CommandEffect {
   return { ...eff, undo: { 종류: "묶음", 명령: [eff.undo, ...restore] } };
 }
 
+/** 자재 → 알약(키 = 자재 코드) */
+const ofMaterial = (m: LinkMaterial): LinkItem => ({
+  키: m.코드,
+  이름: m.규격 ? `${m.이름} ${m.규격}` : m.이름,
+  단위: m.단위,
+  자재: m,
+});
+
 export function mountLinks(
   ctx: SpreadsheetContext,
   opts: LinkOptions | undefined,
@@ -113,8 +130,8 @@ export function mountLinks(
   if (opts) ctx.root.prepend(bar);
   const menu = createMapContextMenu("ss");
   ctx.root.append(menu.element);
-  /** 이번에 고른 자재(아직 칸 없음 — 연결하면 문서에 들어감) */
-  const picked = new Map<string, LinkMaterial>();
+  /** 알약 목록 — 호스트가 준 항목 + 더한 자재(자재 모드 · 바뀌면 호스트에 알림) */
+  const items: LinkItem[] = opts ? [...opts.항목] : [];
   let dots: HTMLElement[] = [];
   let pick: HTMLElement | null = null;
 
@@ -133,31 +150,38 @@ export function mountLinks(
     ctx.dispatch({ 종류: "시트통째", 시트: next });
   }
 
-  function link(item: LinkItem, 자재?: LinkMaterial): void {
+  function link(item: LinkItem): void {
     if (ctx.readOnly) return;
     const sheet = ctx.sheet();
     const 칸 = toA1(ctx.selection.활성.r, ctx.selection.활성.c);
     const rest = (sheet.연결 ?? []).filter((l) => l.칸 !== 칸 && l.키 !== item.키);
     const one: CellLink = { 키: item.키, 이름: item.이름, 칸 };
     if (item.단위) one.단위 = item.단위;
-    if (자재) one.자재 = 자재;
+    if (item.자재) one.자재 = item.자재;
     put(sheet, [...rest, one]);
     back();
   }
 
+  /** 그 칸으로 가서 눈에 띄게 깜빡임(굵은 테두리 + 채움 · 테마 색 · 끝나면 스스로 사라짐) */
   function goTo(sheet: Sheet, a1: string): void {
     const p = parseA1(a1);
     if (!p) return;
     if (sheet.id !== ctx.selection.시트) ctx.showSheet(sheet.id);
     ctx.select(selectCell(ctx.sheet(), p.r, p.c), true);
     back();
+    requestAnimationFrame(() => {
+      const { layer, box } = slot(ctx, p.r, p.c);
+      if (!box.w || !box.h) return;
+      const f = el("div", { className: "ss-link-flash" });
+      f.style.cssText = `left:${box.x}px;top:${box.y}px;width:${box.w}px;height:${box.h}px`;
+      f.addEventListener("animationend", () => f.remove());
+      layer.append(f);
+    });
   }
 
-  function pill(
-    item: LinkItem,
-    hit: { sheet: Sheet; link: CellLink } | undefined,
-    자재?: LinkMaterial,
-  ) {
+  const commit = (): void => opts?.onItemsChange?.(items.map((i) => ({ ...i })));
+
+  function pill(item: LinkItem, hit: { sheet: Sheet; link: CellLink } | undefined) {
     const where = hit
       ? hit.sheet.id === ctx.selection.시트
         ? hit.link.칸
@@ -173,21 +197,35 @@ export function mountLinks(
       ],
     });
     b.addEventListener("mousedown", (e) => e.preventDefault()); // 초점은 격자에 둠
-    b.addEventListener("click", () => (hit ? goTo(hit.sheet, hit.link.칸) : link(item, 자재)));
+    b.addEventListener("click", () => (hit ? goTo(hit.sheet, hit.link.칸) : link(item)));
+    const unlink = (): void => {
+      if (hit)
+        put(
+          hit.sheet,
+          (hit.sheet.연결 ?? []).filter((l) => l.키 !== item.키),
+        );
+    };
     b.addEventListener("contextmenu", (e) => {
       e.preventDefault();
-      if (!hit || ctx.readOnly) return;
+      const inList = opts?.모드 === "자재" && items.some((i) => i.키 === item.키);
+      if (ctx.readOnly || !(hit || inList)) return;
       menu.open(e.clientX, e.clientY, [
-        [
-          TEXT.unlink,
-          () => {
-            put(
-              hit.sheet,
-              (hit.sheet.연결 ?? []).filter((l) => l.키 !== item.키),
-            );
-            back();
-          },
-        ],
+        ...(hit ? [[TEXT.unlink, () => (unlink(), back())] as [string, () => void]] : []),
+        ...(inList
+          ? [
+              [
+                TEXT.remove,
+                () => {
+                  unlink();
+                  items.splice(0, items.length, ...items.filter((i) => i.키 !== item.키));
+                  commit();
+                  renderBar();
+                  if (hit) showToast(TEXT.removed, "info");
+                  back();
+                },
+              ] as [string, () => void],
+            ]
+          : []),
       ]);
     });
     return b;
@@ -196,29 +234,22 @@ export function mountLinks(
   function renderBar(): void {
     if (!opts) return;
     const map = found();
-    const items: [LinkItem, LinkMaterial?][] = [];
+    const shown: LinkItem[] = [];
     const seen = new Set<string>();
-    const add = (item: LinkItem, 자재?: LinkMaterial) => {
+    const add = (item: LinkItem) => {
       if (seen.has(item.키)) return;
       seen.add(item.키);
-      items.push([item, 자재]);
+      shown.push(item);
     };
-    const ofMaterial = (m: LinkMaterial): LinkItem => ({
-      키: m.코드,
-      이름: m.규격 ? `${m.이름} ${m.규격}` : m.이름,
-      단위: m.단위,
-    });
-    if (opts.모드 === "입력") for (const item of opts.항목) add(item);
-    // 문서에 있는 연결(항목에서 빠진 것 · 자재) — 풀 수 있게 늘 보임
+    for (const item of items) add(item);
+    // 문서에 있는 연결(목록에서 빠진 것) — 풀 수 있게 늘 보임
     for (const { link } of map.values())
       add(
         link.자재
           ? ofMaterial(link.자재)
           : { 키: link.키, 이름: link.이름 ?? link.키, 단위: link.단위 },
-        link.자재,
       );
-    for (const m of picked.values()) add(ofMaterial(m), m);
-    const pills = items.map(([item, 자재]) => pill(item, map.get(item.키), 자재));
+    const pills = shown.map((item) => pill(item, map.get(item.키)));
     if (opts.모드 === "자재" && opts.자재찾기 && !ctx.readOnly) {
       const more = el("button", {
         className: "ss-link ss-link--add",
@@ -277,10 +308,14 @@ export function mountLinks(
     let seq = 0;
     let timer = 0;
     const choose = (m: LinkMaterial) => {
-      picked.set(m.코드, m);
       closePick();
-      renderBar();
-      showToast(TEXT.picked, "info");
+      if (items.some((i) => i.키 === m.코드)) showToast(TEXT.dup, "info");
+      else {
+        items.push(ofMaterial(m));
+        commit();
+        renderBar();
+        showToast(TEXT.picked, "info");
+      }
       back();
     };
     const search = async (): Promise<void> => {
diff --git a/M01_MasterData/M01_MasterData_Api_Fetch.ts b/M01_MasterData/M01_MasterData_Api_Fetch.ts
index d7b4eb05..f9105aff 100644
--- a/M01_MasterData/M01_MasterData_Api_Fetch.ts
+++ b/M01_MasterData/M01_MasterData_Api_Fetch.ts
@@ -176,7 +176,7 @@ export const fetchPick = (
   q: string,
 ): Promise<{ total: number; items: PickItem[] }> => get("/pick", { kind, q, limit: 50 });
 
-/** 조합 알약 물량 하나 — 담은 로직 결과단위 분모(같은 이름 · 단위는 합침) · `배` = 원/10㎡ 의 10 */
+/** 조합 알약 물량 하나 — 키 = 「이름|단위」 · 담은 로직 결과단위 분모(같은 이름 · 단위는 합침) · `배` = 원/10㎡ 의 10 */
 export interface ComboQuantity {
   키: string;
   이름: string;
diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py
index a411a2cb..942a1ecd 100644
--- a/M01_MasterData/M01_MasterData_Router.py
+++ b/M01_MasterData/M01_MasterData_Router.py
@@ -15,6 +15,7 @@ from pydantic import BaseModel
 from M01_MasterData import M01_MasterData_Store as store
 from M01_MasterData import M01_MasterData_Store_Combo as combo_store
 from M01_MasterData import M01_MasterData_Store_Make as make
+from M01_MasterData import M01_MasterData_Store_Matset as matset_store
 
 router = APIRouter(prefix="/api/m01", tags=["M01 MasterData"])
 
@@ -114,6 +115,20 @@ class PreviewCombo(BaseModel):
     inputs: dict[str, dict[str, Any]] = {}
 
 
+class NewMatset(BaseModel):
+    """자재 조합 — 담은 자재 목록만(코드 · 이름 · 규격 · 단위 · 수량 · 단가는 안 둠)."""
+
+    matset: dict[str, Any]
+    owner: str = matset_store.OWNERS[0]
+
+
+class EditMatset(BaseModel):
+    key: str
+    version: str
+    matset: dict[str, Any]
+    owner: str = ""
+
+
 class DraftLogic(BaseModel):
     text: str  # 줄로 적은 식 — 줄마다 「이름 = 식」
     decided: dict[str, Any] = {}  # 변수마다 정한 것 {이름: {무엇, 단위, 비목, 요소·찾기·값}}
@@ -349,3 +364,29 @@ def post_combo_delete(body: DeleteCombo) -> dict:
 def post_combo_preview(body: PreviewCombo) -> dict:
     """담은 로직마다 값을 뽑아 비목별로 갈라 합계 — 저장하지 않음."""
     return _call(combo_store.combo_preview, body.combo, body.inputs)
+
+
+# ── 자재 조합(계약 9장 끝) ─────────────────────────────────────────────
+@router.get("/matsets")
+def get_matsets(q: str = "", owner: str = "") -> dict:
+    return {"matsets": _call(matset_store.matsets, q, owner)}
+
+
+@router.get("/matset")
+def get_matset(key: str) -> dict:
+    return _call(matset_store.matset, key)
+
+
+@router.post("/matset/new")
+def post_matset_new(body: NewMatset) -> dict:
+    return _call(matset_store.matset_new, body.matset, body.owner)
+
+
+@router.post("/matset/edit")
+def post_matset_edit(body: EditMatset) -> dict:
+    return _call(matset_store.matset_edit, body.key, body.version, body.matset, body.owner)
+
+
+@router.post("/matset/delete")
+def post_matset_delete(body: DeleteCombo) -> dict:
+    return _call(matset_store.matset_delete, body.key, body.version)
diff --git a/M01_MasterData/M01_MasterData_Store_Combo.py b/M01_MasterData/M01_MasterData_Store_Combo.py
index c340e0de..74fba826 100644
--- a/M01_MasterData/M01_MasterData_Store_Combo.py
+++ b/M01_MasterData/M01_MasterData_Store_Combo.py
@@ -8,16 +8,21 @@
 
 from __future__ import annotations
 
+import json
 import re
 from datetime import date
 from pathlib import Path
 
+from config import config_system
 from M01_MasterData import M01_MasterData_Store as store
 
 cm, mk, mcb = store.cm, store.mk, store.mcb
 
 FILE = mcb.FILE
 OWNERS = mcb.OWNERS
+_MT = config_system.PROJECT_ROOT / "resources" / "master_template"
+# 조합을 쓰는 열이 적힌 곳 — 집계표(정본) · 구조물집계표조합(SS 장부) · 시험이 바꿈
+USERS = (_MT / "table" / "구조물집계표.json", _MT / "구조물집계표조합.json")
 
 
 def _path() -> Path:
@@ -47,6 +52,9 @@ def _clean(combo: dict, owner: str, key: str | None = None) -> dict:
         raise store.StoreError(400, "조합 줄에 「이름」 이 없거나 글자 아님")
     if owner not in OWNERS:
         raise store.StoreError(400, f"모르는 소유 「{owner}」 — {' · '.join(OWNERS)}")
+    origin = combo.get("본뜬키")
+    if origin is not None and (origin == key or origin not in _keys()):
+        raise store.StoreError(400, f"본뜬키 「{origin}」 — 비었거나 있는 다른 조합 키여야 함")
     rest = {k: v for k, v in combo.items() if k not in ("키", "원문번호", "소유")}
     one = {**({"키": key} if key else {}), "소유": owner, **rest}
     one.setdefault("출처", "자체")
@@ -150,7 +158,8 @@ def combo_inputs(key: str) -> dict:
     """조합 알약 — 담은 로직마다 결과단위 분모(원/㎥ → ㎥)가 물량 하나.
 
     이름 = 로직 이름 끝 괄호 뗀 것(「(인력)」·「(장비)」 한 알약) · 같은 이름 · 단위면 합침 ·
-    키 = 그 알약 첫 로직 키 · `배` = 분모 앞 수(원/10㎡ → 10 · 1 이면 안 줌) · 돈 아닌 로직은 빠짐.
+    키 = 「이름|단위」(로직을 빼고 더하고 차례를 바꿔도 같은 물량이면 같은 키) ·
+    `배` = 분모 앞 수(원/10㎡ → 10 · 1 이면 안 줌) · 돈 아닌 로직은 빠짐.
     `조건` 은 자리만(설계 조건 고르기 · 범위는 알약에 안 넣음).
     """
     row = _find(_read()[0], key)
@@ -168,7 +177,9 @@ def combo_inputs(key: str) -> dict:
         # ponytail: 분모가 여럿(「원/㎡ · 원/㎥(단위당 따름)」)이면 「㎡ · ㎥」 한 글 — 입력이 고름
         unit = " · ".join(dict.fromkeys(u for _, u in per))
         name = _TAIL.sub("", str(got.get("이름") or code)) or code
-        pill = pills.setdefault((name, unit), {"키": code, "이름": name, "단위": unit, "로직": []})
+        pill = pills.setdefault(
+            (name, unit), {"키": f"{name}|{unit}", "이름": name, "단위": unit, "로직": []}
+        )
         pill["로직"].append(code)
         times = per[0][0]
         if len(per) == 1 and times and float(times) != 1:
@@ -202,14 +213,39 @@ def combo_edit(key: str, version: str, combo_: dict, owner: str = "") -> dict:
     was = _find(data, key)
     if store.read(FILE)[1] != version:
         raise store.StoreError(409, {"stale": [FILE]})
+    if isinstance(combo_, dict):  # 화면이 안 보내도 계보(본뜬키)는 남김
+        combo_ = {"본뜬키": was.get("본뜬키"), **combo_}
     fixed = _clean(combo_, owner or str(was.get("소유") or OWNERS[0]), key)
     done = _write([{"op": "edit", "key": key, "row": fixed}], version)
     return {**done, "combo": _find(store.read(FILE)[0], key)}
 
 
+def users_of(field: str, key: str) -> list[str]:
+    """집계표 · SS 장부에서 열 칸 `field`(「일위대가」 · 「자재조합」)가 `key` 인 열 이름들."""
+    names: dict[str, str] = {}
+    for path in USERS:
+        if not path.is_file():
+            continue
+        doc = json.loads(path.read_text(encoding="utf-8"))
+        for col in doc.get("열") or doc.get("줄") or []:
+            if col.get(field) != key:
+                continue
+            head = col.get("머리") or [col.get(k) for k in ("종류", "분류1", "분류2", "분류3")]
+            cid = str(col.get("id") or col.get("열"))
+            names.setdefault(cid, " ".join(str(h) for h in head if h and str(h).strip()) or cid)
+    return list(names.values())
+
+
+def combo_users(key: str) -> list[str]:
+    return users_of("일위대가", key)
+
+
 def combo_delete(key: str, version: str) -> dict:
     data, _ = _read()
     _find(data, key)
+    if users := combo_users(key):
+        msg = f"구조물 {len(users)} 곳이 쓰는 조합이라 못 지움 — {' · '.join(users)}"
+        raise store.StoreError(409, {"errors": [msg], "users": users})
     if store.read(FILE)[1] != version:
         raise store.StoreError(409, {"stale": [FILE]})
     return _write([{"op": "delete", "key": key}], version)
diff --git a/M01_MasterData/M01_MasterData_Store_Matset.py b/M01_MasterData/M01_MasterData_Store_Matset.py
new file mode 100644
index 00000000..08308fdc
--- /dev/null
+++ b/M01_MasterData/M01_MasterData_Store_Matset.py
@@ -0,0 +1,136 @@
+"""M01 자재 조합 저장소 — 목록 · 하나 읽기 · 만들기 · 고치기 · 지우기.
+
+계약: `_화면_계약.md` 9장 끝 · 파일 모양: `_틀.md` 11장 · 엔진: `scripts/master_matset.py`.
+조합은 담은 자재 목록(코드 · 이름 · 규격 · 단위)만 지님 — 수량 · 단가는 두지 않음(재료산출 몫).
+자리는 `자재조합.json` 한 파일 · 키는 `_키대장.json` 의 `UM` 다음 번호(서버가 줌).
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+
+from M01_MasterData import M01_MasterData_Store as store
+from M01_MasterData import M01_MasterData_Store_Combo as combos
+
+cm = store.cm
+msk = cm.mmc  # sub4 가 세운 자재 조합 엔진(`scripts/master_material_combo.py`)
+
+FILE = msk.FILE
+OWNERS = msk.OWNERS
+
+
+def _path() -> Path:
+    return store.FOLDER / FILE
+
+
+def _make_file() -> None:
+    """파일이 없으면 머리만 두고 만듦."""
+    if not _path().is_file():
+        head = {"그룹": msk.GROUP, "판": str(date.today().year), "줄": []}
+        _path().write_text(store.dump(head), encoding="utf-8", newline="\n")
+
+
+def _read() -> tuple[dict, str]:
+    _make_file()
+    return store.read(FILE)
+
+
+def _keys() -> list[str]:
+    return [str(r.get("키")) for r in _read()[0].get("줄") or []]
+
+
+def _find(data: dict, key: str) -> dict:
+    for row in data.get("줄") or []:
+        if str(row.get("키")) == key:
+            return row
+    raise store.StoreError(404, f"없는 자재 조합 「{key}」")
+
+
+def _clean(one: dict, owner: str, key: str | None = None) -> dict:
+    """서버가 잡는 칸 — 키 · 소유 · 열 한 벌(안 준 칸은 null · 자재 줄은 네 칸만)."""
+    if not isinstance(one, dict):
+        raise store.StoreError(400, "자재 조합 줄이 묶음 아님")
+    name = one.get("이름")
+    if not isinstance(name, str) or not name.strip():
+        raise store.StoreError(400, "자재 조합 줄에 「이름」 이 없거나 글자 아님")
+    if owner not in OWNERS:
+        raise store.StoreError(400, f"모르는 소유 「{owner}」 — {' · '.join(OWNERS)}")
+    origin = one.get("본뜬키")
+    if origin is not None and (origin == key or origin not in _keys()):
+        raise store.StoreError(400, f"본뜬키 「{origin}」 — 비었거나 있는 다른 자재 조합 키여야 함")
+    got = one.get("담은자재")
+    if isinstance(got, list):  # 화면이 덤을 실어도 자재 줄은 네 칸만 · 안 준 칸은 빈 글
+        got = [{c: m.get(c, "") for c in msk.ITEM_COLS} if isinstance(m, dict) else m for m in got]
+    rest = {k: v for k, v in one.items() if k not in ("키", "원문번호", "소유")}
+    _check_codes(got)
+    row = {**({"키": key} if key else {}), "소유": owner, **rest, "담은자재": got or []}
+    for col in msk.COLS:
+        row.setdefault(col, None)
+    return {k: row[k] for k in msk.COLS if k in row}
+
+
+def _check_codes(got) -> None:
+    """담은 자재 코드가 마스터 어느 줄에도 없으면 422 — 틀 검사는 저장 길(`store.save`)이 함."""
+    if not isinstance(got, list) or not got:
+        return
+    known = {str(r.get("키")) for d in store.loaded()[0].values() for r in d.get("줄") or []}
+    lost = [str(m.get("코드")) for m in got if isinstance(m, dict) and m.get("코드") not in known]
+    if lost:
+        raise store.StoreError(422, {"errors": [f"마스터에 없는 자재 {' · '.join(lost)}"]})
+
+
+def _write(changes: list[dict], version: str | None = None) -> dict:
+    _make_file()
+    return store.save(
+        [{"file": FILE, "version": version or store.read(FILE)[1], "changes": changes}]
+    )[0]
+
+
+def matsets(q: str = "", owner: str = "") -> list[dict]:
+    """목록 — 찾기(이름 · 키)와 소유로 거름 · 줄마다 자재 수."""
+    out = []
+    for row in store.loaded()[0].get(FILE, {}).get("줄") or []:
+        if owner and row.get("소유") != owner:
+            continue
+        if not store._hit(row, q):
+            continue
+        out.append(
+            {k: row.get(k) for k in msk.COLS if k != "담은자재"}
+            | {"file": FILE, "count": len(msk.items(row))}
+        )
+    return out
+
+
+def matset(key: str) -> dict:
+    data, version = _read()
+    return {"file": FILE, "version": version, "matset": _find(data, key)}
+
+
+def matset_new(one: dict, owner: str = OWNERS[0]) -> dict:
+    """새 자재 조합 — 키는 서버가 `UM` 다음 번호로 줌."""
+    before = set(_keys())
+    done = _write([{"op": "add", "row": _clean(one, owner)}])
+    key = next((k for k in reversed(_keys()) if k not in before), "")
+    return {**done, "key": key, "matset": _find(_read()[0], key) if key else {}}
+
+
+def matset_edit(key: str, version: str, one: dict, owner: str = "") -> dict:
+    data, _ = _read()
+    was = _find(data, key)
+    if store.read(FILE)[1] != version:
+        raise store.StoreError(409, {"stale": [FILE]})
+    fixed = _clean(one, owner or str(was.get("소유") or OWNERS[0]), key)
+    done = _write([{"op": "edit", "key": key, "row": fixed}], version)
+    return {**done, "matset": _find(_read()[0], key)}
+
+
+def matset_delete(key: str, version: str) -> dict:
+    """지우기 — 구조물 열이 「자재조합」 칸으로 쓰면 409 + 구조물 이름들(지우지 않음)."""
+    _find(_read()[0], key)
+    if users := combos.users_of("자재조합", key):
+        msg = f"구조물 {len(users)} 곳이 쓰는 자재 조합이라 못 지움 — {' · '.join(users)}"
+        raise store.StoreError(409, {"errors": [msg], "users": users})
+    if store.read(FILE)[1] != version:
+        raise store.StoreError(409, {"stale": [FILE]})
+    return _write([{"op": "delete", "key": key}], version)
diff --git a/M01_MasterData/M01_MasterData_UI_Combo.ts b/M01_MasterData/M01_MasterData_UI_Combo.ts
index fa94820a..4d992d94 100644
--- a/M01_MasterData/M01_MasterData_UI_Combo.ts
+++ b/M01_MasterData/M01_MasterData_UI_Combo.ts
@@ -39,6 +39,7 @@ const blankCombo = (): Combo => ({
   담은로직: [],
   출처: "자체",
   소유: "현장",
+  본뜬키: null,
   비고: null,
 });
 
@@ -162,14 +163,21 @@ export function mountM01Combo(
       tc("Detail"),
       tc("Head_Unit"),
       tc("Head_Count"),
+      tc("Head_Origin"),
     ];
     const rows = shown.map((x) => {
       const tr = el("tr", {
         className: "m01-master__table-row",
         attrs: { "data-combo-key": x.키 },
-        children: [x.키, x.이름, x.구분 ?? "", x.상세구분 ?? "", x.단위 ?? "", String(x.count)].map(
-          (v) => el("td", { text: v }),
-        ),
+        children: [
+          x.키,
+          x.이름,
+          x.구분 ?? "",
+          x.상세구분 ?? "",
+          x.단위 ?? "",
+          String(x.count),
+          x.본뜬키 ?? tc("Origin_Self"),
+        ].map((v) => el("td", { text: v })),
       });
       tr.addEventListener("click", () => void open(x.키));
       return tr;
@@ -238,7 +246,7 @@ export function mountM01Combo(
         memo.input.value = row.메모 ?? "";
         memo.input.addEventListener("input", () => (row.메모 = memo.input.value || null));
         const name = el("button", {
-          className: "ui-btn ui-btn--ghost",
+          className: "ui-btn ui-btn--ghost ui-btn--sm",
           text: info?.이름 ?? row.로직,
           attrs: { type: "button", title: tc("Open") },
         });
@@ -249,11 +257,22 @@ export function mountM01Combo(
         const btns = el("div", {
           className: "m01-logic__chips",
           children: [
-            createButton({ label: tc("Up"), variant: "ghost", onClick: () => move(i, -1) }),
-            createButton({ label: tc("Down"), variant: "ghost", onClick: () => move(i, 1) }),
+            createButton({
+              label: tc("Up"),
+              variant: "ghost",
+              size: "sm",
+              onClick: () => move(i, -1),
+            }),
+            createButton({
+              label: tc("Down"),
+              variant: "ghost",
+              size: "sm",
+              onClick: () => move(i, 1),
+            }),
             createButton({
               label: tc("Remove"),
               variant: "ghost",
+              size: "sm",
               onClick: () => {
                 combo.담은로직.splice(i, 1);
                 drawTable();
@@ -358,6 +377,11 @@ export function mountM01Combo(
               field(tc("Detail"), "상세구분"),
               field(tc("Head_Unit"), "단위"),
               field(tc("Head_Note"), "비고"),
+              el("p", {
+                className: "m01-logic__muted",
+                text: `${tc("Head_Origin")}: ${combo.본뜬키 ?? tc("Origin_Self")}`,
+                attrs: { "data-combo-origin": combo.본뜬키 ?? "" },
+              }),
             ],
           }),
         ],
diff --git a/M01_MasterData/M01_MasterData_UI_Combo_Api.ts b/M01_MasterData/M01_MasterData_UI_Combo_Api.ts
index c0ea8a02..9a9bd455 100644
--- a/M01_MasterData/M01_MasterData_UI_Combo_Api.ts
+++ b/M01_MasterData/M01_MasterData_UI_Combo_Api.ts
@@ -22,6 +22,8 @@ export interface Combo {
   담은로직: ComboLogic[];
   출처: string | null;
   소유: string | null;
+  /** 이 조합을 본떠 만든 원본 키 — 비면 원본(M02 가 갈라 낸 조합에 채워짐) */
+  본뜬키: string | null;
   비고: string | null;
 }
 export interface ComboSummary extends Combo {
diff --git a/M01_MasterData/M01_MasterData_UI_Combo_Text.ts b/M01_MasterData/M01_MasterData_UI_Combo_Text.ts
index 4456b20f..0e2dcefc 100644
--- a/M01_MasterData/M01_MasterData_UI_Combo_Text.ts
+++ b/M01_MasterData/M01_MasterData_UI_Combo_Text.ts
@@ -30,6 +30,8 @@ const TEXT = {
   Head_Unit: ["단위", "Unit"],
   Head_Note: ["비고", "Note"],
   Head_Count: ["로직 수", "Logics"],
+  Head_Origin: ["본뜬키", "Copied from"],
+  Origin_Self: ["원본", "Original"],
   Logics_Title: ["담은 로직", "Logics in it"],
   Col_Order: ["차례", "No."],
   Col_Key: ["로직 키", "Logic key"],
diff --git a/M01_MasterData/M01_MasterData_UI_Matset.ts b/M01_MasterData/M01_MasterData_UI_Matset.ts
new file mode 100644
index 00000000..d7bded9e
--- /dev/null
+++ b/M01_MasterData/M01_MasterData_UI_Matset.ts
@@ -0,0 +1,367 @@
+/* =============================================================================
+ * M01_MasterData_UI_Matset.ts
+ * 자재 조합 화면 — 왼쪽 컨테이너(찾기) / 오른쪽 목록 · 상세 (일위대가 조합 화면과 같은 틀)
+ * 상세 = 이름 · 비고 + 본뜬키 줄 + 담은 자재 표(코드 · 이름 · 규격 · 단위 · 빼기) + [자재 더하기]
+ * 저장 · 지우기는 서버 자재 조합 마스터(`자재조합.json` · 키 UM) — 길은 `Matset_Api` 한 곳
+ * ========================================================================== */
+
+import {
+  createButton,
+  createInputField,
+  el,
+  showConfirmDialog,
+  showToast,
+} from "@ui/ui_template_elements";
+import { searchMaterials } from "./M01_MasterData_Api_Fetch";
+import { ApiError } from "./M01_MasterData_UI_Logic_Api";
+import {
+  deleteMatset,
+  editMatset,
+  fetchMatset,
+  fetchMatsets,
+  newMatset,
+  type MatItem,
+  type Matset,
+  type MatsetSummary,
+} from "./M01_MasterData_UI_Matset_Api";
+import { tm } from "./M01_MasterData_UI_Matset_Text";
+import type { SideHandle } from "./M01_MasterData_UI_Side";
+import "./M01_MasterData_UI_Logic_Style.css";
+import "./M01_MasterData_UI_LogicLab_Style.css";
+
+const blank = (): Matset => ({
+  키: "",
+  이름: "",
+  담은자재: [],
+  본뜬키: null,
+  소유: "현장",
+  비고: null,
+});
+
+/** 서버가 준 까닭 — 422 · 409(지우기 막음) 는 글 목록 · 409 낡은 판본은 stale */
+function reason(error: unknown): string {
+  if (error instanceof ApiError && typeof error.detail === "object" && error.detail) {
+    const d = error.detail as { errors?: string[]; stale?: string[] };
+    if (d.errors) return d.errors.join(" / ");
+    if (d.stale) return tm("Stale");
+  }
+  return error instanceof Error ? error.message : tm("Load_Failed");
+}
+
+const fail = (error: unknown): void =>
+  showToast(error instanceof Error ? error.message : tm("Load_Failed"), "error");
+
+/** [자재 더하기] 창 — 낱말로 자재DB 를 찾아 하나씩 고름 */
+function openMaterialPicker(have: Set<string>, done: (item: MatItem) => void): void {
+  const search = createInputField({ type: "search", placeholder: tm("Pick_Search") });
+  const list = el("div", { className: "m01-logic__pick-list" });
+  const hint = el("p", { className: "m01-logic__muted", text: tm("Pick_Hint") });
+  const close = (): void => backdrop.remove();
+  const find = async (): Promise<void> => {
+    try {
+      const found = await searchMaterials(search.input.value.trim());
+      hint.textContent = found.length ? String(found.length) : tm("Pick_None");
+      list.replaceChildren(
+        ...found.map((x) => {
+          const taken = have.has(x.코드);
+          const row = el("button", {
+            className: "m01-logic__pick-row m01-logic__pick-row--button",
+            attrs: { type: "button", "data-pick": x.코드, ...(taken ? { disabled: "" } : {}) },
+            children: [
+              el("div", {
+                className: "m01-logic__stack",
+                children: [
+                  el("strong", { text: x.이름 }),
+                  el("span", { className: "m01-logic__muted", text: `${x.코드} · ${x.규격}` }),
+                ],
+              }),
+              el("span", { text: taken ? tm("Pick_Have") : x.단위 }),
+            ],
+          });
+          row.addEventListener("click", () => {
+            close();
+            done(x);
+          });
+          return row;
+        }),
+      );
+    } catch (error) {
+      fail(error);
+    }
+  };
+  search.input.addEventListener("keydown", (ev) => ev.key === "Enter" && void find());
+  const dialog = el("div", {
+    className: "m01-logic__pick",
+    attrs: { role: "dialog", "aria-label": tm("Pick_Title") },
+    children: [
+      el("div", {
+        className: "m01-logic__section-head",
+        children: [
+          el("h3", { text: tm("Pick_Title") }),
+          createButton({ label: tm("Pick_Close"), variant: "ghost", onClick: close }),
+        ],
+      }),
+      el("div", {
+        className: "m01-logic__filters",
+        children: [
+          search.root,
+          createButton({ label: tm("Pick_Find"), variant: "filled", onClick: () => void find() }),
+        ],
+      }),
+      hint,
+      list,
+    ],
+  });
+  const backdrop = el("div", { className: "m01-logic__backdrop", children: [dialog] });
+  backdrop.addEventListener("click", (ev) => ev.target === backdrop && close());
+  backdrop.addEventListener("keydown", (ev) => ev.key === "Escape" && close());
+  document.body.append(backdrop);
+  search.input.focus();
+}
+
+export interface MatsetHandle {
+  /** 컨테이너를 펼칠 때 — 목록을 새로 받아 그림 */
+  show: () => Promise<void>;
+}
+
+export function mountM01Matset(host: HTMLElement, side: SideHandle): MatsetHandle {
+  let items: MatsetSummary[] = [];
+  let q = "";
+  /** 화면을 바꾼 횟수 — 늦게 온 답은 이 값이 달라졌으면 버림 */
+  let nav = 0;
+  /** 열어 둔 상세 — 다른 화면에 갔다 와도 그대로 돌아오게 기억 */
+  let current: { matset: Matset; version: string } | null = null;
+  const view = el("div", { className: "m01-logic__editor" });
+  host.replaceChildren(view);
+
+  const find = createInputField({ type: "search", placeholder: tm("Search") });
+  find.input.addEventListener("input", () => {
+    q = find.input.value.trim().toLowerCase();
+    if (!current) drawList();
+  });
+  side.matsetHost.replaceChildren(find.root);
+
+  const load = async (redraw = true): Promise<void> => {
+    const my = nav;
+    try {
+      items = await fetchMatsets();
+    } catch (error) {
+      fail(error);
+    }
+    if (redraw && my === nav) drawList();
+  };
+
+  const show = async (): Promise<void> => {
+    if (!items.length && !current) {
+      view.replaceChildren(el("p", { className: "m01-logic__muted", text: tm("Loading") }));
+    }
+    await load(false);
+    if (current) draw(current.matset, current.version);
+    else drawList();
+  };
+
+  /* --- 목록 --- */
+  const drawList = (): void => {
+    nav++;
+    current = null;
+    const shown = items.filter((x) => !q || `${x.키} ${x.이름}`.toLowerCase().includes(q));
+    const heads = [
+      tm("Head_Key"),
+      tm("Head_Name"),
+      tm("Head_Count"),
+      tm("Head_Origin"),
+      tm("Head_Owner"),
+    ];
+    const rows = shown.map((x) => {
+      const tr = el("tr", {
+        className: "m01-master__table-row",
+        attrs: { "data-matset-key": x.키 },
+        children: [x.키, x.이름, String(x.count), x.본뜬키 ?? tm("Origin_Self"), x.소유 ?? ""].map(
+          (v) => el("td", { text: v }),
+        ),
+      });
+      tr.addEventListener("click", () => void open(x.키));
+      return tr;
+    });
+    view.replaceChildren(
+      el("div", {
+        className: "m01-logic__section-head",
+        children: [
+          createButton({ label: tm("New"), variant: "filled", onClick: () => draw(blank(), "") }),
+        ],
+      }),
+      shown.length
+        ? el("div", {
+            className: "m01-master__grid-wrap",
+            children: [
+              el("table", {
+                className: "m01-master__grid",
+                children: [
+                  el("thead", {
+                    children: [el("tr", { children: heads.map((t) => el("th", { text: t })) })],
+                  }),
+                  el("tbody", { children: rows }),
+                ],
+              }),
+            ],
+          })
+        : el("p", { className: "m01-logic__muted", text: tm("Empty") }),
+    );
+  };
+
+  const open = async (key: string): Promise<void> => {
+    try {
+      const my = ++nav;
+      const one = await fetchMatset(key);
+      if (my !== nav) return;
+      draw(one.matset, one.version);
+    } catch (error) {
+      fail(error);
+    }
+  };
+
+  /* --- 상세 --- */
+  const draw = (matset: Matset, version: string): void => {
+    nav++;
+    current = { matset, version };
+    const field = (label: string, name: "이름" | "비고") => {
+      const f = createInputField({ type: "text", label });
+      f.input.value = matset[name] ?? "";
+      f.input.setAttribute("data-matset-field", name);
+      f.input.addEventListener("input", () => {
+        if (name === "이름") matset.이름 = f.input.value;
+        else matset.비고 = f.input.value || null;
+      });
+      return f.root;
+    };
+    const table = el("div", { className: "m01-master__grid-wrap" });
+    const drawTable = (): void => {
+      const trs = matset.담은자재.map((m, i) =>
+        el("tr", {
+          attrs: { "data-matset-item": m.코드 },
+          children: [
+            el("td", { text: m.코드 }),
+            el("td", { text: m.이름 }),
+            el("td", { text: m.규격 }),
+            el("td", { text: m.단위 }),
+            el("td", {
+              children: [
+                createButton({
+                  label: tm("Remove"),
+                  variant: "ghost",
+                  size: "sm",
+                  onClick: () => {
+                    matset.담은자재.splice(i, 1);
+                    drawTable();
+                  },
+                }),
+              ],
+            }),
+          ],
+        }),
+      );
+      const heads = [
+        tm("Col_Code"),
+        tm("Col_Name"),
+        tm("Col_Spec"),
+        tm("Col_Unit"),
+        tm("Col_Move"),
+      ];
+      table.replaceChildren(
+        el("table", {
+          className: "m01-master__grid",
+          children: [
+            el("thead", {
+              children: [el("tr", { children: heads.map((t) => el("th", { text: t })) })],
+            }),
+            el("tbody", { children: trs }),
+          ],
+        }),
+        ...(trs.length ? [] : [el("p", { className: "m01-logic__muted", text: tm("NoItem") })]),
+      );
+    };
+    drawTable();
+
+    const add = createButton({
+      label: tm("AddItem"),
+      variant: "filled",
+      onClick: () =>
+        openMaterialPicker(new Set(matset.담은자재.map((m) => m.코드)), (x) => {
+          matset.담은자재.push({ 코드: x.코드, 이름: x.이름, 규격: x.규격, 단위: x.단위 });
+          drawTable();
+        }),
+    });
+    const save = createButton({
+      label: tm("Save"),
+      variant: "filled",
+      onClick: async () => {
+        if (!matset.이름.trim()) return showToast(tm("NeedName"), "error");
+        if (!matset.담은자재.length) return showToast(tm("NeedItem"), "error");
+        const my = nav;
+        try {
+          const key = matset.키 ? matset.키 : (await newMatset(matset)).key;
+          if (matset.키) await editMatset(matset.키, version, matset);
+          showToast(tm("Saved"), "success");
+          await load(false);
+          if (my !== nav) {
+            if (current?.matset === matset) current = null; // 저장 사이에 나감 — 옛 판본을 붙들지 않음
+            return;
+          }
+          await open(key);
+        } catch (error) {
+          showToast(reason(error), "error");
+        }
+      },
+    });
+    const remove = createButton({
+      label: tm("Delete"),
+      variant: "ghost",
+      onClick: async () => {
+        if (!matset.키 || !(await showConfirmDialog(tm("DeleteAsk")))) return;
+        try {
+          await deleteMatset(matset.키, version);
+          showToast(tm("Deleted"), "success");
+          await load();
+        } catch (error) {
+          showToast(reason(error), "error");
+        }
+      },
+    });
+    const back = createButton({ label: "←", variant: "ghost", onClick: () => drawList() });
+    view.replaceChildren(
+      el("div", {
+        className: "m01-logic__section-head",
+        children: [back, el("h3", { text: matset.키 || tm("New") }), remove, save],
+      }),
+      el("section", {
+        className: "m01lab__box m01-logic__section",
+        children: [
+          el("div", {
+            className: "m01lab__info",
+            children: [
+              field(tm("Head_Name"), "이름"),
+              field(tm("Head_Note"), "비고"),
+              el("p", {
+                className: "m01-logic__muted",
+                text: `${tm("Head_Origin")}: ${matset.본뜬키 ?? tm("Origin_Self")}`,
+                attrs: { "data-matset-origin": matset.본뜬키 ?? "" },
+              }),
+            ],
+          }),
+        ],
+      }),
+      el("section", {
+        className: "m01lab__box m01-logic__section",
+        children: [
+          el("div", {
+            className: "m01-logic__section-head",
+            children: [el("h3", { text: tm("Items_Title") }), add],
+          }),
+          table,
+        ],
+      }),
+    );
+  };
+
+  return { show };
+}
diff --git a/M01_MasterData/M01_MasterData_UI_Matset_Api.ts b/M01_MasterData/M01_MasterData_UI_Matset_Api.ts
new file mode 100644
index 00000000..251b6ea0
--- /dev/null
+++ b/M01_MasterData/M01_MasterData_UI_Matset_Api.ts
@@ -0,0 +1,60 @@
+/* =============================================================================
+ * M01_MasterData_UI_Matset_Api.ts
+ * 자재 조합(`자재조합.json` · 키 UM) 서버 길 — 목록 · 하나 · 새로 · 고치기 · 지우기
+ * 계약: `resources/master_data/_화면_계약.md` 9장 「자재 조합」
+ * ========================================================================== */
+
+import { API_BASE_URL } from "@config/config_frontend";
+import { ApiError } from "./M01_MasterData_UI_Logic_Api";
+
+/** 담은 자재 한 줄 — 고를 때의 사본(수량 · 단가는 안 둠) */
+export interface MatItem {
+  코드: string;
+  이름: string;
+  규격: string;
+  단위: string;
+}
+export interface Matset {
+  키: string;
+  이름: string;
+  담은자재: MatItem[];
+  /** 본뜬 원본 자재 조합 키 — 비면 원본 */
+  본뜬키: string | null;
+  소유: string | null;
+  비고: string | null;
+}
+export interface MatsetSummary extends Omit<Matset, "담은자재"> {
+  count: number;
+}
+export interface MatsetOne {
+  file: string;
+  version: string;
+  matset: Matset;
+}
+
+async function request<T>(path: string, body?: unknown): Promise<T> {
+  const response = await fetch(`${API_BASE_URL}/m01${path}`, {
+    method: body === undefined ? "GET" : "POST",
+    credentials: "include",
+    headers: { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const data = (await response.json().catch(() => ({}))) as { detail?: unknown } & T;
+  if (!response.ok) throw new ApiError(response.status, data.detail ?? response.statusText);
+  return data;
+}
+
+export const fetchMatsets = (): Promise<MatsetSummary[]> =>
+  request<{ matsets: MatsetSummary[] }>("/matsets").then((d) => d.matsets);
+
+export const fetchMatset = (key: string): Promise<MatsetOne> =>
+  request(`/matset?key=${encodeURIComponent(key)}`);
+
+export const newMatset = (matset: Matset): Promise<{ key: string; version: string }> =>
+  request("/matset/new", { matset });
+
+export const editMatset = (key: string, version: string, matset: Matset): Promise<unknown> =>
+  request("/matset/edit", { key, version, matset });
+
+export const deleteMatset = (key: string, version: string): Promise<unknown> =>
+  request("/matset/delete", { key, version });
diff --git a/M01_MasterData/M01_MasterData_UI_Matset_Text.ts b/M01_MasterData/M01_MasterData_UI_Matset_Text.ts
new file mode 100644
index 00000000..734bb890
--- /dev/null
+++ b/M01_MasterData/M01_MasterData_UI_Matset_Text.ts
@@ -0,0 +1,59 @@
+/* =============================================================================
+ * M01_MasterData_UI_Matset_Text.ts
+ * 자재 조합 화면 글자 — [한국어, 영어]
+ * ========================================================================== */
+
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+
+const TEXT = {
+  Title: ["자재 조합", "Material set"],
+  Search: ["이름 · 키로 찾기", "Search by name or key"],
+  Empty: [
+    "자재 조합이 없음 — [새 자재 조합]으로 만듦",
+    "No material sets — press [New material set]",
+  ],
+  New: ["새 자재 조합", "New material set"],
+  Delete: ["지우기", "Delete"],
+  Save: ["저장", "Save"],
+  DeleteAsk: ["이 자재 조합을 지울까요?", "Delete this material set?"],
+  Saved: ["저장함", "Saved"],
+  Deleted: ["지움", "Deleted"],
+  Stale: ["그 사이 자재 조합 파일이 바뀜 — 다시 열어 주세요", "The file changed — reopen it"],
+  Loading: ["불러오는 중…", "Loading…"],
+  NeedName: ["이름을 적어야 저장됨", "A name is required"],
+  NeedItem: ["담은 자재가 하나는 있어야 저장됨", "Add at least one material"],
+  Load_Failed: ["불러오지 못함", "Load failed"],
+  Head_Key: ["키", "Key"],
+  Head_Name: ["이름", "Name"],
+  Head_Count: ["자재 수", "Materials"],
+  Head_Origin: ["본뜬키", "Copied from"],
+  Head_Owner: ["소유", "Owner"],
+  Head_Note: ["비고", "Note"],
+  Origin_Self: ["원본", "Original"],
+  Items_Title: ["담은 자재", "Materials in it"],
+  Col_Code: ["자재 코드", "Code"],
+  Col_Name: ["이름", "Name"],
+  Col_Spec: ["규격", "Spec"],
+  Col_Unit: ["단위", "Unit"],
+  Col_Move: ["빼기", "Remove"],
+  Remove: ["빼기", "Remove"],
+  AddItem: ["자재 더하기", "Add material"],
+  NoItem: ["담은 자재 없음", "No materials yet"],
+  Pick_Title: ["자재 고르기", "Pick a material"],
+  Pick_Search: ["이름 · 규격으로 찾기", "Search by name or spec"],
+  Pick_Find: ["찾기", "Find"],
+  Pick_Hint: [
+    "낱말을 적고 [찾기]를 누름 — 하나씩 직접 고름",
+    "Type words, press Find — pick one by one",
+  ],
+  Pick_None: ["찾은 자재 없음", "No materials found"],
+  Pick_Have: ["이미 담음", "Already in"],
+  Pick_Close: ["닫기", "Close"],
+} as const satisfies Record<string, readonly [string, string]>;
+
+export type MatsetTextKey = keyof typeof TEXT;
+
+export function tm(key: MatsetTextKey): string {
+  const entry = TEXT[key];
+  return entry[currentLanguageIndex as 0 | 1] ?? entry[0];
+}
diff --git a/M01_MasterData/M01_MasterData_UI_Page.ts b/M01_MasterData/M01_MasterData_UI_Page.ts
index 211b16ff..e4437db8 100644
--- a/M01_MasterData/M01_MasterData_UI_Page.ts
+++ b/M01_MasterData/M01_MasterData_UI_Page.ts
@@ -39,6 +39,7 @@ import { tl } from "./M01_MasterData_UI_LogicLab_Text";
 import { renderTables } from "./M01_MasterData_UI_Tables";
 import type { LogicHandle } from "./M01_MasterData_UI_LogicLab";
 import type { ComboHandle } from "./M01_MasterData_UI_Combo";
+import type { MatsetHandle } from "./M01_MasterData_UI_Matset";
 import "./M01_MasterData_UI_Style.css";
 
 const TABLE_GROUPS = ["소요량", "계수"];
@@ -60,6 +61,7 @@ function buildPage(): HTMLElement {
   let dispose = (): void => {};
   let logicMounted = false;
   let comboHandle: ComboHandle | null = null;
+  let matsetHandle: MatsetHandle | null = null;
 
   /* --- 우측: 머리(제목·찾기·저장) + 알림 + 본문 --- */
   const title = el("h2", { className: "m01-master__title", text: L("M01_PickFile") });
@@ -76,6 +78,7 @@ function buildPage(): HTMLElement {
   });
   const logicHost = el("div", { className: "m01-master__logic", attrs: { hidden: "" } });
   const comboHost = el("div", { className: "m01-master__logic", attrs: { hidden: "" } });
+  const matsetHost = el("div", { className: "m01-master__logic", attrs: { hidden: "" } });
   const elementView = el("div", {
     className: "m01-master__elements",
     children: [
@@ -98,9 +101,10 @@ function buildPage(): HTMLElement {
   onDraftChange(refreshBar);
   refreshBar();
 
-  const showMode = (mode: "elements" | "logic" | "combo"): void => {
+  const showMode = (mode: "elements" | "logic" | "combo" | "matset"): void => {
     logicHost.hidden = mode !== "logic";
     comboHost.hidden = mode !== "combo";
+    matsetHost.hidden = mode !== "matset";
     elementView.hidden = mode !== "elements";
   };
 
@@ -222,6 +226,22 @@ function buildPage(): HTMLElement {
     });
   };
 
+  /** 「자재 조합」 — 목록을 새로 받아 그림 */
+  const openMatsetTab = (): void => {
+    dispose();
+    dispose = (): void => {};
+    current = null;
+    showMode("matset");
+    if (matsetHandle) {
+      void matsetHandle.show();
+      return;
+    }
+    void import("./M01_MasterData_UI_Matset").then((m) => {
+      matsetHandle = m.mountM01Matset(matsetHost, side);
+      void matsetHandle.show();
+    });
+  };
+
   /** 알약 → 마스터 화면 — 찾기 글을 그 키로 두고 열고, 알림줄에 「단가산출 로직으로 돌아가기」를 둠 */
   const jump = async (target: MasterJump): Promise<void> => {
     let group = target.kind === "element" ? target.group : "";
@@ -262,7 +282,7 @@ function buildPage(): HTMLElement {
   setMasterJump((target) => void jump(target));
 
   /* --- 좌측: 컨테이너 --- */
-  const side = buildSide(openFile, () => openLogicTab(), openComboTab);
+  const side = buildSide(openFile, () => openLogicTab(), openComboTab, openMatsetTab);
 
   const layout = el("div", { className: "ui-workflow-layout m01-master" });
   const main = el("main", {
@@ -270,7 +290,7 @@ function buildPage(): HTMLElement {
     children: [
       el("div", {
         className: "m01-master__panel",
-        children: [elementView, logicHost, comboHost],
+        children: [elementView, logicHost, comboHost, matsetHost],
       }),
     ],
   });
diff --git a/M01_MasterData/M01_MasterData_UI_Rows.ts b/M01_MasterData/M01_MasterData_UI_Rows.ts
index 07f5b564..a3b5d24d 100644
--- a/M01_MasterData/M01_MasterData_UI_Rows.ts
+++ b/M01_MasterData/M01_MasterData_UI_Rows.ts
@@ -248,12 +248,13 @@ export function renderRows(host: HTMLElement, pick: Pick, q: string): () => void
 }
 
 function actionCell(label: string, onClick: () => void): HTMLTableCellElement {
-  return el("td", { children: [createButton({ label, variant: "ghost", onClick })] });
+  return el("td", { children: [createButton({ label, variant: "ghost", size: "sm", onClick })] });
 }
 
 type Put = (row: Row) => void;
 
-const rowBtn = (label: string): HTMLButtonElement => createButton({ label, variant: "ghost" });
+const rowBtn = (label: string): HTMLButtonElement =>
+  createButton({ label, variant: "ghost", size: "sm" });
 
 /** 품셈재료 — 가격 연결(자재품목 키 · 후보 조건 · 없음) · 고르기 모달. */
 function linkedCell(row: Row, cur: Row, put?: Put): HTMLTableCellElement {
diff --git a/M01_MasterData/M01_MasterData_UI_Side.ts b/M01_MasterData/M01_MasterData_UI_Side.ts
index 2e31508d..187d84f5 100644
--- a/M01_MasterData/M01_MasterData_UI_Side.ts
+++ b/M01_MasterData/M01_MasterData_UI_Side.ts
@@ -11,6 +11,7 @@ import { t as L } from "@ui/ui_template_locale";
 import { fetchFiles, fetchSubsAll, type FileInfo, type SubInfo } from "./M01_MasterData_Api_Fetch";
 import { tx } from "./M01_MasterData_UI_Logic_Text";
 import { tc } from "./M01_MasterData_UI_Combo_Text";
+import { tm } from "./M01_MasterData_UI_Matset_Text";
 import { renderTree, type MakeRow } from "./M01_MasterData_UI_Tree";
 
 /** 컨테이너마다 기억하는 화면 상태 — 찾기 글 · 쪽 · 소요량·계수 표의 용도 대상 거름 (거름은 `m01.filter.*`) */
@@ -88,6 +89,8 @@ export interface SideHandle {
   logicHost: HTMLElement;
   /** 일위대가 조합 컨테이너 안(구분 · 상세구분 거름이 들어갈 자리) */
   comboHost: HTMLElement;
+  /** 자재 조합 컨테이너 안(찾기 칸이 들어갈 자리) */
+  matsetHost: HTMLElement;
   /** 그룹의 파일 판본을 다시 받음(저장 뒤) — 돌려받는 것 = 새 목록 */
   refresh: (group: string) => Promise<FileInfo[]>;
   /** 그룹의 파일 목록(이미 받은 것) */
@@ -146,11 +149,13 @@ const LEAF: Group[] = ["환율", "요율"];
 const FILTERED: Group[] = ["인력", "기계", "소요량", "계수"];
 const LOGIC_ID = "로직|";
 const COMBO_ID = "조합|";
+const MATSET_ID = "자재조합|";
 
 export function buildSide(
   onOpen: (pick: Pick) => void,
   onLogic: () => void,
   onCombo: () => void = () => {},
+  onMatset: () => void = () => {},
 ): SideHandle {
   const lists = new Map<Group, FileInfo[]>();
   const bodies = new Map<Group, HTMLElement>();
@@ -460,9 +465,17 @@ ${first.file}`
     onCombo();
   });
 
+  const matsetHost = el("div", { className: "m01-side__items ui-sidebar-list" });
+  const matset = section(tm("Title"), matsetHost);
+  matset.querySelector(".ui-collapsible__title")?.addEventListener("click", () => {
+    if (!matset.classList.contains("is-collapsed")) return;
+    setActive(buttons.has(MATSET_ID) ? MATSET_ID : null);
+    onMatset();
+  });
+
   const root = el("div", {
     className: "m01-side ui-sidebar-panel",
-    children: [...groups, logic, combo],
+    children: [...groups, logic, combo, matset],
   });
   attachCollapsible(root);
   void Promise.all(GROUPS.map(refresh)).catch((error) =>
@@ -472,5 +485,5 @@ ${first.file}`
     onPicked = fn;
   };
   const files = (group: string): FileInfo[] => lists.get(group as Group) ?? [];
-  return { root, logicHost, comboHost, refresh, files, setActive, setOnPicked, filter };
+  return { root, logicHost, comboHost, matsetHost, refresh, files, setActive, setOnPicked, filter };
 }
diff --git a/M01_MasterData/M01_MasterData_UI_Style.css b/M01_MasterData/M01_MasterData_UI_Style.css
index 6d2983e3..2b909b1b 100644
--- a/M01_MasterData/M01_MasterData_UI_Style.css
+++ b/M01_MasterData/M01_MasterData_UI_Style.css
@@ -162,12 +162,6 @@
   padding: 2px var(--spacing-4);
 }
 
-/* 표 칸 안 공용 단추 — 줄 높이에 맞춰 작게 */
-.m01-master__grid .ui-btn {
-  padding: 2px var(--spacing-8);
-  font-size: var(--text-caption);
-}
-
 .m01-master__pager {
   display: flex;
   align-items: center;
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
index 12c31e68..d35080df 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
@@ -138,6 +138,8 @@ export interface StructureCombo extends StructureNumbers {
   분류3: string | null;
   단위: string | null;
   일위대가: string | null;
+  /** 자재 조합 키 `UM` */
+  자재조합: string | null;
   바인딩: unknown;
   펼침: unknown;
 }
@@ -153,6 +155,59 @@ export interface StructureCombos {
 /** 조합 표 — 서버가 집계표 [저장] 때 맞춤(읽기만) */
 export const fetchStructureCombos = (): Promise<StructureCombos> => call("/structure-combos");
 
+/** 조합 갈라 내기 결과 — `새로만듦` false = 같은 담은 로직의 조합이 이미 있어 그 키를 가리킴 */
+export interface BranchedCombo {
+  키: string;
+  이름: string;
+  새로만듦: boolean;
+  집계표판: string;
+}
+
+/** 이 열이 가리키는 일위대가 조합을 고친 담은 로직으로 갈라 냄 — 새 UA · 집계표 그 열만 새 키 ·
+ * `판`(집계표 판)을 주면 어긋날 때 StaleError · 원래 조합은 그대로 */
+export const branchCombo = (
+  column: string,
+  body: {
+    본뜬키: string;
+    담은로직: { 로직: string; 메모?: string | null }[];
+    이름: string;
+    판?: string;
+  },
+): Promise<BranchedCombo> =>
+  call(`/structures/${enc(column)}/combo`, { method: "POST", body: JSON.stringify(body) });
+
+/** 자재 조합(키 `UM`) 담은 자재 한 줄 */
+export interface MaterialItem {
+  코드: string;
+  이름: string | null;
+  규격: string | null;
+  단위: string | null;
+}
+
+/** 자재 조합 한 줄 — 본뜬키 = 갈라 낸 원래 키(없으면 null) */
+export interface MaterialCombo {
+  키: string;
+  이름: string;
+  담은자재: MaterialItem[];
+  본뜬키: string | null;
+  소유: string;
+  비고: string | null;
+}
+
+export const fetchMaterialCombo = (key: string): Promise<MaterialCombo> =>
+  call(`/material-combos/${enc(key)}`);
+
+/** 이 열의 자재 조합을 고친 담은 자재로 갈라 냄 — 규칙은 `branchCombo` 와 같음 ·
+ * `본뜬키` 빈 글 = 이 열의 첫 자재 조합 */
+export const branchMaterialCombo = (
+  column: string,
+  body: { 본뜬키?: string; 담은자재: MaterialItem[]; 이름: string; 판?: string },
+): Promise<BranchedCombo> =>
+  call(`/structures/${enc(column)}/material-combo`, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
 /** 다른 열(`from`) 구조물 도면 내용을 받는 열(`column`)로 가져옴 — 도번 · 열은 받는 쪽 그대로 */
 export const copyStructure = async (column: string, from: string): Promise<void> => {
   await call(`/structures/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" });
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Branch.py b/M02_MasterTemplete/M02_MasterTemplete_Branch.py
new file mode 100644
index 00000000..d708e92d
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Branch.py
@@ -0,0 +1,151 @@
+"""조합 갈라 내기 — 구조물 열 하나가 가리키는 조합을 고친 내용으로 새로 만들어 그 열만 새 키를
+가리키게 함(PLAN 15장 · 검토 `14_조합편집검토.md` 1장).
+  · 일위대가 조합(UA · `일위대가조합.json`) — 새 줄은 M01 조합 저장소가 만듦(부르기만)
+  · 자재 조합(UM · `자재조합.json`) — M01 마스터 저장(`save`)으로 더함(키 = 대장 다음 번호)
+
+조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것의 집합(차례 · 메모 무시)이
+이미 있는 조합과 같으면 새로 안 만들고 그 키 · 새 줄의 본뜬키 = 원래 키 · 소유 현장.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from M01_MasterData import M01_MasterData_Store as m01
+from M01_MasterData import M01_MasterData_Store_Combo as combo_store
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+
+_OWNER = "현장"
+MATERIAL_FILE = "자재조합.json"
+
+
+def _m01(fn, *args):
+    """M01 막힘은 M02 막힘으로 — 상태 · 까닭 그대로."""
+    try:
+        return fn(*args)
+    except m01.StoreError as e:
+        raise store.StoreError(e.status, e.detail) from e
+
+
+def _free_name(name: str, rows: list[dict]) -> str:
+    taken = {str(r.get("이름") or "") for r in rows}
+    n, out = 2, name
+    while out in taken:
+        out, n = f"{name} ({n})", n + 1
+    return out
+
+
+def _branch(
+    column: str,
+    version: str,
+    field: str,
+    file: str,
+    slot: str,
+    ident: str,
+    items: list[dict],
+    source: str,
+    make: Callable[[str, list[dict]], dict],
+    name: str,
+) -> dict[str, Any]:
+    """집계표 판 검사 → 같은 내용 찾기 · 없으면 `make(이름, 줄들)` 로 새 줄 → 집계표 그 열 `field`.
+    `slot` = 담은 칸(담은로직 · 담은자재) · `ident` = 담은 줄의 알맹이 칸(로직 · 코드)."""
+    table = store.read("table", store.STRUCTURE_TABLE)
+    if version and table["판"] != version:
+        raise store.StoreError(409, {"stale": [store.STRUCTURE_TABLE], "판": table["판"]})
+    col = next((c for c in store._structure_columns() if c["id"] == column), None)
+    if col is None:
+        raise store.StoreError(404, f"{store.STRUCTURE_TABLE}에 없는 구조물 열 「{column}」")
+    if not isinstance(items, list) or not items:
+        raise store.StoreError(400, "담은 것이 비었음")
+
+    def body(got) -> frozenset[str]:
+        return frozenset(str(x.get(ident) or "") for x in got or [] if isinstance(x, dict))
+
+    rows = _m01(m01.read, file)[0].get("줄") or []
+    same = [r for r in rows if body(r.get(slot)) == body(items)]
+    hit = next((r for r in same if source and r.get("키") == source), same[0] if same else None)
+    if hit:
+        key, made_name, made = str(hit["키"]), str(hit.get("이름") or ""), False
+    else:
+        made_name = _free_name(name, rows)
+        key, made = make(made_name, rows), True
+    # ponytail: 조합 쓰기와 집계표 쓰기는 한 묶음 아님 — 사이에 집계표가 바뀌면 409 뒤 주인 없는
+    # 조합 하나가 남음(다시 하면 같은 내용이라 그 키를 씀)
+    doc = table["문서"]
+    for c in doc.get("열", []):
+        if isinstance(c, dict) and c.get("id") == column:
+            c[field] = key
+    info = store.write("table", store.STRUCTURE_TABLE, table["판"], doc)  # SS 도 여기서 맞춤
+    return {"키": key, "이름": made_name, "새로만듦": made, "집계표판": info["판"]}
+
+
+def branch_combo(
+    column: str, source: str, items: list[dict], name: str, version: str = ""
+) -> dict[str, Any]:
+    """일위대가 조합 갈라 내기 — 구분 · 상세구분 · 단위 · 출처 = 본뜬 것."""
+    was = _m01(combo_store.combo, source)["combo"]
+    items = [
+        {"로직": str(x.get("로직") or ""), "메모": x.get("메모")}
+        for x in items or []
+        if isinstance(x, dict)
+    ]
+
+    def make(made_name: str, _rows) -> str:
+        row = {
+            "이름": made_name,
+            **{k: was.get(k) for k in ("구분", "상세구분", "단위")},
+            "담은로직": items,
+            "본뜬키": source,
+            "출처": was.get("출처"),
+        }
+        return str(_m01(combo_store.combo_new, row, _OWNER)["key"])
+
+    name = name.strip() or str(was.get("이름") or source)
+    return _branch(
+        column, version, "일위대가", combo_store.FILE, "담은로직", "로직", items, source, make, name
+    )
+
+
+def _material_rows() -> list[dict]:
+    return _m01(m01.read, MATERIAL_FILE)[0].get("줄") or []
+
+
+def material_combo(key: str) -> dict[str, Any]:
+    row = next((r for r in _material_rows() if r.get("키") == key), None)
+    if row is None:
+        raise store.StoreError(404, f"없는 자재 조합 「{key}」")
+    return row
+
+
+def branch_material_combo(
+    column: str, source: str, items: list[dict], name: str, version: str = ""
+) -> dict[str, Any]:
+    """자재 조합 갈라 내기 — `source` 가 빈 글이면 이 열의 첫 자재 조합(본뜬키 null)."""
+    was = material_combo(source) if source else {}
+    items = [
+        {k: x.get(k) for k in ("코드", "이름", "규격", "단위")}
+        for x in items or []
+        if isinstance(x, dict)
+    ]
+
+    def make(made_name: str, rows: list[dict]) -> str:
+        row = {"이름": made_name, "담은자재": items, "본뜬키": source or None, "소유": _OWNER}
+        before = {r.get("키") for r in rows}
+        _m01(
+            m01.save,
+            [
+                {
+                    "file": MATERIAL_FILE,
+                    "version": _m01(m01.read, MATERIAL_FILE)[1],
+                    "changes": [{"op": "add", "row": {**row, "비고": None}}],
+                }
+            ],
+        )
+        return str(next(r["키"] for r in _material_rows() if r.get("키") not in before))
+
+    heads = next((c for c in store._structure_columns() if c["id"] == column), {})
+    default = " ".join(h for h in store._heads(heads) if h) if heads else column
+    name = name.strip() or str(was.get("이름") or default or column)
+    return _branch(
+        column, version, "자재조합", MATERIAL_FILE, "담은자재", "코드", items, source, make, name
+    )
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Combo.css b/M02_MasterTemplete/M02_MasterTemplete_Combo.css
new file mode 100644
index 00000000..096e38a6
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Combo.css
@@ -0,0 +1,144 @@
+/* M02 조합 줄(면적산출) · 조합 고치기 창 · 자재 목록 옆 판(재료산출) */
+
+/* 알약 막대 위 한 줄 */
+.m02-combo {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-4) var(--spacing-12);
+  font-size: var(--text-body-sm);
+}
+
+.m02-combo__key {
+  padding: 0 var(--spacing-8);
+  border-radius: var(--radius-md);
+  background: color-mix(in srgb, var(--color-accent) 14%, transparent);
+  color: var(--color-text);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+.m02-combo__name {
+  color: var(--color-text);
+  overflow-wrap: anywhere;
+}
+
+.m02-combo__meta,
+.m02-combo__origin {
+  color: var(--color-text-secondary);
+  white-space: nowrap;
+}
+
+.m02-combo__origin {
+  font-size: var(--text-caption);
+}
+
+.m02-combo > .ui-btn {
+  margin-left: auto;
+}
+
+/* 조합 고치기 창 — 담은 로직 표(M01 조합 화면과 같은 줄) */
+.ui-modal.m02-combo-edit {
+  width: min(980px, 94vw);
+}
+
+.m02-combo-edit__row {
+  display: grid;
+  grid-template-columns: 3rem 7rem minmax(10rem, 1.4fr) 6rem minmax(8rem, 1fr) auto;
+  align-items: center;
+  gap: var(--spacing-8);
+  padding: var(--spacing-4) 0;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.m02-combo-edit__row--head {
+  color: var(--color-text-secondary);
+  font-size: var(--text-caption);
+  font-weight: 600;
+}
+
+.m02-combo-edit__acts {
+  display: flex;
+  gap: var(--spacing-4);
+}
+
+.m02-combo-edit__foot,
+.m02-branch__foot {
+  display: flex;
+  gap: var(--spacing-8);
+  justify-content: flex-end;
+}
+
+.m02-branch__msg {
+  margin: 0;
+  line-height: 1.5;
+}
+
+/* 재료산출 — 엑셀 옆 접히는 판 */
+.m02-main__host:has(> .ss) > .m02-mat {
+  flex: none;
+}
+
+.m02-mat {
+  order: 2;
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+  width: min(30rem, 42%);
+  min-height: 0;
+  padding: var(--spacing-8);
+  border-left: 1px solid var(--color-border);
+  overflow: auto;
+}
+
+.m02-mat.is-collapsed {
+  width: auto;
+}
+
+.m02-mat.is-collapsed .m02-mat__body {
+  display: none;
+}
+
+.m02-mat > .ui-btn {
+  align-self: flex-start;
+}
+
+.m02-mat__body {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+  font-size: var(--text-body-sm);
+}
+
+.m02-mat__title {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-4) var(--spacing-12);
+  color: var(--color-text);
+}
+
+.m02-mat__row {
+  display: grid;
+  grid-template-columns: 5.5rem minmax(6rem, 1.4fr) minmax(4rem, 1fr) 3rem 4rem auto;
+  align-items: center;
+  gap: var(--spacing-4);
+  padding: var(--spacing-4) 0;
+  border-bottom: 1px solid var(--color-border);
+  overflow-wrap: anywhere;
+}
+
+.m02-mat__row--head {
+  color: var(--color-text-secondary);
+  font-size: var(--text-caption);
+  font-weight: 600;
+}
+
+.m02-mat__foot {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-8);
+}
+
+.m02-main__combo:empty {
+  display: none;
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Combo.ts b/M02_MasterTemplete/M02_MasterTemplete_Combo.ts
new file mode 100644
index 00000000..873ebeb9
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Combo.ts
@@ -0,0 +1,263 @@
+/* =============================================================================
+ * M02_MasterTemplete_Combo.ts
+ * 면적산출 편집 화면 — 알약 막대 위 조합 줄 + [조합 고치기](시스템 관리자만).
+ * 일위대가 조합(UA)은 여러 열 · 모든 프로젝트가 같이 씀 → 제자리 고치지 않고 고친 내용으로 새 조합을 만들어
+ * 이 열만 가리킴(서버 `branchCombo`) · 원래 조합은 그대로. 담은 로직 표는 M01 조합 화면과 같은 줄 모양.
+ * 갈라 내기 모달(`askBranch`)은 재료산출 자재 목록(`M02_MasterTemplete_Materials.ts`)도 씀.
+ * ========================================================================== */
+
+import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
+import { openModal } from "@ui/ui_template_modal";
+import { fetchCombo, type ComboLine } from "../M01_MasterData/M01_MasterData_UI_Combo_Api";
+import { openLogicPicker } from "../M01_MasterData/M01_MasterData_UI_Combo_Pick";
+import { branchCombo, type BranchedCombo } from "./M02_MasterTemplete_Api_Fetch";
+import { readColumnBase, reasonOf } from "./M02_MasterTemplete_Combo_Api";
+import "./M02_MasterTemplete_Combo.css";
+
+const TEXT = {
+  combo: "일위대가",
+  logics: "담은 로직 {n}",
+  shared: "다른 열 {n} 이 같이 씀",
+  alone: "이 열만 씀",
+  branched: "본뜬 조합 {value}",
+  edit: "조합 고치기",
+  editTitle: "일위대가 조합 고치기 — {value}",
+  no: "차례",
+  key: "키",
+  name: "이름",
+  unit: "결과 단위",
+  memo: "메모",
+  up: "위",
+  down: "아래",
+  remove: "빼기",
+  add: "로직 더하기",
+  apply: "적용",
+  close: "닫기",
+  empty: "담은 로직이 없음",
+  unchanged: "고친 것이 없음",
+  loadFailed: "조합을 못 읽음 — {value}",
+  askTitle: "새 조합으로 갈라 냄",
+  askName: "새 조합 이름",
+  askOk: "새로 만듦",
+  askCancel: "취소",
+  askBody:
+    "이 조합은 열 {n} 개와 모든 프로젝트가 같이 씀 — 고친 내용으로 새 조합을 만들고 이 열만 새 조합을 가리킴 · 원래 조합은 그대로",
+  askAlone:
+    "이 조합은 모든 프로젝트가 같이 씀 — 고친 내용으로 새 조합을 만들고 이 열만 새 조합을 가리킴 · 원래 조합은 그대로",
+  made: "새 조합 {value} 을 만들고 이 열이 가리킴",
+  reused: "같은 내용의 조합 {value} 을 씀",
+  failed: "조합을 못 고침 — {value}",
+};
+
+const fill = (text: string, value: string | number): string =>
+  text.replace("{n}", String(value)).replace("{value}", String(value));
+
+/** 갈라 내기 확인 모달 — 이름 칸을 미리 채워 두고 고칠 수 있음 · 취소면 null */
+export function askBranch(message: string, defaultName: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (value: string | null): void => {
+      if (!done) resolve(value);
+      done = true;
+    };
+    openModal({
+      title: TEXT.askTitle,
+      closeLabel: TEXT.askCancel,
+      dialogClass: "m02-modal m02-branch",
+      mount: (body, close) => {
+        const name = createInputField({ label: TEXT.askName, type: "text" });
+        name.input.value = defaultName;
+        const ok = createButton({
+          label: TEXT.askOk,
+          variant: "filled",
+          onClick: () => {
+            const value = name.input.value.trim();
+            if (!value) return name.input.focus();
+            finish(value);
+            close();
+          },
+        });
+        body.append(
+          el("p", { className: "m02-branch__msg", text: message }),
+          name.root,
+          el("div", { className: "m02-branch__foot", children: [ok] }),
+        );
+        name.input.focus();
+      },
+    });
+    // 닫기 단추 · Esc · 바깥 누르기 — 창이 빠지면 취소
+    const watch = new MutationObserver(() => {
+      if (document.querySelector(".m02-branch")) return;
+      watch.disconnect();
+      finish(null);
+    });
+    watch.observe(document.body, { childList: true });
+  });
+}
+
+/** 결과 알림 — 새로 만듦 / 같은 조합 씀 */
+export const branchToast = (r: BranchedCombo): void =>
+  showToast(fill(r.새로만듦 ? TEXT.made : TEXT.reused, `${r.키} ${r.이름}`), "success");
+
+export interface ComboBarOptions {
+  /** 집계표 열 id */
+  column: string;
+  /** 화면 제목에 쓰는 구조물 이름(집계표 머리 층을 이은 글) — 새 이름 자동 미리 채움에 씀 */
+  label: string;
+  isAdmin: boolean;
+  /** 고치기 전 — 저장 안 한 시트 고침이 있으면 물음 · false 면 그만둠 */
+  beforeEdit: () => Promise<boolean>;
+  /** 갈라 낸 뒤 — 알약 다시 받기 */
+  onApplied: () => Promise<void> | void;
+}
+
+interface Line {
+  로직: string;
+  메모: string | null;
+  이름: string;
+  결과단위: string;
+}
+
+/** 조합 줄 — 이 열에 일위대가가 없으면 null */
+export async function buildComboBar(opts: ComboBarOptions): Promise<HTMLElement | null> {
+  const base = await readColumnBase(opts.column);
+  if (!base.일위대가) return null;
+  const key = base.일위대가;
+  let one;
+  try {
+    one = await fetchCombo(key);
+  } catch (error) {
+    showToast(fill(TEXT.loadFailed, reasonOf(error)), "error");
+    return null;
+  }
+  const combo = one.combo as typeof one.combo & { 본뜬키?: string | null };
+  const same = base.다른열일위대가;
+  const parts = [
+    el("span", { className: "m02-combo__key", text: `${TEXT.combo} ${key}` }),
+    el("span", { className: "m02-combo__name", text: combo.이름 }),
+    el("span", { className: "m02-combo__meta", text: fill(TEXT.logics, combo.담은로직.length) }),
+    el("span", {
+      className: "m02-combo__meta",
+      text: same ? fill(TEXT.shared, same) : TEXT.alone,
+    }),
+  ];
+  if (opts.isAdmin && combo.본뜬키) {
+    parts.push(
+      el("span", { className: "m02-combo__origin", text: fill(TEXT.branched, combo.본뜬키) }),
+    );
+  }
+  const bar = el("div", { className: "m02-combo", children: parts });
+  if (!opts.isAdmin) return bar;
+
+  const edit = createButton({ label: TEXT.edit, variant: "ghost", size: "sm" });
+  edit.addEventListener("click", async () => {
+    if (!(await opts.beforeEdit())) return;
+    openEditor(one.줄, combo.이름, same);
+  });
+  bar.append(edit);
+  return bar;
+
+  function openEditor(from: ComboLine[], comboName: string, others: number): void {
+    const original = JSON.stringify(from.map((l) => [l.로직, l.메모 ?? null]));
+    const lines: Line[] = from.map((l) => ({
+      로직: l.로직,
+      메모: l.메모,
+      이름: l.이름 ?? "",
+      결과단위: l.결과단위 ?? "",
+    }));
+    openModal({
+      title: fill(TEXT.editTitle, opts.label),
+      closeLabel: TEXT.close,
+      dialogClass: "m02-modal m02-combo-edit",
+      mount: (body, close) => {
+        const table = el("div", { className: "m02-combo-edit__table" });
+        const paint = (): void => {
+          const head = el("div", {
+            className: "m02-combo-edit__row m02-combo-edit__row--head",
+            children: [TEXT.no, TEXT.key, TEXT.name, TEXT.unit, TEXT.memo, ""].map((t) =>
+              el("span", { text: t }),
+            ),
+          });
+          const rows = lines.map((line, i) => {
+            const memo = el("input", {
+              className: "ui-input",
+              attrs: { type: "text", value: line.메모 ?? "" },
+            });
+            memo.addEventListener("input", () => (line.메모 = memo.value || null));
+            const move = (to: number): void => {
+              if (to < 0 || to >= lines.length) return;
+              [lines[i], lines[to]] = [lines[to], lines[i]];
+              paint();
+            };
+            const up = createButton({ label: "▲", variant: "ghost", size: "sm" });
+            up.title = TEXT.up;
+            up.disabled = i === 0;
+            up.addEventListener("click", () => move(i - 1));
+            const down = createButton({ label: "▼", variant: "ghost", size: "sm" });
+            down.title = TEXT.down;
+            down.disabled = i === lines.length - 1;
+            down.addEventListener("click", () => move(i + 1));
+            const del = createButton({ label: TEXT.remove, variant: "ghost", size: "sm" });
+            del.addEventListener("click", () => {
+              lines.splice(i, 1);
+              paint();
+            });
+            return el("div", {
+              className: "m02-combo-edit__row",
+              attrs: { "data-combo-line": line.로직 },
+              children: [
+                el("span", { text: String(i + 1) }),
+                el("span", { text: line.로직 }),
+                el("span", { text: line.이름 }),
+                el("span", { text: line.결과단위 }),
+                memo,
+                el("span", { className: "m02-combo-edit__acts", children: [up, down, del] }),
+              ],
+            });
+          });
+          table.replaceChildren(
+            head,
+            ...(rows.length
+              ? rows
+              : [el("p", { className: "m02-struct__empty", text: TEXT.empty })]),
+          );
+        };
+        paint();
+        const add = createButton({ label: TEXT.add, variant: "ghost", size: "sm" });
+        add.addEventListener("click", () =>
+          openLogicPicker((logic) => {
+            lines.push({ 로직: logic.키, 메모: null, 이름: logic.이름, 결과단위: logic.결과단위 });
+            paint();
+          }),
+        );
+        const apply = createButton({ label: TEXT.apply, variant: "filled" });
+        apply.addEventListener("click", async () => {
+          if (JSON.stringify(lines.map((l) => [l.로직, l.메모 ?? null])) === original) {
+            return showToast(TEXT.unchanged, "info");
+          }
+          const message = others ? fill(TEXT.askBody, others + 1) : TEXT.askAlone;
+          const name = await askBranch(message, `${comboName} · ${opts.label}`);
+          if (name === null) return;
+          apply.disabled = true;
+          try {
+            const result = await branchCombo(opts.column, {
+              본뜬키: key,
+              담은로직: lines.map((l) => ({ 로직: l.로직, 메모: l.메모 })),
+              이름: name,
+            });
+            branchToast(result);
+            close();
+            await opts.onApplied();
+          } catch (error) {
+            apply.disabled = false;
+            showToast(fill(TEXT.failed, reasonOf(error)), "error");
+          }
+        });
+        body.append(
+          table,
+          el("div", { className: "m02-combo-edit__foot", children: [add, apply] }),
+        );
+      },
+    });
+  }
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Combo_Api.ts b/M02_MasterTemplete/M02_MasterTemplete_Combo_Api.ts
new file mode 100644
index 00000000..1eb5e2b8
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Combo_Api.ts
@@ -0,0 +1,37 @@
+/* =============================================================================
+ * M02_MasterTemplete_Combo_Api.ts
+ * 조합 고치기 · 자재 목록 화면이 함께 쓰는 읽기 — 집계표 열이 가리키는 조합 키 · 같이 쓰는 다른 열 수 ·
+ * 서버 까닭 글. 갈라 내기 길(`branchCombo` · `branchMaterialCombo` · `fetchMaterialCombo`)은 `M02_MasterTemplete_Api_Fetch.ts`.
+ * ========================================================================== */
+
+import { readTemplate } from "./M02_MasterTemplete_Api_Fetch";
+
+/** 구조물집계표 이름 — `M02_MasterTemplete_Structure.STRUCTURE_TABLE` 과 같은 글 */
+const STRUCTURE_TABLE = "구조물집계표";
+
+/** 집계표 열이 가리키는 조합 키 + 같은 조합을 쓰는 다른 열 수 */
+export interface ColumnBase {
+  일위대가: string | null;
+  자재조합: string | null;
+  다른열일위대가: number;
+  다른열자재조합: number;
+}
+
+/** 서버가 준 까닭 글 */
+export const reasonOf = (error: unknown): string => (error instanceof Error ? error.message : "");
+
+/** 집계표(시스템 층)에서 이 열의 일위대가 · 자재조합 키와 같이 쓰는 다른 열 수 */
+export async function readColumnBase(column: string): Promise<ColumnBase> {
+  type Col = { id: string; 일위대가?: string | null; 자재조합?: string | null };
+  const table = await readTemplate("system", "table", STRUCTURE_TABLE, null).catch(() => null);
+  const cols = ((table?.문서 as { 열?: Col[] } | null)?.열 ?? []) as Col[];
+  const mine = cols.find((c) => c.id === column);
+  const same = (key: string | null | undefined, pick: (c: Col) => string | null | undefined) =>
+    key ? cols.filter((c) => c.id !== column && pick(c) === key).length : 0;
+  return {
+    일위대가: mine?.일위대가 || null,
+    자재조합: mine?.자재조합 || null,
+    다른열일위대가: same(mine?.일위대가, (c) => c.일위대가),
+    다른열자재조합: same(mine?.자재조합, (c) => c.자재조합),
+  };
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Materials.ts b/M02_MasterTemplete/M02_MasterTemplete_Materials.ts
new file mode 100644
index 00000000..5499479b
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Materials.ts
@@ -0,0 +1,322 @@
+/* =============================================================================
+ * M02_MasterTemplete_Materials.ts
+ * 재료산출 편집 화면 — 엑셀 옆 접히는 판: 그 열의 자재 조합(UM) 담은 자재 표 + [자재 더하기] · [빼기] · [적용].
+ * 자재 조합도 여러 열이 같이 쓸 수 있어 [적용] 때 일위대가처럼 모달 후 새 조합으로 갈라 냄
+ * (서버 `branchMaterialCombo`) · 원래 조합은 그대로. 빼는 자재가 칸에 이어져 있으면 확인 후 연결도 풂.
+ * ========================================================================== */
+
+import {
+  createButton,
+  createInputField,
+  el,
+  showConfirmDialog,
+  showToast,
+} from "@ui/ui_template_elements";
+import { openModal } from "@ui/ui_template_modal";
+import { searchMaterials } from "../M01_MasterData/M01_MasterData_Api_Fetch";
+import type { LinkItem } from "../A00_Common/spreadsheet/spreadsheet_links";
+import type { CellLink } from "../A00_Common/spreadsheet/spreadsheet_types";
+import {
+  branchMaterialCombo,
+  fetchMaterialCombo,
+  type MaterialCombo,
+  type MaterialItem,
+} from "./M02_MasterTemplete_Api_Fetch";
+import { askBranch, branchToast } from "./M02_MasterTemplete_Combo";
+import { readColumnBase, reasonOf } from "./M02_MasterTemplete_Combo_Api";
+
+const TEXT = {
+  toggle: "자재 목록",
+  combo: "자재 조합",
+  branched: "본뜬 조합 {value}",
+  none: "자재 조합 없음 — 자재를 더하면 새로 만듦",
+  code: "코드",
+  name: "이름",
+  spec: "규격",
+  unit: "단위",
+  cell: "이은 칸",
+  remove: "빼기",
+  add: "자재 더하기",
+  apply: "적용",
+  undo: "되돌리기",
+  empty: "담은 자재가 없음",
+  unlinkAsk: "{value} 자재는 {cell} 칸에 이어져 있음 — 빼면 연결도 풂",
+  unlinkOk: "빼고 연결 풂",
+  loadFailed: "자재 조합을 못 읽음 — {value}",
+  askBody:
+    "이 자재 조합은 열 {n} 개와 모든 프로젝트가 같이 씀 — 고친 내용으로 새 자재 조합을 만들고 이 열만 새 조합을 가리킴 · 같은 내용이면 있는 조합을 씀 · 원래 조합은 그대로",
+  askAlone:
+    "이 자재 조합은 모든 프로젝트가 같이 씀 — 고친 내용으로 새 자재 조합을 만들고 이 열만 새 조합을 가리킴 · 같은 내용이면 있는 조합을 씀",
+  failed: "자재 조합을 못 고침 — {value}",
+  pickTitle: "자재 더하기",
+  pickClose: "닫기",
+  search: "자재 이름 · 규격 · 코드",
+  searching: "찾는 중…",
+  noMatch: "맞는 자재 없음",
+  searchFailed: "자재 목록을 못 받음",
+};
+
+const fill = (text: string, values: Record<string, string | number>): string =>
+  Object.entries(values).reduce((s, [k, v]) => s.replace(`{${k}}`, String(v)), text);
+
+/** 이 열의 자재 조합 — 키(없으면 빈 글) · 같이 쓰는 다른 열 수 · 담은 자재 */
+export interface MaterialState {
+  key: string;
+  others: number;
+  combo: MaterialCombo | null;
+}
+
+export async function loadMaterialState(column: string): Promise<MaterialState> {
+  const base = await readColumnBase(column);
+  const key = base.자재조합 ?? "";
+  let combo: MaterialCombo | null = null;
+  if (key) {
+    try {
+      combo = await fetchMaterialCombo(key);
+    } catch (error) {
+      showToast(fill(TEXT.loadFailed, { value: reasonOf(error) }), "error");
+    }
+  }
+  return { key, others: base.다른열자재조합, combo };
+}
+
+/** 알약 막대 자재 항목 ↔ 담은 자재 — 알약 키 = 자재 코드 */
+export const toPills = (items: MaterialItem[]): LinkItem[] =>
+  items.map((m) => {
+    const 자재 = {
+      코드: m.코드,
+      이름: m.이름 ?? "",
+      규격: m.규격 ?? "",
+      단위: m.단위 ?? "",
+    };
+    return { 키: m.코드, 이름: 자재.이름, 단위: 자재.단위, 자재 };
+  });
+
+export interface MaterialPanel {
+  root: HTMLElement;
+  /** 알약 막대에서 목록이 바뀜 — 표만 다시 그림(알약은 이미 맞음) */
+  setItems: (items: MaterialItem[]) => void;
+}
+
+export interface MaterialPanelOptions {
+  /** 집계표 열 id */
+  column: string;
+  state: MaterialState;
+  /** 표에서 더하기 · 빼기 · 되돌리기 — 알약 막대를 이 목록으로 맞춤 */
+  onChange: (items: MaterialItem[]) => void;
+  /** 이은 칸이 있는 줄을 누름 — 알약을 눌러 그 칸으로 감(깜빡임) */
+  goTo: (code: string) => void;
+  /** 구조물 이름 — 새 이름 자동 미리 채움 */
+  label: string;
+  isAdmin: boolean;
+  /** 지금 시트 문서의 연결 전부 */
+  links: () => CellLink[];
+  /** 자재 코드에 이어진 칸 연결을 풂(시트 문서를 고치고 고침 표시) */
+  unlink: (codes: string[]) => void;
+}
+
+/** 자재 고르기 창 — 이름 · 규격 · 코드 낱말로 찾아 하나 고름 */
+function pickMaterial(done: (item: MaterialItem) => void): void {
+  openModal({
+    title: TEXT.pickTitle,
+    closeLabel: TEXT.pickClose,
+    dialogClass: "m02-modal m02-pick",
+    mount: (body, close) => {
+      const search = createInputField({ placeholder: TEXT.search, type: "search" });
+      const list = el("div", { className: "m02-pick__list" });
+      let seq = 0;
+      const paint = async (): Promise<void> => {
+        const mine = ++seq;
+        list.replaceChildren(el("p", { className: "m02-struct__empty", text: TEXT.searching }));
+        try {
+          const hits = await searchMaterials(search.input.value.trim());
+          if (mine !== seq) return;
+          list.replaceChildren(
+            ...(hits.length
+              ? hits.map((m) => {
+                  const row = el("button", {
+                    className: "m02-pick__item",
+                    attrs: { type: "button", "data-material": m.코드 },
+                    children: [
+                      el("span", { className: "m02-pick__key", text: m.코드 }),
+                      `${m.이름} ${m.규격} ${m.단위}`.replace(/\s+/g, " "),
+                    ],
+                  });
+                  row.addEventListener("click", () => {
+                    done(m);
+                    close();
+                  });
+                  return row;
+                })
+              : [el("p", { className: "m02-struct__empty", text: TEXT.noMatch })]),
+          );
+        } catch {
+          if (mine === seq) showToast(TEXT.searchFailed, "error");
+        }
+      };
+      let timer = 0;
+      search.input.addEventListener("input", () => {
+        window.clearTimeout(timer);
+        timer = window.setTimeout(() => void paint(), 250);
+      });
+      body.append(search.root, list);
+      void paint();
+      search.input.focus();
+    },
+  });
+}
+
+/** 옆 판 — 이 열에 자재 조합이 없어도 판은 뜸(더하면 새로 만듦) */
+export function buildMaterialPanel(opts: MaterialPanelOptions): MaterialPanel {
+  let key = opts.state.key;
+  let others = opts.state.others;
+  let combo = opts.state.combo;
+  let saved: MaterialItem[] = combo?.담은자재 ?? [];
+  let items: MaterialItem[] = [...saved];
+  const sig = (list: MaterialItem[]): string => JSON.stringify(list.map((m) => m.코드));
+
+  const toggle = createButton({ label: "", variant: "ghost", size: "sm" });
+  const title = el("div", { className: "m02-mat__title" });
+  const table = el("div", { className: "m02-mat__table" });
+  const foot = el("div", { className: "m02-mat__foot" });
+  const body = el("div", { className: "m02-mat__body", children: [title, table, foot] });
+  const root = el("aside", { className: "m02-mat", children: [toggle, body] });
+  toggle.addEventListener("click", () => {
+    root.classList.toggle("is-collapsed");
+    paintToggle();
+  });
+  const paintToggle = (): void => {
+    const open = !root.classList.contains("is-collapsed");
+    toggle.querySelector(".ui-btn__label")!.textContent =
+      `${open ? "▸" : "◂"} ${TEXT.toggle} ${items.length}`;
+  };
+
+  const cellsOf = (code: string): string[] =>
+    opts
+      .links()
+      .filter((l) => (l.자재?.코드 ?? l.키) === code)
+      .map((l) => l.칸);
+
+  const paint = (): void => {
+    title.replaceChildren(
+      el("span", { text: key ? `${TEXT.combo} ${key} ${combo?.이름 ?? ""}`.trim() : TEXT.none }),
+      ...(opts.isAdmin && combo?.본뜬키
+        ? [
+            el("span", {
+              className: "m02-combo__origin",
+              text: fill(TEXT.branched, { value: combo.본뜬키 }),
+            }),
+          ]
+        : []),
+    );
+    const head = el("div", {
+      className: "m02-mat__row m02-mat__row--head",
+      children: [TEXT.code, TEXT.name, TEXT.spec, TEXT.unit, TEXT.cell, ""].map((t) =>
+        el("span", { text: t }),
+      ),
+    });
+    const rows = items.map((m, i) => {
+      const cells = cellsOf(m.코드);
+      const acts = el("span", { className: "m02-mat__acts" });
+      if (opts.isAdmin) {
+        const del = createButton({ label: TEXT.remove, variant: "ghost", size: "sm" });
+        del.addEventListener("click", async () => {
+          if (
+            cells.length &&
+            !(await showConfirmDialog(
+              fill(TEXT.unlinkAsk, { value: m.이름 ?? m.코드, cell: cells.join(", ") }),
+              TEXT.unlinkOk,
+            ))
+          )
+            return;
+          items.splice(i, 1);
+          removed.push(m.코드);
+          paint();
+          opts.onChange(items);
+        });
+        acts.append(del);
+      }
+      const row = el("div", {
+        className: `m02-mat__row${cells.length ? " is-linked" : ""}`,
+        attrs: { "data-material": m.코드 },
+        children: [m.코드, m.이름 ?? "", m.규격 ?? "", m.단위 ?? "", cells.join(", ")]
+          .map((t) => el("span", { text: t }))
+          .concat(acts),
+      });
+      if (cells.length) row.addEventListener("click", () => opts.goTo(m.코드));
+      return row;
+    });
+    table.replaceChildren(
+      head,
+      ...(rows.length ? rows : [el("p", { className: "m02-struct__empty", text: TEXT.empty })]),
+    );
+    paintFoot();
+    paintToggle();
+  };
+
+  /** 이번에 뺀 자재 코드 — 적용하면 이은 칸 연결도 풂 */
+  let removed: string[] = [];
+  const paintFoot = (): void => {
+    if (!opts.isAdmin) return foot.replaceChildren();
+    const add = createButton({ label: TEXT.add, variant: "ghost", size: "sm" });
+    add.addEventListener("click", () =>
+      pickMaterial((m) => {
+        if (items.some((x) => x.코드 === m.코드)) return;
+        items.push(m);
+        removed = removed.filter((c) => c !== m.코드);
+        paint();
+        opts.onChange(items);
+      }),
+    );
+    const buttons = [add];
+    if (sig(items) !== sig(saved)) {
+      const apply = createButton({ label: TEXT.apply, variant: "filled", size: "sm" });
+      apply.addEventListener("click", async () => {
+        const message = others ? fill(TEXT.askBody, { n: others + 1 }) : TEXT.askAlone;
+        const name = await askBranch(
+          message,
+          `${combo?.이름 ?? ""} · ${opts.label}`.replace(/^ · /, ""),
+        );
+        if (name === null) return;
+        apply.disabled = true;
+        try {
+          const result = await branchMaterialCombo(opts.column, {
+            본뜬키: key,
+            담은자재: items,
+            이름: name,
+          });
+          branchToast(result);
+          if (removed.length) opts.unlink(removed);
+          removed = [];
+          key = result.키;
+          others = 0;
+          combo = await fetchMaterialCombo(key).catch(() => null);
+          saved = combo?.담은자재 ?? [...items];
+          items = [...saved];
+          paint();
+        } catch (error) {
+          apply.disabled = false;
+          showToast(fill(TEXT.failed, { value: reasonOf(error) }), "error");
+        }
+      });
+      const undo = createButton({ label: TEXT.undo, variant: "ghost", size: "sm" });
+      undo.addEventListener("click", () => {
+        items = [...saved];
+        removed = [];
+        paint();
+        opts.onChange(items);
+      });
+      buttons.push(apply, undo);
+    }
+    foot.replaceChildren(...buttons);
+  };
+
+  paint();
+  return {
+    root,
+    setItems: (list) => {
+      items = [...list];
+      paint();
+    },
+  };
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Router.py b/M02_MasterTemplete/M02_MasterTemplete_Router.py
index 696292b6..cbef0be9 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Router.py
+++ b/M02_MasterTemplete/M02_MasterTemplete_Router.py
@@ -10,6 +10,7 @@ from typing import Any
 from fastapi import APIRouter, HTTPException, Query
 from pydantic import BaseModel
 
+from M02_MasterTemplete import M02_MasterTemplete_Branch as branch
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 
 router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete"])
@@ -20,6 +21,20 @@ class SaveBody(BaseModel):
     문서: Any
 
 
+class BranchBody(BaseModel):
+    본뜬키: str
+    담은로직: list[dict[str, Any]]
+    이름: str = ""
+    판: str = ""  # 집계표 판 — 주면 어긋날 때 409
+
+
+class MaterialBranchBody(BaseModel):
+    본뜬키: str = ""  # 빈 글 = 이 열의 첫 자재 조합
+    담은자재: list[dict[str, Any]]
+    이름: str = ""
+    판: str = ""
+
+
 def _call(fn, *args):
     try:
         return fn(*args)
@@ -49,6 +64,26 @@ def post_structure(column: str) -> dict:
     return _call(store.create_structure, column)
 
 
+@router.post("/structures/{column}/combo")
+def post_structure_combo(column: str, body: BranchBody) -> dict:
+    """조합 갈라 내기 — 고친 담은 로직으로 새 UA(같은 로직 집합이면 있는 키) · 이 열만 가리킴."""
+    return _call(branch.branch_combo, column, body.본뜬키, body.담은로직, body.이름, body.판)
+
+
+@router.post("/structures/{column}/material-combo")
+def post_structure_material_combo(column: str, body: MaterialBranchBody) -> dict:
+    """자재 조합 갈라 내기 — 같은 규칙(같은 자재 집합이면 있는 키 · 아니면 새 UM)."""
+    return _call(
+        branch.branch_material_combo, column, body.본뜬키, body.담은자재, body.이름, body.판
+    )
+
+
+@router.get("/material-combos/{key}")
+def get_material_combo(key: str) -> dict:
+    """자재 조합 한 줄(키 UM) — 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고."""
+    return _call(branch.material_combo, key)
+
+
 # 복사 가져오기 — 다른 열(`from`) 내용을 받는 열로 · 번호 · 열은 받는 쪽 그대로
 @router.post("/structures/{column}/copy")
 def post_structure_copy(column: str, source: str = Query(alias="from")) -> dict:
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Store.py
index 5aadc5ed..c846c529 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Store.py
+++ b/M02_MasterTemplete/M02_MasterTemplete_Store.py
@@ -109,9 +109,12 @@ def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]:
     만들고 지운 열(또는 구조물이 아니게 된 열)의 세 파일을 지움(잠금 밖에서 · 안에서 부르면 죽음).
     통합문서(area · material)는 서버가 같은 TS 엔진을 Node 로 돌려 `계산값` 을 새로 적음
     (브라우저 값 버림 · 5장 ②) · 알약 `연결` 은 문서와 같이 그대로 적힘.
-    번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음)."""
+    번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음).
+    표 열의 `본뜬열`(분류 더하기로 복사한 새 열)은 적지 않음 — 집계표면 아직 파일이 없는 새 열이
+    원본 열의 일위대가 · 자재조합 키와 세 파일 내용을 받음(새 번호 · 그 뒤로는 열마다 따로)."""
     path = _path(kind, name)
     _check_skeleton(kind, doc)
+    origins = _take_origins(doc) if kind == "table" else {}
     if kind in SHEETS:
         doc = _server_values(doc)
     with _LOCK:
@@ -124,6 +127,9 @@ def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]:
         atomic_write_json(path, doc)
         info = _info(kind, path)
     if kind == "table" and name == STRUCTURE_TABLE:
+        for column, source in origins.items():  # 빈 파일 채우기 앞 — 원본 내용으로 만듦
+            for part in _KEY:
+                _ensure(part, column, source)
         backfill_missing_structures()  # 지우기 앞 — 같은 저장의 새 열이 지운 번호를 안 받게
         prune_removed_structures()
         sync_combos()  # 번호가 다 선 뒤 — 조합 표 도번 · 면적번 · 재료번 칸
@@ -256,17 +262,46 @@ def _blank(kind: str, column: str) -> dict[str, Any]:
     }
 
 
-def _ensure(kind: str, column: str) -> bool:
-    """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로."""
+def _ensure(kind: str, column: str, source: str | None = None) -> bool:
+    """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로.
+    `source` 열 파일이 있으면 빈 문서 대신 그 내용(알약 `연결` 포함 · 계산값은 서버가 다시 풂)."""
     path = _path(kind, column)
+    if path.is_file():
+        return False
     head = next(h for k, _, h, _ in PARTS if k == kind)
+    base = _blank(kind, column)
+    if source and _path(kind, source).is_file():
+        got = json.loads(_path(kind, source).read_bytes())
+        base = {**{k: v for k, v in got.items() if k != "계산값"}, "열": column}
+        if kind in SHEETS:
+            base = _server_values(base)
     with _LOCK:
         if path.is_file():
             return False
-        atomic_write_json(path, {**_blank(kind, column), _KEY[kind]: head + _new_code(column)})
+        atomic_write_json(path, {**base, _KEY[kind]: head + _new_code(column)})
     return True
 
 
+def _take_origins(doc: Any) -> dict[str, str]:
+    """표 열의 `본뜬열` 을 떼어 냄 → `{새 열: 원본 열}` (구조물 파일이 아직 없는 열만) ·
+    그 열에 일위대가 · 자재조합 키가 비었으면 원본 열 것을 받음."""
+    cols = (
+        [c for c in (doc.get("열") or []) if isinstance(c, dict)] if isinstance(doc, dict) else []
+    )
+    by_id = {c.get("id"): c for c in cols}
+    out: dict[str, str] = {}
+    for col in cols:
+        source = col.pop("본뜬열", None)
+        if not source or source not in by_id or not col.get("id"):
+            continue
+        if (FOLDER / "structure" / f"{col['id']}.json").is_file():
+            continue
+        out[col["id"]] = source
+        for field in ("일위대가", "자재조합"):
+            col[field] = col.get(field) or by_id[source].get(field)
+    return out
+
+
 def create_structure(column: str) -> dict[str, Any]:
     """구조물 열 하나의 구조물 도면 새로 — 도번 SD + 8자리 · 이미 있으면 409.
     면적산출 · 재료산출 파일이 없으면 빈 통합문서도 같이 만듦(같은 8자리)."""
@@ -400,6 +435,7 @@ def _combo_row(key: str, col: dict[str, Any], numbers: dict[str, str]) -> dict[s
         "분류3": level3,
         "단위": col.get("단위"),
         "일위대가": col.get("일위대가"),
+        "자재조합": col.get("자재조합"),
         **{field: numbers.get(field, "") for _, field, _, _ in PARTS},
         "바인딩": col.get("바인딩"),
         "펼침": col.get("펼침"),
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Structure.css b/M02_MasterTemplete/M02_MasterTemplete_Structure.css
index 104ed6ac..e291744e 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Structure.css
+++ b/M02_MasterTemplete/M02_MasterTemplete_Structure.css
@@ -54,13 +54,19 @@
   min-width: 0;
 }
 
+/* 머리 = 번호 · [수정] 한 줄, 이름은 그 아래 전체 폭 — 긴 이름도 잘리지 않게 줄바꿈 */
+.m02-struct__head {
+  flex-wrap: wrap;
+}
+
 .m02-struct__title {
+  order: 1;
+  flex: 1 0 100%;
+  min-width: 0;
   margin: 0;
-  overflow: hidden;
   color: var(--color-text);
   font-size: var(--text-body);
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  overflow-wrap: anywhere; /* 이름이 길어도 잘리지 않게 줄바꿈 */
 }
 
 .m02-struct__no {
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Structure.ts b/M02_MasterTemplete/M02_MasterTemplete_Structure.ts
index b95e356c..a52ae745 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Structure.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Structure.ts
@@ -264,7 +264,7 @@ export function createStructurePanel(opts: StructurePanelOptions): StructurePane
 
   const columnName = el("span", { className: "m02-struct__title" });
   const number = el("span", { className: "m02-struct__no" });
-  const edit = createButton({ label: TEXT.edit, variant: "filled" });
+  const edit = createButton({ label: TEXT.edit, variant: "filled", size: "sm" });
   const previewHost = el("div", { className: "m02-struct__preview" });
   const infoCard = card(
     TEXT.drawingInfo,
@@ -288,6 +288,7 @@ export function createStructurePanel(opts: StructurePanelOptions): StructurePane
     const editButton = createButton({
       label: fill(TEXT.editSheet, PARTS[kind].word),
       variant: "ghost",
+      size: "sm",
     });
     const host = el("div", { className: "m02-struct__sheet" });
     editButton.addEventListener("click", () => void openEdit(kind));
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts
index 2ac3160b..93e60594 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts
@@ -23,6 +23,18 @@ import {
   type StructureColumn,
   type StructurePanelHandle,
 } from "./M02_MasterTemplete_Structure";
+import { buildComboBar } from "./M02_MasterTemplete_Combo";
+import {
+  buildMaterialPanel,
+  loadMaterialState,
+  toPills,
+  type MaterialPanel,
+  type MaterialState,
+} from "./M02_MasterTemplete_Materials";
+import type { SpreadsheetHandle } from "../A00_Common/spreadsheet/spreadsheet";
+import type { LinkOptions } from "../A00_Common/spreadsheet/spreadsheet_links";
+import { searchMaterials } from "../M01_MasterData/M01_MasterData_Api_Fetch";
+import type { MaterialItem } from "./M02_MasterTemplete_Api_Fetch";
 export interface Selection {
   layer: Layer;
   projectId: string | null;
@@ -87,6 +99,7 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
   const save = createButton({ label: L("M02_Save"), variant: "filled" });
   const slot = el("div", { className: "m02-main__slot" }); // 도면 양식의 작도 영역 칸이 들어옴
   const notice = el("div", { className: "m02-main__notice", attrs: { hidden: "" } });
+  const comboSlot = el("div", { className: "m02-main__combo" }); // 면적산출 — 알약 막대 위 조합 줄
   const host = el("div", { className: "m02-main__host" });
   const extra = el("div", { className: "m02-main__extra" }); // 표 밖 형제 자리 — 구조물 설계 컨테이너
   const root = el("div", {
@@ -94,6 +107,7 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
     children: [
       el("div", { className: "m02-main__head", children: [title, slot, reload, save] }),
       notice,
+      comboSlot,
       host,
       extra,
     ],
@@ -105,6 +119,9 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
   let editor: EditorHandle | null = null;
   let sheet: SheetEditorHandle | null = null;
   let panel: StructurePanelHandle | null = null;
+  let sheetHandle: SpreadsheetHandle | null = null;
+  let matPanel: MaterialPanel | null = null;
+  let matState: MaterialState | null = null;
   let seq = 0;
   let dirty = false;
 
@@ -139,10 +156,14 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
     editor?.destroy();
     editor = null;
     sheet = null;
+    sheetHandle = null;
+    matPanel = null;
+    matState = null;
     panel?.destroy();
     panel = null;
     extra.replaceChildren();
     slot.replaceChildren();
+    comboSlot.replaceChildren();
   };
 
   /** 구조물집계표 아래 설계 컨테이너 — 고른 열의 도면 정보 · 면적산출 · 재료산출 카드 */
@@ -159,6 +180,106 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
     return made;
   }
 
+  /** 면적산출 · 재료산출 스프레드시트 — 위 알약 막대(sub7 `links`) · 면적 = 그 열 일위대가 입력값 ·
+   * 재료 = 자재DB 찾기(`pillsFor`) · 시스템 층은 면적 = 조합 줄 + [조합 고치기] ·
+   * 재료 = 그 열 자재 조합 담은 자재(알약 항목 = 옆 판 표 = 같은 목록) + 옆 판
+   * (`pillItems` = 옆 판에서 고친 목록으로 알약 막대만 다시 만들 때) */
+  async function mountSheet(
+    doc: unknown,
+    kind: "area" | "material",
+    at: Selection,
+    readOnly: boolean,
+    pillItems?: MaterialItem[],
+  ): Promise<void> {
+    const mine = seq;
+    try {
+      const master = at.layer === "system" && kind === "material";
+      if (master && !matState) matState = await loadMaterialState(at.name);
+      const [{ createSpreadsheet }, pills] = await Promise.all([
+        import("../A00_Common/spreadsheet/spreadsheet"),
+        master ? null : pillsFor(kind, at.name),
+      ]);
+      if (mine !== seq) return;
+      if (pills?.notice) showNotice([pills.notice]);
+      const links: LinkOptions =
+        pills?.links ??
+        ({
+          항목: toPills(pillItems ?? matState?.combo?.담은자재 ?? []),
+          모드: "자재",
+          자재찾기: searchMaterials,
+          // 알약 막대에서 더하기 · 빼기 — 옆 판 표를 같은 목록으로
+          onItemsChange: (list) =>
+            matPanel?.setItems(list.flatMap((i) => (i.자재 ? [{ ...i.자재 }] : []))),
+        } satisfies LinkOptions);
+      const handle: SpreadsheetHandle = createSpreadsheet(
+        host,
+        doc as Parameters<typeof createSpreadsheet>[1],
+        {
+          readOnly,
+          tabs: false, // 시트 하나 · 탭 줄 없음
+          onChange: () => (dirty = !readOnly),
+          links,
+        },
+      );
+      editor = handle;
+      sheetHandle = handle;
+      if (at.layer !== "system") return;
+      if (kind === "area") {
+        const bar = await buildComboBar({
+          column: at.name,
+          label: at.label ?? at.name,
+          isAdmin,
+          beforeEdit: async () => true,
+          // 알약만 다시 받음 — 저장 안 한 시트 고침은 그대로 옮김
+          onApplied: async () => {
+            if (mine !== seq) return;
+            const kept = handle.getDoc();
+            editor?.destroy();
+            editor = null;
+            host.replaceChildren();
+            await mountSheet(kept, kind, at, readOnly);
+          },
+        });
+        if (mine === seq) comboSlot.replaceChildren(...(bar ? [bar] : []));
+        return;
+      }
+      if (matPanel || !matState) return;
+      matPanel = buildMaterialPanel({
+        column: at.name,
+        label: at.label ?? at.name,
+        isAdmin,
+        state: matState,
+        links: () => sheetHandle?.getDoc().시트.flatMap((s) => s.연결 ?? []) ?? [],
+        // 옆 판 표에서 고침 — 알약 막대만 이 목록으로 다시 만듦(저장 안 한 시트 고침은 그대로)
+        onChange: (items) => {
+          const kept = sheetHandle?.getDoc();
+          if (!kept) return;
+          editor?.destroy();
+          editor = null;
+          void mountSheet(kept, kind, at, readOnly, items);
+        },
+        goTo: (code) =>
+          host
+            .querySelector<HTMLElement>(`.ss-link.is-linked[data-key="${CSS.escape(code)}"]`)
+            ?.click(),
+        unlink: (codes) => {
+          const book = sheetHandle?.getDoc();
+          if (!book) return;
+          for (const s of book.시트) {
+            const rest = (s.연결 ?? []).filter((l) => !codes.includes(l.자재?.코드 ?? l.키));
+            if (rest.length) s.연결 = rest;
+            else delete s.연결;
+          }
+          sheetHandle?.setDoc(book);
+          dirty = !readOnly;
+        },
+      });
+      host.append(matPanel.root);
+    } catch {
+      empty(L("M02_NoSpreadsheet"));
+    }
+  }
+
   async function mount(doc: unknown, at: Selection): Promise<void> {
     const readOnly = !canEdit(at.layer, isAdmin);
     host.replaceChildren();
@@ -202,23 +323,7 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
     if (at.kind === "area" || at.kind === "material") {
       // 면적산출 · 재료산출 = 구조물집계표 열마다 한 스프레드시트 — 페이지 번들에 안 섞이게 이 화면을
       // 열 때만 `import()` 로 받음(계약 `spreadsheet_types.ts` 머리)
-      // 위 알약 막대(sub7 `links`) — 면적 = 그 열 일위대가 입력값 · 재료 = 자재DB 찾기(`pillsFor`)
-      try {
-        const [{ createSpreadsheet }, pills] = await Promise.all([
-          import("../A00_Common/spreadsheet/spreadsheet"),
-          pillsFor(at.kind, at.name),
-        ]);
-        if (pills.notice) showNotice([pills.notice]);
-        editor = createSpreadsheet(host, doc as Parameters<typeof createSpreadsheet>[1], {
-          readOnly,
-          tabs: false, // 시트 하나 · 탭 줄 없음
-          onChange: () => (dirty = !readOnly),
-          links: pills.links,
-        });
-      } catch {
-        empty(L("M02_NoSpreadsheet"));
-      }
-      return;
+      return mountSheet(doc, at.kind, at, readOnly);
     }
     const mountDrawing = await findExport<(h: HTMLElement, d: unknown, o: object) => EditorHandle>(
       DRAWING_MODS,
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts
index 80b5c960..e1bbec82 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts
@@ -119,9 +119,9 @@ export function buildSide(opt: SideOptions): SideHandle {
   const editButtons = new Map<Kind, { copy: HTMLButtonElement; del: HTMLButtonElement }>();
   const actionRow = (kind: Kind): HTMLElement[] => {
     if (!canEdit(layer, opt.isAdmin)) return [];
-    const btnNew = createButton({ label: L("M02_New"), variant: "filled" });
-    const copy = createButton({ label: L("M02_Copy"), variant: "ghost" });
-    const del = createButton({ label: L("M02_Delete"), variant: "danger" });
+    const btnNew = createButton({ label: L("M02_New"), variant: "filled", size: "sm" });
+    const copy = createButton({ label: L("M02_Copy"), variant: "ghost", size: "sm" });
+    const del = createButton({ label: L("M02_Delete"), variant: "danger", size: "sm" });
     editButtons.set(kind, { copy, del });
     btnNew.addEventListener("click", () => newTemplate(kind));
     copy.addEventListener("click", copyTemplate);
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css b/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css
index 5c3ae7ed..cb26dc9c 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css
@@ -26,7 +26,7 @@
 
 .m02-main__head {
   display: flex;
-  flex-wrap: nowrap;
+  flex-wrap: wrap;
   align-items: center;
   gap: var(--spacing-12);
 }
@@ -34,10 +34,7 @@
 .m02-main__title {
   flex: 0 1 auto;
   min-width: 3rem;
-  max-width: 9rem;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  overflow-wrap: anywhere; /* 번호 + 이름 — 잘리지 않게 줄바꿈 */
   margin: 0;
   color: var(--color-text);
   font-size: var(--text-body);
diff --git a/resources/master_data/_키대장.json b/resources/master_data/_키대장.json
index b4e053f7..fe3115ac 100644
--- a/resources/master_data/_키대장.json
+++ b/resources/master_data/_키대장.json
@@ -1,5 +1,5 @@
 {
-  "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 252, "CC": 341, "GC": 1104, "QC": 2060, "GX": 1, "UA": 38},
+  "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 252, "CC": 341, "GC": 1104, "QC": 2060, "GX": 1, "UA": 38, "UM": 1},
   "폐기": {"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"}},
   "키": {
     "CC000001": {"원문번호": "공통 1-3-1 콘크리트 및 포장용 재료", "파일": "계수_건설품셈_01장_적용기준.json"},
diff --git a/resources/master_data/_틀.md b/resources/master_data/_틀.md
index b8ed909b..8597ac01 100644
--- a/resources/master_data/_틀.md
+++ b/resources/master_data/_틀.md
@@ -38,7 +38,7 @@
 | MT  | 재료 자재품목 | CF · CC      | 계수 산림 · 건설        |
 | MO  | 재료 유가     | RT           | 요율                    |
 | MP  | 재료 품셈재료(old/ — PLAN 7-4b) | GF · GC · GX | 로직 산림 · 건설 · 자체 |
-| EQ  | 기계          |              |                         |
+| EQ  | 기계          | UA · UM      | 일위대가 조합 · 자재 조합 |
 
 - 빌더는 옛 모양(`열쇠` · 원문별 파일)으로 쓰고 끝에 `scripts/master_keys.py` 의 `adopt` 를 부름 — 키·원문번호·한 테이블·장 파일 이름으로 받음. 옛 이름으로 읽기는 `old_view`.
 
@@ -279,6 +279,7 @@
         { "로직": "GF000219", "메모": "인력 메쌓기" },
         { "로직": "GF000220", "메모": null }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": null
@@ -287,7 +288,8 @@
 }
 ```
 
-- 열 한 벌 — `키` · `이름` · `구분` · `상세구분` · `단위` · `담은로직` · `출처` · `소유` · `비고`(차례까지 이대로 · 안 채운 칸은 `null`).
+- 열 한 벌 — `키` · `이름` · `구분` · `상세구분` · `단위` · `담은로직` · `본뜬키` · `출처` · `소유` · `비고`(차례까지 이대로 · 안 채운 칸은 `null`).
+- `본뜬키` = 갈라 낸 원래 조합 키(M02 조합 갈라 내기) · 없으면 `null` · M01 고치기는 안 보내도 그대로 둠.
 - **담은 로직 목록만 둠** — 수량 · 비율 · 계산 칸을 두지 않음. 로직마다 하는 일이 달라 수량은 로직마다 따로 들어가고, 그 대입과 합계는 프로젝트 몫(B08 · B09).
 - `담은로직` 줄 = `{로직, 메모}` 뿐 · 목록 차례가 곧 조합 안 차례. `메모` = 글자 또는 `null` — 수량 같은 값을 넣는 자리가 아님.
 - `키` = `UA` + 6자리 — 대장 `_키대장.json` 의 `UA` 다음 번호(서버가 줌). 원문이 없어 **줄에 `원문번호` 를 두지 않음**(대장 열쇠는 조합 이름).
@@ -295,3 +297,13 @@
 - `이름` = 글자 · 빈 이름 안 됨 · 60자까지(`master_combo.MAX_이름`) · 같은 파일 안에서 안 겹침.
 - 검사(`check_master.py 조합` · 엔진 `scripts/master_combo.py`) — 없는 로직 키 · 단가산출 로직이 아닌 키 · 같은 로직 두 번 · 빈 조합 · **조합이 조합을 담음**(1단만) · 메모가 글자·`null` 아님 · 이름이 글자 아니거나 없음·너무 김·겹침.
 - 「이 로직을 쓰는 조합」 은 로직 줄에 칸으로 박지 않고 물을 때 훑어 찾음(`master_combo.using`) — 조합은 관리자가 그때그때 만드는 것이라 박아 두면 낡음. 소요량 「용도」 와 결은 같되 자리가 다름.
+
+## 11. 자재 조합 파일
+
+`자재조합.json` 하나 — 구조물 열 재료산출이 쓰는 **자재 목록 묶음**. 머리 `그룹` · `판` · `비고` · `줄`(원문 없음).
+
+- 열 한 벌 — `키` · `이름` · `담은자재` · `본뜬키` · `소유` · `비고`(차례까지 이대로 · 엔진 `scripts/master_material_combo.py`).
+- `키` = `UM` + 6자리 — 대장 `UM` 다음 번호 · 줄에 `원문번호` 를 두지 않음.
+- `담은자재` 줄 = `{코드, 이름, 규격, 단위}` 뿐 · 빈 목록 안 됨 · 같은 코드 두 번 안 됨 · 수량 · 계산은 두지 않음(재료산출 몫).
+- `본뜬키` = 갈라 낸 원래 자재 조합 키 · 없으면 `null` · `소유` = `현장` · `공용`.
+- 새 줄은 M02 갈라 내기(`POST /api/m02/structures/{열}/material-combo`)가 만듦 — 같은 자재 집합이 있으면 그 키.
diff --git a/resources/master_data/_화면_계약.md b/resources/master_data/_화면_계약.md
index a6bf8e63..78400935 100644
--- a/resources/master_data/_화면_계약.md
+++ b/resources/master_data/_화면_계약.md
@@ -183,6 +183,9 @@
 | `POST /combo/delete`  | `{key, version}`                 | `{file, version}`                                        |
 | `POST /combo/preview` | `{combo, inputs}`                | `{키, 이름, 단위, 줄: […], 노무비, 재료비, 경비, 계, 멈춤}` |
 
+- `본뜬키` = 본뜬 원본 조합 키(같은 파일의 다른 UA) 또는 `null`(원본) — 없는 키 · 자기 키는 400 · 목록 · 상세에 그대로 나옴.
+- `POST /combo/delete` 는 구조물집계표 · `구조물집계표조합` 의 「일위대가」 칸으로 쓰는 열이 있으면 409 `{detail: {errors: […], users: [구조물 이름…]}}` — 지우지 않음.
+- 조합 알약 `GET /combo/{키}/inputs` = `{키, 이름, 물량: [{키 = 「이름|단위」, 이름, 단위, 로직: […], 배?}], 조건: []}` — 같은 이름 · 단위 물량은 한 알약.
 - `combo` = 조합 한 줄 통째(`_틀.md` 10장) · `키`·`소유` 는 보내도 서버 것이 이김 · 안 준 칸은 `null` 로 채워 열 한 벌을 맞춤.
 - `version` = `GET /combo` 가 준 그 파일 판본 — 다르면 409 `{detail: {stale: ["일위대가조합.json"]}}`.
 - `GET /combo` 의 `줄` = 담은 로직에 이름을 붙인 목록 `{차례, 로직, 메모, ok, 이름, 원문번호, 구분, 상세구분, 결과단위, 출처}` — 없는 키는 `ok` false 와 `까닭`.
@@ -193,6 +196,22 @@
   - 못 도는 줄은 통째로 멈추지 않고 그 줄만 `ok` false · `까닭` · `멈춤` 에 한 줄 — 나머지 줄의 합계는 그대로 냄.
 - 답 — 200 · 400(틀린 몸 · 이름 없음 · 모르는 소유) · 404(없는 키) · 409(낡은 판본) · 422 `{detail: {errors: […]}}`(검사 걸림 — 없는 로직 키 · 같은 로직 두 번 · 빈 조합 · 조합을 담음).
 
+### 자재 조합
+
+재료산출에서 쓸 **자재 목록 묶음**(파일 `자재조합.json` · 키 `UM` · `_틀.md` 11장). 담은 자재 `{코드, 이름, 규격, 단위}` 만 지님 — 수량 · 단가 없음. 요소 그룹이 아님(`/groups` · `/rows` 에 안 끼고 제 길로만).
+
+| 길                    | 받음                            | 줌                                          |
+| --------------------- | ------------------------------- | ------------------------------------------- |
+| `GET /matsets`        | `q?` `owner?`                   | `{matsets: […]}` — 줄마다 `count` (자재 수) |
+| `GET /matset`         | `key`                           | `{file, version, matset}`                   |
+| `POST /matset/new`    | `{matset, owner?}`              | `{file, version, key, matset}`              |
+| `POST /matset/edit`   | `{key, version, matset, owner?}` | `{file, version, matset}`                   |
+| `POST /matset/delete` | `{key, version}`                | `{file, version}`                           |
+
+- 답 — 200 · 400(이름 없음 · 모르는 소유 · 없는/자기 본뜬키) · 404 · 409(낡은 판본 · 지우기 막음) · 422(없는 자재 코드 · 같은 자재 두 번 · 자재 줄 모양).
+- 지우기는 구조물집계표 · `구조물집계표조합` 의 「자재조합」 칸으로 쓰는 열이 있으면 409 `{detail: {errors: […], users: [구조물 이름…]}}` — 지우지 않음.
+- M02 화면이 새로 만드는 조합도 같은 파일 · 같은 길이라 M01 목록에 같이 보임.
+
 ## 10. 재료 · 기계 고르기
 
 재료 줄은 키 대신 기본 검색어로 품목을 찾음 — 파일 모양 · 찾기 규칙 · 자동값 차례 · 단위 환산은 `_틀.md` 7장.
diff --git a/resources/master_data/scripts/check_master.py b/resources/master_data/scripts/check_master.py
index 264b402a..c42a8285 100644
--- a/resources/master_data/scripts/check_master.py
+++ b/resources/master_data/scripts/check_master.py
@@ -30,6 +30,7 @@ sys.path.insert(0, str(ROOT / "resources/knowledge/original/_pipeline"))
 import master_combo as mcb  # noqa: E402
 import master_formula as mf  # noqa: E402
 import master_keys as mk  # noqa: E402
+import master_material_combo as mmc  # noqa: E402
 from pum_md_tool import _NUM, md_lines  # noqa: E402
 
 BOOKS = (
@@ -249,12 +250,17 @@ def check_combo_form(name: str, data: dict) -> list[str]:
             out.append(f"{where} · 소유 「{row.get('소유')}」 — {' · '.join(mcb.OWNERS)} 아님")
         if not _source_ok(row.get("출처")):
             out.append(f"{where} · 출처 모양 「{row.get('출처')}」")
+        origin = row.get("본뜬키")
+        if origin is not None and not (mk.KEY.fullmatch(str(origin)) and origin[:2] == mcb.TID):
+            out.append(f"{where} · 본뜬키 모양 「{origin}」")
     return out
 
 
 def check_form(name: str, data: dict) -> list[str]:
     if name == mcb.FILE:
         return check_combo_form(name, data)
+    if name == mmc.FILE:
+        return mmc.check_form(name, data)
     if name in SPECIAL_FILES:
         return []
     m = _FILE.match(name)
diff --git a/resources/master_data/scripts/master_combo.py b/resources/master_data/scripts/master_combo.py
index 54d6fa2f..9f2f634f 100644
--- a/resources/master_data/scripts/master_combo.py
+++ b/resources/master_data/scripts/master_combo.py
@@ -18,8 +18,8 @@ FILE = "일위대가조합.json"
 TID = "UA"
 OWNERS = ("현장", "공용")
 MAX_이름 = 60  # 조합 이름 최대 글자 수 — 관리자가 짓는 짧은 이름이라 이보다 길면 저장 막음
-# 줄 열 한 벌 — 차례까지 이대로(`_틀.md` 10장)
-COLS = ("키", "이름", "구분", "상세구분", "단위", "담은로직", "출처", "소유", "비고")
+# 줄 열 한 벌 — 차례까지 이대로(`_틀.md` 10장) · 본뜬키 = 갈라 낸 원래 조합 키(없으면 null)
+COLS = ("키", "이름", "구분", "상세구분", "단위", "담은로직", "본뜬키", "출처", "소유", "비고")
 ITEM_COLS = ("로직", "메모")
 
 
diff --git a/resources/master_data/scripts/master_keys.py b/resources/master_data/scripts/master_keys.py
index 10f08fbf..befb7490 100644
--- a/resources/master_data/scripts/master_keys.py
+++ b/resources/master_data/scripts/master_keys.py
@@ -32,12 +32,13 @@ TABLES = {
     ("로직", "건설품셈"): "GC",
     ("로직", "자체"): "GX",
     ("일위대가조합", None): "UA",
+    ("자재조합", None): "UM",
 }
 GROUP_OF = {tid: group for (group, _), tid in TABLES.items()}
 IDS = tuple(GROUP_OF)
 # 줄에 원문번호를 두지 않는 테이블 — 자재품목은 번호가 남의 품번이라 이름 몫을 못 하고,
 # 조합은 원문이 없어 번호 자체가 없음(대조는 대장에만)
-NO_NUMBER = ("MT", "UA")
+NO_NUMBER = ("MT", "UA", "UM")
 
 
 def table_id(group: str, book: str | None) -> str:
@@ -181,10 +182,12 @@ ROW_ORDER = {
         "상세구분",
         "단위",
         "담은로직",
+        "본뜬키",
         "출처",
         "소유",
         "비고",
     ),
+    "자재조합": ("키", "이름", "담은자재", "본뜬키", "소유", "비고"),
 }
 OLD_CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈)_(\D*)(\d+)장\.json$")
 CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈|자체)_(\d\d)장_.+\.json$")
diff --git a/resources/master_data/scripts/master_material_combo.py b/resources/master_data/scripts/master_material_combo.py
new file mode 100644
index 00000000..52441e9f
--- /dev/null
+++ b/resources/master_data/scripts/master_material_combo.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""자재 조합 — 구조물 열 재료산출이 쓰는 자재 목록 묶음(키 UM · `_틀.md` 11장).
+
+담은 자재 목록만 지님(수량 · 계산은 재료산출 몫). 일위대가 조합(`master_combo`)과 같은 결 —
+갈라 내기(M02) 때 새 줄 · 본뜬키 = 원래 키.
+"""
+
+from __future__ import annotations
+
+import master_combo as mcb
+import master_keys as mk
+
+GROUP = "자재조합"
+FILE = "자재조합.json"
+TID = "UM"
+OWNERS = mcb.OWNERS
+MAX_이름 = mcb.MAX_이름
+COLS = mk.ROW_ORDER[GROUP]  # 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고
+ITEM_COLS = ("코드", "이름", "규격", "단위")
+
+
+def items(row: dict) -> list[dict]:
+    got = row.get("담은자재")
+    return got if isinstance(got, list) else []
+
+
+def check_form(name: str, data: dict) -> list[str]:
+    """파일 틀 + 줄 — 키 모양 · 열 한 벌 · 이름 · 소유 · 담은 자재(빈 목록 · 모양 · 같은 코드 두 번)."""
+    out = [] if data.get("그룹") == GROUP else [f"{name} · 머리 그룹이 「{GROUP}」 아님"]
+    rows = data.get("줄")
+    if not isinstance(rows, list):
+        return out + [f"{name} · 머리 「줄」 목록 없음"]
+    seen_names: dict[str, str] = {}
+    for row in rows:
+        key = str(row.get("키"))
+        where = f"{name} · {key} {row.get('이름') or ''}".strip()
+        if not mk.KEY.fullmatch(key) or key[:2] != TID:
+            out.append(f"{where} · 키 모양이 「{TID}」 + 6자리 아님")
+        if tuple(row) != COLS:
+            out.append(f"{where} · 열이 한 벌이 아님 — 「{' · '.join(COLS)}」")
+        plain = row.get("이름").strip() if isinstance(row.get("이름"), str) else ""
+        if not plain or len(plain) > MAX_이름:
+            out.append(f"{where} · 「이름」 이 없거나 {MAX_이름}자 넘음")
+        elif plain in seen_names:
+            out.append(f"{where} · 「이름」 이 같은 조합과 겹침 — {seen_names[plain]}")
+        seen_names.setdefault(plain, key)
+        if row.get("소유") not in OWNERS:
+            out.append(f"{where} · 소유 「{row.get('소유')}」 — {' · '.join(OWNERS)} 아님")
+        origin = row.get("본뜬키")
+        if origin is not None and not (mk.KEY.fullmatch(str(origin)) and origin[:2] == TID):
+            out.append(f"{where} · 본뜬키 모양 「{origin}」")
+        got = items(row)
+        if not got:
+            out.append(f"{where} · 빈 조합 — 담은 자재가 없음")
+        codes: set[str] = set()
+        for at, one in enumerate(got, start=1):
+            if not isinstance(one, dict) or set(one) - set(ITEM_COLS):
+                out.append(f"{where} 줄{at} · 담은 자재 줄 모양 「{one}」")
+                continue
+            code = str(one.get("코드") or "")
+            if not mk.KEY.fullmatch(code):
+                out.append(f"{where} 줄{at} · 자재 코드 모양 아님 「{code}」")
+            elif code in codes:
+                out.append(f"{where} 줄{at} · 같은 자재를 두 번 담음 「{code}」")
+            codes.add(code)
+    return out
diff --git a/resources/master_data/일위대가조합.json b/resources/master_data/일위대가조합.json
index 6aee5be4..62c5ce2b 100644
--- a/resources/master_data/일위대가조합.json
+++ b/resources/master_data/일위대가조합.json
@@ -10,6 +10,7 @@
       "상세구분": null,
       "단위": "식",
       "담은로직": [{ "로직": "GF000219", "메모": "메쌓기 — 돌쌓기 인력" }, { "로직": "GF000119", "메모": "노체포설 — 굴착기 0.7㎥" }, { "로직": "GF000137", "메모": "운반 — 중기운반 트레일러(20ton)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "브레인이 넣은 견본 · 조합 화면을 바로 볼 수 있게 함 · 지워도 됨"
@@ -28,6 +29,7 @@
         { "로직": "GF000156", "메모": "콘크리트비빔 채움재 (실무 수는 옛 판 값)" },
         { "로직": "GC000214", "메모": "유로폼 설치 및 해체 간단" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "글자새김 자당 6*6 — 우리 로직에 없음\n잔토처리 굴삭기 0.2m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00005 · 울진대흥 B01224"
@@ -49,6 +51,7 @@
         { "로직": "GF000218", "메모": "잡석운반및다짐 (실무 수는 옛 판 값)" },
         { "로직": "GF000124", "메모": "면고르기" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n잔토처리 굴삭기 0.7m3 — 우리 로직에 없음\n측구수로관부설 500∼700kg미만 — 우리 로직에 없음\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 봉화 B00008 · 봉화 B00030 · 영월 B02019 · 영월 B02052 · 영월 B02134"
@@ -72,6 +75,7 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "깬잡석채집 L=45cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채집 기계(0.7㎥,100%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채집 기계 — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00010 · 봉화 B00011 · 봉화 B00022 · 봉화 B00047 · 울진대흥 B01212 · 울진대흥 B01213 · 울진대흥 B01214 · 울진대흥 B01215 · 울진대흥 B01216 · 울진대흥 B01225 · 울진대흥 B01226 · 울진대흥 B01227 · 울진대흥 B01231 · 울진소광 B02122"
@@ -95,6 +99,7 @@
         { "로직": "GC000015", "메모": "강관동바리 2.5m이하(1개월) (실무 수는 옛 판 값)" },
         { "로직": "GC000821", "메모": "잡철물제작및설치(현장) 일반철재" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "PE관 부설 및 접합 D50 — 후보 「부단수 할정자관 부설 및 접합」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 봉화 B00012 · 영월 B02002 · 거창 제12호표"
@@ -111,6 +116,7 @@
         { "로직": "GF000156", "메모": "콘크리트믹서사용 0.45 m3 (실무 수는 옛 판 값)" },
         { "로직": "GF000162", "메모": "콘크리트포장(B-type) t=20cm (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 봉화 B00014 · 울진대흥 B01232"
@@ -122,6 +128,7 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GF000162", "메모": "콘크리트포장(인력) T=20㎝" }, { "로직": "GC000211", "메모": "합판거푸집(6회) 간단" }, { "로직": "GF000163", "메모": "콘크리트포장절단공 임도 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 영월 B02059"
@@ -148,6 +155,7 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "막자갈채집 기계(0.7㎥,100%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n야면석 채집 운반 (25x25x35㎝)장비 — 후보 「야면석 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n막자갈채집 기계 — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈(파쇄석)채집 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00017 · 봉화 B00018 · 봉화 B00029 · 봉화 B00048 · 봉화 B00049 · 봉화 B00055 · 봉화 B00056 · 영월 B01981 · 영월 B01983 · 영월 B01988 · 영월 B02045 · 영월 B02155 · 울진대흥 B01219 · 울진대흥 B01220 · 울진소광 B02120"
@@ -168,6 +176,7 @@
         { "로직": "GC000677", "메모": "모르터바르기 1:3" },
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n잔토처리 굴삭기 0.7m3 — 우리 로직에 없음\n깬잡석채집 L=60cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n파쇄석 채집 L3=35cm내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.2m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00020 · 봉화 B00032 · 봉화 B00036 · 봉화 B00064 · 울진대흥 B01222 · 울진대흥 B01223 · 울진대흥 B01229 · 울진대흥 B01230 · 울진소광 B02125"
@@ -189,6 +198,7 @@
         { "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" },
         { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "잔토처리 굴삭기 0.2m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00025"
@@ -207,6 +217,7 @@
         { "로직": "GC000677", "메모": "모르타르배합 1:3" },
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "깬잡석채집 L=35cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n야면석 채집 운반 (25x25x35㎝)장비 — 후보 「야면석 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n야면석소운반(L=35CM) (L=20m) — 우리 로직에 없음\n콘크리트소운반 (L=20m) — 우리 로직에 없음\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00034 · 영월 B02016 · 영월 B02017 · 울진소광 B02124"
@@ -223,6 +234,7 @@
         { "로직": "GC000206", "메모": "철근가공및조립(현장) 일반(Type-Ⅰ-1)" },
         { "로직": "GC000207", "메모": "철근가공및조립(현장) 일반(Type-Ⅰ-1)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 봉화 B00038"
@@ -240,6 +252,7 @@
         { "로직": "GC000207", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" },
         { "로직": "GC000712", "메모": "유성페인트칠(붓칠)-황색 콘크리트,모르타르면3회 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 봉화 B00041"
@@ -259,6 +272,7 @@
         { "로직": "GC000022", "메모": "강관비계 3개월사용 (실무 수는 옛 판 값)" },
         { "로직": "GC000211", "메모": "합판거푸집 6회 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 봉화 B00058 · 거창 제5호표 · 거창 제6호표"
@@ -275,6 +289,7 @@
         { "로직": "GC000206", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" },
         { "로직": "GC000207", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 봉화 B00062 · 거창 제9호표"
@@ -291,6 +306,7 @@
         { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" },
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B00704"
@@ -308,6 +324,7 @@
         { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" },
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B01982"
@@ -325,6 +342,7 @@
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" },
         { "로직": "GC000310", "메모": "도로반사경설치 D=1000(STS)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B01997"
@@ -341,6 +359,7 @@
         { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" },
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B02152"
@@ -352,6 +371,7 @@
       "상세구분": null,
       "단위": "㎡",
       "담은로직": [{ "로직": "GC000149", "메모": "관목식재(단식) H=0.3~0.7m" }, { "로직": "GC000148", "메모": "굴취(관목) H=0.3~0.7m" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "인력운반 기타 — 우리 로직에 없음\n실무 호표 — 계류보전 B01099"
@@ -368,6 +388,7 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02121"
@@ -379,6 +400,7 @@
       "상세구분": null,
       "단위": "개소",
       "담은로직": [{ "로직": "GC000198", "메모": "레미콘타설 무근(장비)" }, { "로직": "GC000214", "메모": "유로폼 설치 및 해체 간단" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 울진소광 B02129"
@@ -394,6 +416,7 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02123"
@@ -413,6 +436,7 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "물구멍설치 D=50mm — 우리 로직에 없음\n실무 호표 — 울진소광 B02128"
@@ -429,6 +453,7 @@
         { "로직": "GC000206", "메모": "철근가공및조립(현장) Type-Ⅱ-1" },
         { "로직": "GC000207", "메모": "철근가공및조립(현장) Type-Ⅱ-1" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 거창 제7호표 · 거창 제8호표"
@@ -440,6 +465,7 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 봉화 B00007"
@@ -451,6 +477,7 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "PE관 부설 및 접합 D50 — 후보 「부단수 할정자관 부설 및 접합」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n실무 호표 — 봉화 B00039"
@@ -462,6 +489,7 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GC000143", "메모": "평떼붙임 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "단끊기 — 우리 로직에 없음\n단끊기 절취없음 — 우리 로직에 없음\n떼 하차비 — 우리 로직에 없음\n실무 호표 — 봉화 B00052 · 울진소광 B02130"
@@ -473,6 +501,7 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GF000101", "메모": "구조물터파기 토사(B/H 90%+인력10%)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "잔토처리 토사(B/H 100%) — 우리 로직에 없음\n실무 호표 — 영월 B01963"
@@ -484,6 +513,7 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GF000218", "메모": "잡석운반및다짐 (실무 수는 옛 판 값)" }, { "로직": "GF000124", "메모": "면고르기" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 영월 B01984"
@@ -495,6 +525,7 @@
       "상세구분": null,
       "단위": "㎡",
       "담은로직": [{ "로직": "GF000218", "메모": "뒷채움돌채집운반부설 4.5톤 덤프트럭(L=500m) (실무 수는 옛 판 값)" }, { "로직": "GF000226", "메모": "큰돌메쌓기 뒷길이 0.6~0.8m" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n실무 호표 — 영월 B02133"
@@ -506,6 +537,7 @@
       "상세구분": null,
       "단위": "㎡",
       "담은로직": [{ "로직": "GF000218", "메모": "뒷채움돌채집운반부설 4.5톤 덤프트럭(L=500m) (실무 수는 옛 판 값)" }, { "로직": "GF000226", "메모": "큰돌메쌓기 뒷길이 0.6~0.8m" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n실무 호표 — 영월 B02156"
@@ -517,6 +549,7 @@
       "상세구분": null,
       "단위": "개소",
       "담은로직": [{ "로직": "GF000101", "메모": "구조물터파기(토사) 굴삭기0.7m3 (실무 수는 옛 판 값)" }, { "로직": "GC000105", "메모": "다지기 굴삭기0.7m3 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 울진대흥 B01221"
@@ -533,6 +566,7 @@
         { "로직": "GF000156", "메모": "콘크리트믹서사용 0.45 m3 (실무 수는 옛 판 값)" },
         { "로직": "GC000214", "메모": "유로폼 설치 및 해체 보통" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 울진대흥 B01234"
@@ -544,6 +578,7 @@
       "상세구분": null,
       "단위": "kg",
       "담은로직": [{ "로직": "GC000206", "메모": "철근(현장)가공 Type-Ⅰ-----아님 (실무 수는 옛 판 값)" }, { "로직": "GC000207", "메모": "철근(현장)조립 Type-Ⅰ-----아님" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 울진소광 B00287"
@@ -559,6 +594,7 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02119"
@@ -574,6 +610,7 @@
         { "로직": "GF000155", "메모": "레미콘타설(인력운반타설) 소형구조물" },
         { "로직": "GC000211", "메모": "합판거푸집 6회, 간단 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
       "비고": "실무 호표 — 거창 제13호표"
diff --git a/resources/master_data/자재조합.json b/resources/master_data/자재조합.json
new file mode 100644
index 00000000..2e7571f8
--- /dev/null
+++ b/resources/master_data/자재조합.json
@@ -0,0 +1,6 @@
+{
+  "그룹": "자재조합",
+  "판": "2026",
+  "비고": ["자재 조합 = 구조물 열 재료산출이 쓰는 자재 목록 묶음 · 수량·계산은 두지 않음(재료산출 몫)"],
+  "줄": []
+}
diff --git a/resources/master_template/구조물집계표조합.json b/resources/master_template/구조물집계표조합.json
index 965fc91a..31cb46e1 100644
--- a/resources/master_template/구조물집계표조합.json
+++ b/resources/master_template/구조물집계표조합.json
@@ -13,6 +13,7 @@
       "분류3": "기초유",
       "단위": "m",
       "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01010100",
       "면적번": "SA01010100",
       "재료번": "SM01010100",
@@ -76,7 +77,8 @@
       "분류2": "1.2m",
       "분류3": "기초무, 소단",
       "단위": "m",
-      "일위대가": null,
+      "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01010101",
       "면적번": "SA01010101",
       "재료번": "SM01010101",
@@ -91,7 +93,8 @@
       "분류2": "1.5m",
       "분류3": "기초유",
       "단위": "m",
-      "일위대가": null,
+      "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01010200",
       "면적번": "SA01010200",
       "재료번": "SM01010200",
@@ -106,7 +109,8 @@
       "분류2": null,
       "분류3": null,
       "단위": "m",
-      "일위대가": null,
+      "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01020000",
       "면적번": "SA01020000",
       "재료번": "SM01020000",
@@ -122,6 +126,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010100",
       "면적번": "SA02010100",
       "재료번": "SM02010100",
@@ -155,6 +160,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000007",
+      "자재조합": null,
       "도번": "SD02010200",
       "면적번": "SA02010200",
       "재료번": "SM02010200",
@@ -188,6 +194,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010300",
       "면적번": "SA02010300",
       "재료번": "SM02010300",
@@ -221,6 +228,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000006",
+      "자재조합": null,
       "도번": "SD02010400",
       "면적번": "SA02010400",
       "재료번": "SM02010400",
@@ -236,6 +244,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010500",
       "면적번": "SA02010500",
       "재료번": "SM02010500",
@@ -251,6 +260,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010600",
       "면적번": "SA02010600",
       "재료번": "SM02010600",
@@ -266,6 +276,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000036",
+      "자재조합": null,
       "도번": "SD03010100",
       "면적번": "SA03010100",
       "재료번": "SM03010100",
@@ -302,6 +313,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD03010200",
       "면적번": "SA03010200",
       "재료번": "SM03010200",
@@ -317,6 +329,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000008",
+      "자재조합": null,
       "도번": "SD04010100",
       "면적번": "SA04010100",
       "재료번": "SM04010100",
@@ -364,6 +377,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000014",
+      "자재조합": null,
       "도번": "SD05010100",
       "면적번": "SA05010100",
       "재료번": "SM05010100",
@@ -396,6 +410,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000025",
+      "자재조합": null,
       "도번": "SD05010200",
       "면적번": "SA05010200",
       "재료번": "SM05010200",
@@ -444,6 +459,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD06010000",
       "면적번": "SA06010000",
       "재료번": "SM06010000",
@@ -480,6 +496,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD07010100",
       "면적번": "SA07010100",
       "재료번": "SM07010100",
@@ -513,6 +530,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD07010200",
       "면적번": "SA07010200",
       "재료번": "SM07010200",
@@ -546,6 +564,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000026",
+      "자재조합": null,
       "도번": "SD08010100",
       "면적번": "SA08010100",
       "재료번": "SM08010100",
@@ -576,6 +595,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000003",
+      "자재조합": null,
       "도번": "SD08010200",
       "면적번": "SA08010200",
       "재료번": "SM08010200",
@@ -615,6 +635,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD09010100",
       "면적번": "SA09010100",
       "재료번": "SM09010100",
@@ -651,6 +672,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD10010100",
       "면적번": "SA10010100",
       "재료번": "SM10010100",
@@ -697,6 +719,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000032",
+      "자재조합": null,
       "도번": "SD11010100",
       "면적번": "SA11010100",
       "재료번": "SM11010100",
@@ -733,6 +756,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD12010100",
       "면적번": "SA12010100",
       "재료번": "SM12010100",
@@ -772,6 +796,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000031",
+      "자재조합": null,
       "도번": "SD12010200",
       "면적번": "SA12010200",
       "재료번": "SM12010200",
@@ -787,6 +812,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD13010000",
       "면적번": "SA13010000",
       "재료번": "SM13010000",
@@ -817,6 +843,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD14000000",
       "면적번": "SA14000000",
       "재료번": "SM14000000",
@@ -835,6 +862,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD15000000",
       "면적번": "SA15000000",
       "재료번": "SM15000000",
@@ -853,6 +881,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD15010000",
       "면적번": "SA15010000",
       "재료번": "SM15010000",
@@ -868,6 +897,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD16000000",
       "면적번": "SA16000000",
       "재료번": "SM16000000",
@@ -886,6 +916,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD17000000",
       "면적번": "SA17000000",
       "재료번": "SM17000000",
@@ -904,6 +935,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD18000000",
       "면적번": "SA18000000",
       "재료번": "SM18000000",
@@ -925,6 +957,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD19000000",
       "면적번": "SA19000000",
       "재료번": "SM19000000",
@@ -946,6 +979,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000017",
+      "자재조합": null,
       "도번": "SD20000000",
       "면적번": "SA20000000",
       "재료번": "SM20000000",
@@ -967,6 +1001,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000018",
+      "자재조합": null,
       "도번": "SD21000000",
       "면적번": "SA21000000",
       "재료번": "SM21000000",
@@ -985,6 +1020,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000010",
+      "자재조합": null,
       "도번": "SD22000000",
       "면적번": "SA22000000",
       "재료번": "SM22000000",
@@ -1003,6 +1039,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000016",
+      "자재조합": null,
       "도번": "SD23000000",
       "면적번": "SA23000000",
       "재료번": "SM23000000",
@@ -1021,6 +1058,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000002",
+      "자재조합": null,
       "도번": "SD24000000",
       "면적번": "SA24000000",
       "재료번": "SM24000000",
@@ -1039,6 +1077,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD25010000",
       "면적번": "SA25010000",
       "재료번": "SM25010000",
@@ -1069,6 +1108,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000005",
+      "자재조합": null,
       "도번": "SD26000000",
       "면적번": "SA26000000",
       "재료번": "SM26000000",
@@ -1084,6 +1124,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000009",
+      "자재조합": null,
       "도번": "SD27010000",
       "면적번": "SA27010000",
       "재료번": "SM27010000",
@@ -1099,6 +1140,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000009",
+      "자재조합": null,
       "도번": "SD27020000",
       "면적번": "SA27020000",
       "재료번": "SM27020000",
@@ -1114,6 +1156,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000011",
+      "자재조합": null,
       "도번": "SD28000000",
       "면적번": "SA28000000",
       "재료번": "SM28000000",
@@ -1129,6 +1172,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000023",
+      "자재조합": null,
       "도번": "SD29000000",
       "면적번": "SA29000000",
       "재료번": "SM29000000",
@@ -1144,6 +1188,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000012",
+      "자재조합": null,
       "도번": "SD30000000",
       "면적번": "SA30000000",
       "재료번": "SM30000000",
@@ -1159,6 +1204,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000013",
+      "자재조합": null,
       "도번": "SD31000000",
       "면적번": "SA31000000",
       "재료번": "SM31000000",
@@ -1174,6 +1220,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000033",
+      "자재조합": null,
       "도번": "SD32000000",
       "면적번": "SA32000000",
       "재료번": "SM32000000",
@@ -1189,6 +1236,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000034",
+      "자재조합": null,
       "도번": "SD33000000",
       "면적번": "SA33000000",
       "재료번": "SM33000000",
@@ -1204,6 +1252,7 @@
       "분류3": null,
       "단위": "경간",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD34000000",
       "면적번": "SA34000000",
       "재료번": "SM34000000",
@@ -1219,6 +1268,7 @@
       "분류3": null,
       "단위": "㎥",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD35000000",
       "면적번": "SA35000000",
       "재료번": "SM35000000",
@@ -1234,6 +1284,7 @@
       "분류3": null,
       "단위": "ton",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD36000000",
       "면적번": "SA36000000",
       "재료번": "SM36000000",
diff --git a/resources/tester/spreadsheet/harness_links.ts b/resources/tester/spreadsheet/harness_links.ts
index 9b36313a..ea6b0ff8 100644
--- a/resources/tester/spreadsheet/harness_links.ts
+++ b/resources/tester/spreadsheet/harness_links.ts
@@ -1,4 +1,4 @@
-/* 알약 막대 시험 틀 — 진짜 부품(createSpreadsheet)에 `links` 선택 · 가짜 입력값 · 가짜 자재 목록.
+/* 알약 막대 시험 틀 — 진짜 부품(createSpreadsheet)에 `links` 선택 · 가짜 입력값 · 가짜 자재 목록(호스트 항목 + 자재찾기).
  * Vite 개발 서버가 바로 풂: /resources/tester/spreadsheet/harness_links.html?mode=입력|자재
  * window.ss = 부품 손잡이(getDoc · getLinkedValues) · window.ssFind = 자재찾기 부른 글 목록 */
 import "../../../ui_template/ui_template_theme.css"; // 앱 색 · 간격 토큰
@@ -37,17 +37,29 @@ const MATERIALS: LinkMaterial[] = [
 ];
 const asked: string[] = [];
 w.ssFind = asked;
+w.ssItems = [] as unknown[]; // onItemsChange 로 받은 목록들(부른 순서)
+// 자재 모드 — 호스트가 주는 처음 목록(자재 정보 포함): 레미콘 하나
+const hostItems = MATERIALS.slice(0, 1).map((m) => ({
+  키: m.코드,
+  이름: `${m.이름} ${m.규격}`,
+  단위: m.단위,
+  자재: m,
+}));
 
 w.ss = createSpreadsheet(document.getElementById("host")!, book, {
   tabs: false,
   onChange: () => (w.ssChanges = ((w.ssChanges as number) ?? 0) + 1),
   links: {
     모드: mode,
-    항목: [
-      { 키: "L", 이름: "길이", 단위: "m" },
-      { 키: "H", 이름: "높이", 단위: "m" },
-      { 키: "A", 이름: "면적", 단위: "m²" },
-    ],
+    항목:
+      mode === "자재"
+        ? hostItems
+        : [
+            { 키: "L", 이름: "길이", 단위: "m" },
+            { 키: "H", 이름: "높이", 단위: "m" },
+            { 키: "A", 이름: "면적", 단위: "m²" },
+          ],
+    onItemsChange: (목록) => (w.ssItems as unknown[]).push(목록),
     자재찾기: async (글) => {
       asked.push(글);
       await new Promise((r) => setTimeout(r, 50));
diff --git a/resources/tester/test_m01_combo_inputs.py b/resources/tester/test_m01_combo_inputs.py
index 0e7189d2..d4f174f9 100644
--- a/resources/tester/test_m01_combo_inputs.py
+++ b/resources/tester/test_m01_combo_inputs.py
@@ -4,16 +4,24 @@
   - 물량 = 로직 결과단위 분모(원/㎥ → ㎥) · 설계 조건(고르기 · 범위)은 안 넣음(`조건` 은 빈 자리).
   - 이름 = 로직 이름 끝 괄호 뗀 것 · 같은 이름 · 단위면 한 알약(로직 여럿).
   - 원/10㎡ 는 단위 ㎡ · `배` 10 · 없는 조합 404.
-정본 파일을 읽기만 함.
+  - 알약 키 = 「이름|단위」 — 로직을 빼고 · 더하고 · 차례를 바꿔도 같은 물량이면 같은 키.
+  - 조합 지우기 — 구조물 열이 「일위대가」 로 쓰면 409 + 쓰는 구조물 이름들 · 안 쓰면 지워짐.
+정본은 읽기만 함(지우기 · 만들기 시험은 사본 폴더).
 """
 
 from __future__ import annotations
 
+import json
+import shutil
+from pathlib import Path
+
 import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 
 from M01_MasterData import M01_MasterData_Router as router_module
+from M01_MasterData import M01_MasterData_Store as store
+from M01_MasterData import M01_MasterData_Store_Combo as combo_store
 
 
 @pytest.fixture(scope="module")
@@ -36,13 +44,14 @@ def test_기슭막이_찰쌓기_인력_장비는_한_알약(client) -> None:
     assert len(got["물량"]) == 10  # 담은 로직 11 · 찰쌓기 둘이 합침
     assert by[("돌쌓기 찰쌓기", "㎡")]["로직"] == ["GF000222", "GF000221"]
     assert by[("레디믹스트콘크리트 타설", "㎥")]["로직"] == ["GC000198"]
-    assert by[("유로폼 설치 및 해체", "㎡")]["키"] == "GC000214"
+    assert by[("유로폼 설치 및 해체", "㎡")]["키"] == "유로폼 설치 및 해체|㎡"
     assert set(got["물량"][0]) == {"키", "이름", "단위", "로직"}
 
 
 def test_원_10제곱미터는_배_10(client) -> None:
     got = _pills(client, "UA000031")
-    pill = next(p for p in got["물량"] if p["키"] == "GF000226")
+    pill = next(p for p in got["물량"] if p["로직"] == ["GF000226"])
+    assert pill["키"] == f"{pill['이름']}|㎡"
     assert (pill["단위"], pill["배"]) == ("㎡", 10)
 
 
@@ -53,3 +62,82 @@ def test_준공표지석_물량_여섯(client) -> None:
 
 def test_없는_조합은_404(client) -> None:
     assert client.get("/api/m01/combo/UA999999/inputs").status_code == 404
+
+
+@pytest.fixture
+def own(tmp_path: Path, monkeypatch) -> TestClient:
+    """사본 마스터 폴더 · 사본 집계표 — 조합을 만들고 지워도 정본은 그대로."""
+    for path in store.FOLDER.glob("*.json"):
+        if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
+            shutil.copy(path, tmp_path / path.name)
+    monkeypatch.setattr(store, "FOLDER", tmp_path)
+    sheet = tmp_path / "집계표.json"
+    sheet.write_text(json.dumps({"열": []}), encoding="utf-8")
+    monkeypatch.setattr(combo_store, "USERS", (sheet,))
+    app = FastAPI()
+    app.include_router(router_module.router)
+    return TestClient(app)
+
+
+def _new(client: TestClient, name: str, codes: list[str]) -> str:
+    combo = {"이름": name, "담은로직": [{"로직": c, "메모": None} for c in codes]}
+    res = client.post("/api/m01/combo/new", json={"combo": combo})
+    assert res.status_code == 200, res.text
+    return res.json()["key"]
+
+
+def test_알약_키는_로직을_빼고_더하고_차례를_바꿔도_같다(own) -> None:
+    both = ["GF000222", "GF000221", "GC000198"]  # 찰쌓기 인력 · 장비 + 타설
+    full = _pills(own, _new(own, "전부", both))["물량"]
+    fewer = _pills(own, _new(own, "장비 뺌", ["GF000222", "GC000198"]))["물량"]
+    swapped = _pills(own, _new(own, "차례 바꿈", both[::-1]))["물량"]
+    keys = {p["키"] for p in full}
+    assert keys == {"돌쌓기 찰쌓기|㎡", "레디믹스트콘크리트 타설|㎥"}
+    assert {p["키"] for p in fewer} == keys
+    assert {p["키"] for p in swapped} == keys
+    assert len({p["키"] for p in full}) == len(full)  # 키 겹침 없음
+
+
+def _use(sheet: Path, key: str) -> None:
+    cols = [
+        {"id": "c5", "머리": ["돌기슭막이", "찰쌓기", "", ""], "일위대가": key},
+        {"id": "c6", "머리": ["돌붙임", "", "", ""], "일위대가": "UA000009"},
+    ]
+    sheet.write_text(json.dumps({"열": cols}, ensure_ascii=False), encoding="utf-8")
+
+
+def test_쓰는_열이_있으면_조합을_못_지우고_구조물_이름을_알린다(own) -> None:
+    key = _new(own, "쓰는 조합", ["GF000222"])
+    _use(combo_store.USERS[0], key)
+    version = own.get(f"/api/m01/combo?key={key}").json()["version"]
+    res = own.post("/api/m01/combo/delete", json={"key": key, "version": version})
+    assert res.status_code == 409
+    detail = res.json()["detail"]
+    assert detail["users"] == ["돌기슭막이 찰쌓기"]
+    assert "돌기슭막이 찰쌓기" in detail["errors"][0]
+    assert own.get(f"/api/m01/combo?key={key}").status_code == 200  # 그대로 남음
+
+
+def test_안_쓰는_조합은_지워진다(own) -> None:
+    key = _new(own, "안 쓰는 조합", ["GF000222"])
+    _use(combo_store.USERS[0], "UA000009")  # 다른 조합을 씀
+    version = own.get(f"/api/m01/combo?key={key}").json()["version"]
+    assert (
+        own.post("/api/m01/combo/delete", json={"key": key, "version": version}).status_code == 200
+    )
+    assert own.get(f"/api/m01/combo?key={key}").status_code == 404
+
+
+def test_본뜬키는_목록에_나오고_없는_키_자기_키는_400(own) -> None:
+    base = _new(own, "원본", ["GF000222"])
+    combo = {"이름": "본뜬 것", "본뜬키": base, "담은로직": [{"로직": "GF000222", "메모": None}]}
+    got = own.post("/api/m01/combo/new", json={"combo": combo}).json()
+    assert got["combo"]["본뜬키"] == base
+    rows = {r["키"]: r for r in own.get("/api/m01/combos").json()["combos"]}
+    assert rows[got["key"]]["본뜬키"] == base and rows[base]["본뜬키"] is None
+    bad = {**combo, "이름": "없는 원본", "본뜬키": "UA999999"}
+    assert own.post("/api/m01/combo/new", json={"combo": bad}).status_code == 400
+    version = own.get(f"/api/m01/combo?key={base}").json()["version"]
+    me = {"이름": "원본", "본뜬키": base, "담은로직": combo["담은로직"]}
+    res = own.post("/api/m01/combo/edit", json={"key": base, "version": version, "combo": me})
+    assert res.status_code == 400
diff --git a/resources/tester/test_m01_matset.py b/resources/tester/test_m01_matset.py
new file mode 100644
index 00000000..7be0f59b
--- /dev/null
+++ b/resources/tester/test_m01_matset.py
@@ -0,0 +1,107 @@
+"""M01 자재 조합(`/api/m01/matset…` · 파일 `자재조합.json` · 키 UM) — 담은 자재 목록만 지님.
+
+못박는 것
+  - 새로 만들면 키를 서버가 `UM` 다음 번호로 줌 · 열 한 벌 · 담은 자재는 네 칸.
+  - 없는 자재 코드 · 같은 자재 두 번 · 이름 없음 · 없는 본뜬키는 막음.
+  - 고치기는 낡은 판본이면 409 · 지우기는 구조물 열이 「자재조합」 칸으로 쓰면 409 + 구조물 이름들.
+  - 정본은 읽기만 함(사본 폴더 · 사본 집계표).
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from M01_MasterData import M01_MasterData_Router as router_module
+from M01_MasterData import M01_MasterData_Store as store
+from M01_MasterData import M01_MasterData_Store_Combo as combo_store
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+@pytest.fixture
+def client(tmp_path: Path, monkeypatch) -> TestClient:
+    for path in store.FOLDER.glob("*.json"):
+        if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
+            shutil.copy(path, tmp_path / path.name)
+    monkeypatch.setattr(store, "FOLDER", tmp_path)
+    sheet = tmp_path / "집계표.json"
+    sheet.write_text(json.dumps({"열": []}), encoding="utf-8")
+    monkeypatch.setattr(combo_store, "USERS", (sheet,))
+    app = FastAPI()
+    app.include_router(router_module.router)
+    return TestClient(app)
+
+
+def _mat(client: TestClient) -> dict:
+    """자재품목에서 실제 줄 하나 — 자재 찾기 길 그대로."""
+    got = client.get("/api/m01/pick", params={"kind": "price", "q": "합판", "limit": 2}).json()
+    one = got["items"][0]
+    return {"코드": one["ref"], "이름": one["이름"], "규격": one["규격"], "단위": one["단위"]}
+
+
+def _new(client: TestClient, name: str, mats: list[dict], **more) -> dict:
+    body = {"matset": {"이름": name, "담은자재": mats, **more}}
+    return client.post("/api/m01/matset/new", json=body)
+
+
+def test_정본_자재조합_파일은_틀대로다() -> None:
+    data = json.loads((ROOT / "resources/master_data/자재조합.json").read_text(encoding="utf-8"))
+    assert data["그룹"] == "자재조합" and isinstance(data["줄"], list)
+    assert store.cm.mmc.check_form("자재조합.json", data) == []
+    assert '"UM"' in (ROOT / "resources/master_data/_키대장.json").read_text(encoding="utf-8")
+
+
+def test_새로_만들면_UM_키와_열_한_벌(client) -> None:
+    mat = _mat(client)
+    res = _new(client, "합판 자재", [{**mat, "덤": 1}])
+    assert res.status_code == 200, res.text
+    made = res.json()
+    assert made["key"].startswith("UM") and len(made["key"]) == 8
+    assert tuple(made["matset"]) == store.cm.mmc.COLS
+    assert made["matset"]["담은자재"] == [mat] and made["matset"]["본뜬키"] is None
+    rows = client.get("/api/m01/matsets").json()["matsets"]
+    assert [(r["키"], r["count"]) for r in rows] == [(made["key"], 1)]
+    got = client.get("/api/m01/matset", params={"key": made["key"]}).json()
+    assert got["matset"]["이름"] == "합판 자재"
+
+
+def test_없는_자재_두_번_담기_이름_본뜬키는_막는다(client) -> None:
+    mat = _mat(client)
+    assert _new(client, "없는 코드", [{**mat, "코드": "MT999999"}]).status_code == 422
+    assert _new(client, "두 번", [mat, mat]).status_code == 422
+    assert _new(client, " ", [mat]).status_code == 400
+    assert _new(client, "없는 원본", [mat], 본뜬키="UM999999").status_code == 400
+    ok = _new(client, "원본", [mat]).json()["key"]
+    assert _new(client, "본뜬 것", [mat], 본뜬키=ok).json()["matset"]["본뜬키"] == ok
+    assert _new(client, "원본", [mat]).status_code == 422  # 이름 겹침
+
+
+def test_고치기는_낡은_판본이면_409(client) -> None:
+    mat = _mat(client)
+    key = _new(client, "고칠 것", [mat]).json()["key"]
+    one = client.get("/api/m01/matset", params={"key": key}).json()
+    body = {"key": key, "version": one["version"], "matset": {**one["matset"], "이름": "고침"}}
+    assert client.post("/api/m01/matset/edit", json=body).status_code == 200
+    assert client.post("/api/m01/matset/edit", json=body).status_code == 409  # 같은 옛 판본
+
+
+def test_쓰는_열이_있으면_못_지우고_없으면_지워진다(client) -> None:
+    mat = _mat(client)
+    key = _new(client, "쓰는 것", [mat]).json()["key"]
+    cols = [{"id": "c9", "머리": ["돌붙임", "찰붙임", "", ""], "자재조합": key}]
+    combo_store.USERS[0].write_text(json.dumps({"열": cols}, ensure_ascii=False), encoding="utf-8")
+    version = client.get("/api/m01/matset", params={"key": key}).json()["version"]
+    res = client.post("/api/m01/matset/delete", json={"key": key, "version": version})
+    assert res.status_code == 409 and res.json()["detail"]["users"] == ["돌붙임 찰붙임"]
+    combo_store.USERS[0].write_text(json.dumps({"열": []}), encoding="utf-8")
+    assert (
+        client.post("/api/m01/matset/delete", json={"key": key, "version": version}).status_code
+        == 200
+    )
+    assert client.get("/api/m01/matset", params={"key": key}).status_code == 404
diff --git a/resources/tester/test_m02_combo_branch.py b/resources/tester/test_m02_combo_branch.py
new file mode 100644
index 00000000..92ab78c1
--- /dev/null
+++ b/resources/tester/test_m02_combo_branch.py
@@ -0,0 +1,211 @@
+"""조합 갈라 내기 · 분류 더하기 복사 (PLAN 15장).
+
+M02 견본 표(`write_sample_table`) + M01 마스터 사본(조합 줄은 비워 시작)으로만 봄.
+  · 일위대가(UA) — 새로 만듦(본뜬키 = 원래 키) · 이 열만 새 키 · 다른 열은 옛 키 · 원래 조합 그대로 ·
+    SS 장부 맞춤 · 담은 로직 집합(차례 · 메모 무시)이 같으면 있는 키 · 또 고치면 또 새로 · 같은 이름 (2)
+  · 자재 조합(UM) — 같은 규칙 · 처음 만드는 열(본뜬키 없음) · 읽기
+  · 집계표 판 어긋남 = 409 · 조합 안 만듦
+  · 분류 더하기로 복사한 열(`본뜬열`) — [저장] 때 원본 키 · 세 파일 내용을 새 번호로 받음
+"""
+
+import json
+import shutil
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from M01_MasterData import M01_MasterData_Store as m01
+from M01_MasterData import M01_MasterData_Store_Combo as combo_store
+from M02_MasterTemplete import M02_MasterTemplete_Branch as branch
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete.M02_MasterTemplete_Router import router
+from resources.tester.test_m02_structure import write_sample_table
+
+REAL = m01.FOLDER
+A, B, C = "GF000219", "GF000220", "GF000211"  # 돌쌓기 메쌓기(인력 · 장비) · 채집(인력)
+M1, M2 = (
+    {"코드": "MT000001", "이름": "시멘트", "규격": "40kg", "단위": "포"},
+    {"코드": "MT000002", "이름": "모래", "규격": None, "단위": "㎥"},
+)
+TABLE = "/api/m02/templates/table/구조물집계표"
+
+
+@pytest.fixture()
+def client(tmp_path, monkeypatch):
+    master = tmp_path / "master"
+    master.mkdir()
+    for path in REAL.glob("*.json"):
+        if not path.name.startswith("_") or path.name == m01.mk.BOOK.name:
+            shutil.copy(path, master / path.name)
+    for name in (combo_store.FILE, branch.MATERIAL_FILE):
+        own = master / name
+        data = json.loads(own.read_text(encoding="utf-8"))
+        data["줄"] = []
+        own.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    monkeypatch.setattr(m01, "FOLDER", master)
+    template = tmp_path / "template"
+    template.mkdir()
+    write_sample_table(template)
+    monkeypatch.setattr(store, "FOLDER", template)
+    app = FastAPI()
+    app.include_router(router)
+    return TestClient(app)
+
+
+def _source(client) -> str:
+    """원래 조합(A · B) — rv · c1 두 열이 같이 가리킴."""
+    got = combo_store.combo_new(
+        {
+            "이름": "기슭막이",
+            "구분": "실무 일위대가",
+            "상세구분": "13장 구조물",
+            "단위": "m",
+            "담은로직": [{"로직": A, "메모": None}, {"로직": B, "메모": None}],
+            "출처": "자체",
+        },
+        "현장",
+    )
+    table = client.get(TABLE).json()
+    for col in table["문서"]["열"]:
+        if col["id"] in ("rv", "c1"):
+            col["일위대가"] = got["key"]
+    assert client.put(TABLE, json={"판": table["판"], "문서": table["문서"]}).status_code == 200
+    return got["key"]
+
+
+def _branch(client, column, source, keys, name="", 판="", want=200):
+    body = {"본뜬키": source, "담은로직": [{"로직": k} for k in keys], "이름": name, "판": 판}
+    res = client.post(f"/api/m02/structures/{column}/combo", json=body)
+    assert res.status_code == want, res.text
+    return res.json()
+
+
+def _cols(client, field="일위대가") -> dict[str, str | None]:
+    return {c["id"]: c.get(field) for c in client.get(TABLE).json()["문서"]["열"]}
+
+
+def _ss(client, field="일위대가") -> dict[str, str | None]:
+    rows = client.get("/api/m02/structure-combos").json()["줄"]
+    return {r["열"]: r[field] for r in rows}
+
+
+def test_새로_만듦_이_열만_새_키_원래_조합_그대로(client):
+    ua = _source(client)
+    판 = client.get(TABLE).json()["판"]
+    got = _branch(client, "rv", ua, [A, B, C], "기슭막이 · 돌기슭막이", 판)
+    assert got["새로만듦"] is True and got["키"] != ua
+    assert got["이름"] == "기슭막이 · 돌기슭막이"
+    assert got["집계표판"] == client.get(TABLE).json()["판"] != 판
+    cols = _cols(client)
+    assert (cols["rv"], cols["c1"]) == (got["키"], ua)  # 다른 열은 옛 키
+    assert _ss(client)["rv"] == got["키"] and _ss(client)["c1"] == ua  # SS 장부 맞춤
+    new = combo_store.combo(got["키"])["combo"]
+    assert tuple(new) == combo_store.mcb.COLS  # 열 한 벌 · 본뜬키 칸 포함
+    assert [x["로직"] for x in new["담은로직"]] == [A, B, C]
+    assert (new["본뜬키"], new["구분"], new["상세구분"], new["단위"], new["출처"], new["소유"]) == (
+        ua,
+        "실무 일위대가",
+        "13장 구조물",
+        "m",
+        "자체",
+        "현장",
+    )
+    assert [x["로직"] for x in combo_store.combo(ua)["combo"]["담은로직"]] == [A, B]
+    # M01 에서 고쳐도(화면이 본뜬키를 안 보내도) 계보는 남음
+    one = combo_store.combo(got["키"])
+    edited = {k: v for k, v in one["combo"].items() if k != "본뜬키"} | {"이름": "고친 이름"}
+    combo_store.combo_edit(got["키"], one["version"], edited)
+    assert combo_store.combo(got["키"])["combo"]["본뜬키"] == ua
+
+
+def test_같은_로직_집합이면_있는_키_또_고치면_또_새로_같은_이름은_2(client):
+    ua = _source(client)
+    same = _branch(client, "c1", ua, [B, A])  # 차례만 바꿈 = 원래 조합
+    assert (same["키"], same["새로만듦"]) == (ua, False)
+    first = _branch(client, "rv", ua, [A, B, C], "갈래")
+    again = _branch(client, "rv", first["키"], [A, C], "갈래")  # 갈라 낸 것을 또 고침 = 또 새로
+    assert again["새로만듦"] is True and again["키"] not in (ua, first["키"])
+    assert again["이름"] == "갈래 (2)"
+    assert combo_store.combo(again["키"])["combo"]["본뜬키"] == first["키"]
+    back = _branch(client, "c1", ua, [C, A, B])  # 다른 열이 같게 고침 = 있는 키
+    assert (back["키"], back["새로만듦"]) == (first["키"], False)
+    assert _cols(client)["c1"] == first["키"] and _ss(client)["c1"] == first["키"]
+
+
+def test_집계표_판_어긋나면_409_조합_안_만듦(client):
+    ua = _source(client)
+    before = len(m01.read(combo_store.FILE)[0]["줄"])
+    _branch(client, "rv", ua, [A, B, C], "x", "0000000000000000", want=409)
+    assert len(m01.read(combo_store.FILE)[0]["줄"]) == before
+    assert _cols(client)["rv"] == ua
+    _branch(client, "no", ua, [A, C], want=404)  # 글 열(구조물 아님)
+    _branch(client, "rv", "UA999999", [A, C], want=404)  # 없는 원래 조합
+
+
+def _material(client, column, source, items, name="", want=200):
+    body = {"본뜬키": source, "담은자재": items, "이름": name}
+    res = client.post(f"/api/m02/structures/{column}/material-combo", json=body)
+    assert res.status_code == want, res.text
+    return res.json()
+
+
+def test_자재_조합_처음_만듦_같은_내용이면_있는_키_고치면_새로(client):
+    first = _material(client, "rv", "", [M1, M2])
+    assert first["새로만듦"] is True and first["키"].startswith("UM")
+    assert first["이름"] == "돌기슭막이 (형태마다) H=(높이마다)"  # 이름 없으면 열 머리
+    row = client.get(f"/api/m02/material-combos/{first['키']}").json()
+    assert tuple(row) == ("키", "이름", "담은자재", "본뜬키", "소유", "비고")
+    assert (row["본뜬키"], row["소유"], row["담은자재"]) == (None, "현장", [M1, M2])
+    same = _material(client, "c1", "", [M2, M1])  # 차례만 다름 = 있는 키
+    assert (same["키"], same["새로만듦"]) == (first["키"], False)
+    fork = _material(client, "c1", first["키"], [M1], "시멘트만")
+    assert fork["새로만듦"] is True and fork["키"] != first["키"]
+    assert client.get(f"/api/m02/material-combos/{fork['키']}").json()["본뜬키"] == first["키"]
+    assert (_cols(client, "자재조합")["rv"], _cols(client, "자재조합")["c1"]) == (
+        first["키"],
+        fork["키"],
+    )
+    assert _ss(client, "자재조합")["c1"] == fork["키"]
+    assert client.get("/api/m02/material-combos/UM999999").status_code == 404
+    _material(client, "rv", "", [{"코드": "없는모양"}], want=422)  # M01 저장 검사
+
+
+def test_분류_더하기로_복사한_열은_원본_키_세_파일_내용을_받음(client):
+    ua = _source(client)
+    table = client.get(TABLE).json()
+    doc = table["문서"]
+    rv = next(c for c in doc["열"] if c["id"] == "rv")
+    rv["자재조합"] = "UM000001"
+    assert client.put(TABLE, json={"판": table["판"], "문서": doc}).status_code == 200
+    drawing = client.get("/api/m02/templates/structure/rv").json()
+    marked = {**drawing["문서"], "도면": {"format": 6, "entities": [{"type": "line"}]}}
+    put = client.put("/api/m02/templates/structure/rv", json={"판": drawing["판"], "문서": marked})
+    assert put.status_code == 200
+    table = client.get(TABLE).json()
+    doc = table["문서"]
+    at = next(i for i, c in enumerate(doc["열"]) if c["id"] == "rv")
+    head = ["돌기슭막이", "(형태마다)", "H=(높이마다) 2", None]
+    doc["열"].insert(at + 1, {"id": "c9", "머리": head, "단위": None, "꼴": "수", "본뜬열": "rv"})
+    assert client.put(TABLE, json={"판": table["판"], "문서": doc}).status_code == 200
+    saved = next(c for c in client.get(TABLE).json()["문서"]["열"] if c["id"] == "c9")
+    assert "본뜬열" not in saved  # 뗌
+    assert (saved["일위대가"], saved["자재조합"]) == (ua, "UM000001")
+    copy = client.get("/api/m02/templates/structure/c9").json()["문서"]
+    assert copy["도면"]["entities"] == [{"type": "line"}] and copy["열"] == "c9"
+    numbers = client.get("/api/m02/structures/numbers").json()
+    assert numbers["c9"]["도번"] != numbers["rv"]["도번"]  # 새 번호
+    assert numbers["c9"]["면적번"][2:] == numbers["c9"]["도번"][2:]
+    for kind in ("area", "material"):
+        assert client.get(f"/api/m02/templates/{kind}/c9").json()["문서"]["열"] == "c9"
+    # 그 뒤로는 열마다 따로 — 원본을 고쳐도 복사본은 그대로
+    drawing = client.get("/api/m02/templates/structure/rv").json()
+    client.put(
+        "/api/m02/templates/structure/rv",
+        json={
+            "판": drawing["판"],
+            "문서": {**drawing["문서"], "도면": marked["도면"] | {"entities": []}},
+        },
+    )
+    again = client.get("/api/m02/templates/structure/c9").json()["문서"]
+    assert again["도면"]["entities"] == [{"type": "line"}]
diff --git a/ui_template/sheet/ui_template_sheet_ops.ts b/ui_template/sheet/ui_template_sheet_ops.ts
index dbc5f1fc..4e28211a 100644
--- a/ui_template/sheet/ui_template_sheet_ops.ts
+++ b/ui_template/sheet/ui_template_sheet_ops.ts
@@ -141,7 +141,16 @@ export function addLevel(
     "c",
     doc.열.map((c) => c.id),
   );
-  doc.열.splice(at + 1, 0, { id, 머리: head, 단위: base.단위 ?? null, 꼴: "수" });
+  // 원본(`after`) 열을 따라감 — 일위대가 · 자재조합 같은 키 · 구조물 파일은 저장 때 서버가 복사
+  doc.열.splice(at + 1, 0, {
+    id,
+    머리: head,
+    단위: base.단위 ?? null,
+    꼴: "수",
+    ...(base.꼴 !== "글"
+      ? { 본뜬열: base.id, 일위대가: base.일위대가 ?? null, 자재조합: base.자재조합 ?? null }
+      : {}),
+  });
   return id;
 }
 
diff --git a/ui_template/sheet/ui_template_sheet_types.ts b/ui_template/sheet/ui_template_sheet_types.ts
index 26673614..b89a9d72 100644
--- a/ui_template/sheet/ui_template_sheet_types.ts
+++ b/ui_template/sheet/ui_template_sheet_types.ts
@@ -35,6 +35,10 @@ export interface SheetColumn {
   바인딩?: SheetBinding | null;
   /** 일위대가 조합 키. */
   일위대가?: string | null;
+  /** 자재 조합 키(`UM`). */
+  자재조합?: string | null;
+  /** 분류 더하기로 복사한 원본 열 id — 저장 때 서버가 원본 열 내용을 새 열로 복사하고 뗌. */
+  본뜬열?: string | null;
   /** 마스터 한 칸 → 프로젝트에서 설계 값마다 열. */
   펼침?: boolean;
   /** 사용자 입력 열. */
diff --git a/ui_template/ui_template_elements.ts b/ui_template/ui_template_elements.ts
index cb8fc767..4bd498b4 100644
--- a/ui_template/ui_template_elements.ts
+++ b/ui_template/ui_template_elements.ts
@@ -24,11 +24,14 @@ export { el } from "./ui_template_elements_base";
  * -------------------------------------------------------------------------- */
 
 export type ButtonVariant = "filled" | "ghost" | "pill" | "danger" | "glass";
+export type ButtonSize = "md" | "sm";
 
 export interface ButtonOptions {
   /** 표시 텍스트 (i18n 결과 문자열을 전달) */
   label: string;
   variant?: ButtonVariant;
+  /** 크기 — 기본 md · sm = 표 칸·카드 머리용 작은 단추(글자 캡션 크기) */
+  size?: ButtonSize;
   /** 이벤트 핸들러 (frontend.md §4: on[페이지]_[기능]_[액션] 명명) */
   onClick?: (ev: MouseEvent) => void;
   disabled?: boolean;
@@ -40,7 +43,7 @@ export interface ButtonOptions {
 export function createButton(opts: ButtonOptions): HTMLButtonElement {
   const variant = opts.variant ?? "filled";
   const btn = el("button", {
-    className: `ui-btn ui-btn--${variant}`,
+    className: `ui-btn ui-btn--${variant}${opts.size === "sm" ? " ui-btn--sm" : ""}`,
     attrs: { type: opts.type ?? "button" },
   });
   if (opts.iconStart) {
diff --git a/ui_template/ui_template_elements_styles.ts b/ui_template/ui_template_elements_styles.ts
index 598b4df1..5a1dd3d1 100644
--- a/ui_template/ui_template_elements_styles.ts
+++ b/ui_template/ui_template_elements_styles.ts
@@ -33,6 +33,12 @@ const BASE_CSS = `
 .ui-btn:disabled { opacity: 0.5; cursor: not-allowed; }
 .ui-btn__icon { display: inline-flex; width: 16px; height: 16px; }
 
+/* 작은 크기 — 다섯 모양 모두에 먹음(padding · 글자만 바꿈) */
+.ui-btn--sm {
+  padding: 2px var(--spacing-8);
+  font-size: var(--text-caption);
+}
+
 .ui-btn--filled {
   background-color: var(--color-primary);
   color: var(--color-primary-text);