feat(830-2): 재료 DB 가격 열 재정의 · 항목 통합 이어 감 — 조달청 · 일반가격 · 상하차 · 재료 아닌 줄 삭제

- 열 한 벌 = 키 · 구분 · 상세구분 · 이름 · 규격 · 단위 · 상하차 · 조달청 · 물가자료 · 유통물가 · 물가정보 · 거래가격 · 일반가격 · 출처 · 비고 · 면수(material_merge.COLUMNS 한 곳 · check_master 가 씀)
- 「관급」 칸 → 「조달청」(값 0 · EST 가격정보 값 안 씀) · 새 칸 「일반가격」(빈칸 · 시스템 관리자 손 입력 · 빌더가 원문번호로 이어 받음) · 상하차 = 단위 바로 뒤
- 남는 줄 지역 기준 = 전국 › 지역 없음 › 서울 › 서울 권역 › 경기 › 그 밖(값 중간) · 기준 지역은 비고 「통합: 기준 지역 …」(지역 없는 묶음은 안 적음)
- 재료 아닌 줄 삭제(요구 832) — 품질시험 수수료 60(가격정보 출처 「2026(경북)」) · 일반 도로용 블록 5(「~26.10.16」) · 치즐 2 줄은 남김 · 값 없음
- 재료_자재품목 24,092 → 17,692 줄(통합 6,335 · 재료 아닌 줄 65) · 남는 줄 키 = 830-1 키(7565ee787 이 지운 대장 키를 되살려 다시 지음 · 새 키 0) · 남는 줄 물가지 값 바뀐 것 0 · 빌더 두 번 = 같은 파일
- 가장 낮은 값 = 사급 칸(물가지 넷 + 일반가격) — master_material.SLOTS · M02_Elem_Alias.PRICES · M02 PRICE_SLOTS · 조달청 칸 안 봄 · M01 고르기 「관급」 표시 = 조달청 칸 · B09 대비표 「관급」 출처 = M01 조달청 칸(이름 그대로)
- M01 재료 화면 상하차 = 고르기(부품 createSelectField) · 새 줄 기본 「-」 · 로직 고르기 표 · 시험 계산 값 줄에 일반가격
- check_master 틀 · 로직 · 조합 0 · 단위 27 · 배 7(전과 같음) · _틀.md · _갱신절차.md 열 정의
- 시험: 새 test_830_2_material_merge · test_830_1 지움(EST 그대로 상태 = 830-2 로 끝남 · 남는 검사는 830_2 로) · 지역 줄 · 관급 이름 · 관급 칸을 보던 시험 기대값 고침(m01_api · m01_pick · masterdata_check · 814_1 · 815_1 · 827_2 · 827_3 · 750_1 · m02_hopyo_match · m02_labor_doc) · 「시멘트 전국」 검색어 시험 = xfail(830-3 연결 할 일)

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

B09_Estimation/B09_Estimation_Prices.py

@@ -30,8 +30,9 @@ DRIVER_TABLE = "CC000336"
 DRIVER_PARTS = ("시간환산", "상여계수", "휴지계수")
 #: 연료 지역 — M01 기계경비 로직 지역 고르기 첫 값
 FUEL_REGION = "전국평균"
-#: 자재품목 값 열 → 대비표 출처 칸
+#: 자재품목 값 열 → 대비표 출처 칸 · 대비표 「관급」 = M01 「조달청」 칸(830-2)
 MT_SOURCES = ("관급", "물가자료", "유통물가", "물가정보", "거래가격")
+MT_COLUMN = {"관급": "조달청"}
 
 
 def _f(value: Any) -> float | None:
@@ -103,7 +104,7 @@ def material_input(row: dict[str, Any]) -> dict[str, Any]:
         spec = f"{row.get('상세구분') or ''} {row.get('규격') or ''}".strip()
         unit = (row.get("단위") or "").replace("원/", "")
     else:
-        prices = {s: _f(row.get(s)) for s in MT_SOURCES}
+        prices = {s: _f(row.get(MT_COLUMN.get(s, s))) for s in MT_SOURCES}
         pages = {s: (row.get("면수") or {}).get(s) for s in MT_SOURCES if s != "관급"}
         origin = "M01"
         spec = row.get("규격") or ""

M01_MasterData/M01_MasterData_Store.py

@@ -468,7 +468,7 @@ _PICK = {"price": "재료_자재품목.json", "job": "인력.json"}
 
 
 def _lowest(row: dict) -> object:
-    """자재품목 줄 — 값 열 다섯 가운데 낮은 값(시험 계산용) · 값 칸이 있는 줄은 그 값 그대로."""
+    """자재품목 줄 — 사급 값 열 다섯(조달청 뺌) 가운데 낮은 값(시험 계산용) · 값 칸이 있는 줄은 그 값 그대로."""
     if "값" in row:
         return row["값"]
     nums = [row[s] for s in cm.mf.SLOTS if row.get(s) is not None]
@@ -494,7 +494,7 @@ def pick(kind: str, q: str, limit: int) -> dict:
                     "ref": str(row.get("키")),
                     **{k: row.get(k) for k in ("원문번호", "구분", "이름", "규격", "단위")},
                     "값": _lowest(row),
-                    "관급": row.get("관급") is not None,
+                    "관급": row.get(cm.mm.GOVT) is not None,
                 }
             )
     return {"total": len(hits), "items": hits[: min(max(limit, 1), 200)]}
@@ -507,7 +507,7 @@ def _market_brief(row: dict) -> dict:
         **{k: row.get(k) for k in ("구분", "상세구분", "이름", "규격", "단위")},
         "값들": {s: row.get(s) for s in cm.mf.SLOTS},
         "값": _lowest(row),
-        "관급": row.get("관급") is not None,
+        "관급": row.get(cm.mm.GOVT) is not None,
     }
 
 

M01_MasterData/M01_MasterData_UI_LogicLab_Modal.ts

@@ -191,8 +191,8 @@ function goButton(target: MasterJump): HTMLElement {
   return go;
 }
 
-/** 자재품목 값 칸 넷 — 위 가로 줄(관급은 뺌) */
-const SLOTS = ["물가자료", "유통물가", "물가정보", "거래가격"];
+/** 자재품목 사급 값 칸 다섯 — 위 가로 줄(조달청은 뺌 · 830-2) */
+const SLOTS = ["물가자료", "유통물가", "물가정보", "거래가격", "일반가격"];
 const MARKET_FILE = "재료_자재품목.json";
 const marketRows = new Map<string, Promise<Row | null>>();
 /** 자재품목 줄 하나(값 칸 넷) — 키로 찾음 · 한 번만 물음 */

M01_MasterData/M01_MasterData_UI_Logic_PickTable.ts

@@ -27,6 +27,7 @@ const COLS: Record<PickTableKind, string[]> = {
     "유통물가",
     "물가정보",
     "거래가격",
+    "일반가격",
   ],
   기계: ["원문번호", "구분", "상세구분", "이름", "규격", "값›가격"],
 };

M01_MasterData/M01_MasterData_UI_Rows.ts

@@ -29,6 +29,7 @@ import {
   withCell,
 } from "./M01_MasterData_UI_Cells";
 import { createEmpty } from "@ui/ui_template_empty";
+import { createSelectField } from "@ui/ui_template_input";
 import { guessRows, pageKeepFirst, watchFit } from "@ui/ui_template_pager";
 
 /** 표 칸 위에 오는 도구줄(단추 줄 + 간격) 높이 — 첫 줄 수 어림에만 씀 */
@@ -41,6 +42,29 @@ const NOTE = "비고"; // 끝 열(인력은 준용 앞) · 줄에 없으면 빈
 const ALIAS = "별칭";
 const ALIASED = ["인력.json", "기계.json", MARKET, "재료_유가전력.json"];
 const FALLBACK: Row = { 키: "", 원문번호: "", 이름: "", 규격: "", 단위: "", 값: null, 출처: "" };
+// 자재품목 상하차(830-2 · 요구 828) = 고르기 칸 · 값 셋 = material_merge.LOADS(첫째 = 기본 · 모름)
+const LOAD = "상하차";
+const LOADS = ["-", "상차", "하차"];
+
+/** 상하차 칸 — 고르기(부품 상자) · 노랑(고침) · onPick 없으면 잠금. */
+function loadCell(
+  value: unknown,
+  changed: boolean,
+  onPick?: (value: string) => void,
+): HTMLTableCellElement {
+  const td = el("td");
+  td.classList.toggle("is-changed", changed);
+  const field = createSelectField({
+    options: LOADS.map((v) => ({ value: v, text: v })),
+    value: String(value ?? LOADS[0]),
+    compact: true,
+    disabled: !onPick,
+    ariaLabel: LOAD,
+    onChange: (v) => onPick?.(v),
+  });
+  td.append(field.root);
+  return td;
+}
 
 /** 새 줄 바탕 — 본 줄과 같은 칸 · 글 칸은 "" · 수·값 칸은 null. */
 function blank(sample: Row): Row {
@@ -144,11 +168,12 @@ export function renderRows(
       const tr = el("tr", { className: "is-new" });
       tr.append(actionCell(L("M01_RowRemove"), () => removeAdd(file, i)));
       for (const c of cols) {
+        const onEdit = (text: string): void =>
+          setAdd(file, i, withCell(row, c, coerce(text, flat[c])));
         tr.append(
-          buildCell(show(flat[c]), {
-            changed: true,
-            onEdit: (text) => setAdd(file, i, withCell(row, c, coerce(text, flat[c]))),
-          }),
+          file === MARKET && c === LOAD
+            ? loadCell(flat[c], true, onEdit)
+            : buildCell(show(flat[c]), { changed: true, onEdit }),
         );
       }
       for (const col of aliased ? [ALIAS, NOTE] : [NOTE])
@@ -179,14 +204,15 @@ export function renderRows(
       );
       for (const c of cols) {
         const editable = !deleted && isScalar(orig[c]) && !fixed(file, c);
+        const changed = !same(now[c], orig[c]);
+        const onEdit = editable
+          ? (text: string): void =>
+              editRow(file, d.version, key, row, withCell(cur, c, coerce(text, orig[c])))
+          : undefined;
         tr.append(
-          buildCell(show(now[c]), {
-            changed: !same(now[c], orig[c]),
-            onEdit: editable
-              ? (text) =>
-                  editRow(file, d.version, key, row, withCell(cur, c, coerce(text, orig[c])))
-              : undefined,
-          }),
+          file === MARKET && c === LOAD
+            ? loadCell(now[c], changed, onEdit)
+            : buildCell(show(now[c]), { changed, onEdit }),
         );
       }
       const put = deleted
@@ -224,6 +250,7 @@ export function renderRows(
     const add = createButton({ label: L("M01_RowAdd"), variant: "ghost" });
     add.addEventListener("click", () => {
       const fresh = blank(d.rows[0] ?? FALLBACK);
+      if (file === MARKET) fresh[LOAD] = LOADS[0];
       const col = ["구분", "세부분류"].find((c) => c in fresh);
       addRow(file, d.version, sub && col ? { ...fresh, [col]: sub } : fresh);
     });

M02_MasterTemplete/M02_Elem_Alias.py

@@ -22,7 +22,13 @@ from M01_MasterData import M01_MasterData_Store as m01
 import master_alias as am  # noqa: E402 — M01 store 가 scripts 경로를 넣음
 
 MARKET = "MT"
-PRICES = ("물가자료", "유통물가", "물가정보", "거래가격", "관급")  # 자재 값 칸 다섯
+PRICES = (
+    "물가자료",
+    "유통물가",
+    "물가정보",
+    "거래가격",
+    "일반가격",
+)  # 자재 사급 값 칸 다섯(조달청 뺌)
 BASE_REGION = "서울"
 _CODE = re.compile(r"\bM\d{10}\b")
 LOCAL = "M0000000"  # 공사 직접 번호(파일마다 다른 품목 · 거창 치즐 = 우리 표 Air Hammer) = 코드로 안 이음

M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts

@@ -99,7 +99,7 @@ export interface CalcMaterial {
   코드: string;
   알약?: string | null;
   기준단가: number | null;
-  /** M01 자재품목 값 열 다섯(물가자료 · 유통물가 · 물가정보 · 거래가격 · 관급 · 빈 값 null · 43-3) */
+  /** M01 자재품목 사급 값 열 다섯(물가자료 · 유통물가 · 물가정보 · 거래가격 · 일반가격 · 빈 값 null · 43-3) */
   가격?: Record<string, number | null>;
   /** 기준단가가 된 열 이름 — 없으면 null */
   기준칸?: string | null;

M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts

@@ -570,4 +570,4 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
 }
 
 /** M01 자재품목 값 열 다섯(이름 그대로 · 43-3) — 서버 calc 답 `가격` 열쇠와 같음 */
-export const PRICE_SLOTS = ["물가자료", "유통물가", "물가정보", "거래가격", "관급"] as const;
+export const PRICE_SLOTS = ["물가자료", "유통물가", "물가정보", "거래가격", "일반가격"] as const;

resources/master_data/_갱신절차.md

@@ -36,7 +36,7 @@
 
 - 나라장터 스냅샷에서 마스터 줄을 뽑는 빌더 없음 — 구멍.
 
-## 관급 (자재품목 「관급」 열)
+## 조달청 (자재품목 「조달청」 열)
 
 - 지금 정본에는 적용 안 함 — 요구 822(재료 = EST 그대로).
 

resources/master_data/_키대장.json

@@ -6721,8 +6721,8 @@
     "MT003809": {"원문번호": "M0005253867", "파일": "재료_자재품목.json"},
     "MT003810": {"원문번호": "M0005253868", "파일": "재료_자재품목.json"},
     "MT003811": {"원문번호": "M0005253869", "파일": "재료_자재품목.json"},
-    "MT003813": {"원문번호": "M0005253871", "파일": "재료_자재품목.json"},
     "MT003819": {"원문번호": "M0005253877", "파일": "재료_자재품목.json"},
+    "MT003821": {"원문번호": "M0005253879", "파일": "재료_자재품목.json"},
     "MT003830": {"원문번호": "M0005253888", "파일": "재료_자재품목.json"},
     "MT003846": {"원문번호": "M0005253904", "파일": "재료_자재품목.json"},
     "MT003847": {"원문번호": "M0005253905", "파일": "재료_자재품목.json"},
@@ -11418,11 +11418,6 @@
     "MT010028": {"원문번호": "M0005260086", "파일": "재료_자재품목.json"},
     "MT010029": {"원문번호": "M0005260087", "파일": "재료_자재품목.json"},
     "MT010030": {"원문번호": "M0005260088", "파일": "재료_자재품목.json"},
-    "MT010031": {"원문번호": "M0005260089", "파일": "재료_자재품목.json"},
-    "MT010032": {"원문번호": "M0005260090", "파일": "재료_자재품목.json"},
-    "MT010033": {"원문번호": "M0005260091", "파일": "재료_자재품목.json"},
-    "MT010034": {"원문번호": "M0005260092", "파일": "재료_자재품목.json"},
-    "MT010035": {"원문번호": "M0005260093", "파일": "재료_자재품목.json"},
     "MT010036": {"원문번호": "M0005260094", "파일": "재료_자재품목.json"},
     "MT010037": {"원문번호": "M0005260095", "파일": "재료_자재품목.json"},
     "MT010038": {"원문번호": "M0005260096", "파일": "재료_자재품목.json"},
@@ -21246,53 +21241,6 @@
     "MT023891": {"원문번호": "M0000367671", "파일": "재료_자재품목.json"},
     "MT023892": {"원문번호": "M0000367672", "파일": "재료_자재품목.json"},
     "MT023893": {"원문번호": "M0000367673", "파일": "재료_자재품목.json"},
-    "MT023894": {"원문번호": "M0000019511", "파일": "재료_자재품목.json"},
-    "MT023895": {"원문번호": "M0000019512", "파일": "재료_자재품목.json"},
-    "MT023896": {"원문번호": "M0000019513", "파일": "재료_자재품목.json"},
-    "MT023897": {"원문번호": "M0000019514", "파일": "재료_자재품목.json"},
-    "MT023898": {"원문번호": "M0000019515", "파일": "재료_자재품목.json"},
-    "MT023899": {"원문번호": "M0000019516", "파일": "재료_자재품목.json"},
-    "MT023900": {"원문번호": "M0000019518", "파일": "재료_자재품목.json"},
-    "MT023901": {"원문번호": "M0000019519", "파일": "재료_자재품목.json"},
-    "MT023902": {"원문번호": "M0000019520", "파일": "재료_자재품목.json"},
-    "MT023903": {"원문번호": "M0000019521", "파일": "재료_자재품목.json"},
-    "MT023904": {"원문번호": "M0000019522", "파일": "재료_자재품목.json"},
-    "MT023905": {"원문번호": "M0000019524", "파일": "재료_자재품목.json"},
-    "MT023906": {"원문번호": "M0000019525", "파일": "재료_자재품목.json"},
-    "MT023907": {"원문번호": "M0000019526", "파일": "재료_자재품목.json"},
-    "MT023908": {"원문번호": "M0000019527", "파일": "재료_자재품목.json"},
-    "MT023909": {"원문번호": "M0000019530", "파일": "재료_자재품목.json"},
-    "MT023910": {"원문번호": "M0000019532", "파일": "재료_자재품목.json"},
-    "MT023911": {"원문번호": "M0000019534", "파일": "재료_자재품목.json"},
-    "MT023912": {"원문번호": "M0000019536", "파일": "재료_자재품목.json"},
-    "MT023913": {"원문번호": "M0000019537", "파일": "재료_자재품목.json"},
-    "MT023914": {"원문번호": "M0000019538", "파일": "재료_자재품목.json"},
-    "MT023915": {"원문번호": "M0000019539", "파일": "재료_자재품목.json"},
-    "MT023916": {"원문번호": "M0000019540", "파일": "재료_자재품목.json"},
-    "MT023917": {"원문번호": "M0000019541", "파일": "재료_자재품목.json"},
-    "MT023918": {"원문번호": "M0000019542", "파일": "재료_자재품목.json"},
-    "MT023919": {"원문번호": "M0000019543", "파일": "재료_자재품목.json"},
-    "MT023920": {"원문번호": "M0000019545", "파일": "재료_자재품목.json"},
-    "MT023921": {"원문번호": "M0000019546", "파일": "재료_자재품목.json"},
-    "MT023922": {"원문번호": "M0000019547", "파일": "재료_자재품목.json"},
-    "MT023923": {"원문번호": "M0000019548", "파일": "재료_자재품목.json"},
-    "MT023924": {"원문번호": "M0000019550", "파일": "재료_자재품목.json"},
-    "MT023925": {"원문번호": "M0000019551", "파일": "재료_자재품목.json"},
-    "MT023926": {"원문번호": "M0000019552", "파일": "재료_자재품목.json"},
-    "MT023927": {"원문번호": "M0000019557", "파일": "재료_자재품목.json"},
-    "MT023928": {"원문번호": "M0000019559", "파일": "재료_자재품목.json"},
-    "MT023929": {"원문번호": "M0000019560", "파일": "재료_자재품목.json"},
-    "MT023930": {"원문번호": "M0000019561", "파일": "재료_자재품목.json"},
-    "MT023931": {"원문번호": "M0003609657", "파일": "재료_자재품목.json"},
-    "MT023932": {"원문번호": "M0000019565", "파일": "재료_자재품목.json"},
-    "MT023942": {"원문번호": "M0000019576", "파일": "재료_자재품목.json"},
-    "MT023943": {"원문번호": "M0000019577", "파일": "재료_자재품목.json"},
-    "MT023944": {"원문번호": "M0000019578", "파일": "재료_자재품목.json"},
-    "MT023945": {"원문번호": "M0000019579", "파일": "재료_자재품목.json"},
-    "MT023950": {"원문번호": "M0000019584", "파일": "재료_자재품목.json"},
-    "MT023951": {"원문번호": "M0000019585", "파일": "재료_자재품목.json"},
-    "MT023952": {"원문번호": "M0000019586", "파일": "재료_자재품목.json"},
-    "MT023953": {"원문번호": "M0000019587", "파일": "재료_자재품목.json"},
     "MT023954": {"원문번호": "M0001437047", "파일": "재료_자재품목.json"},
     "MT023955": {"원문번호": "M0005250020", "파일": "재료_자재품목.json"},
     "MT023956": {"원문번호": "M0000000005", "파일": "재료_자재품목.json"},

resources/master_data/_틀.md

@@ -109,12 +109,14 @@
 
 **마스터는 값을 고르는 곳이 아니라 프로젝트에 쓸 데이터를 모으는 곳** — 최저가·견적 고르기는 프로젝트 몫.
 
-- `재료_자재품목` = 자재 테이블 하나 · **열 한 벌** — 키 · 구분 · 상세구분 · 이름 · 규격 · 단위 · 물가자료 · 유통물가 · 물가정보 · 거래가격 · 상하차 · 관급 · 출처 · 비고 · 면수 · 모든 줄이 모든 칸(없으면 `null`).
-- 값 열 다섯 = 물가지 넷(물가자료 · 유통물가 · 물가정보 · 거래가격) · `관급` — 채택값·기본가·견적가 두지 않음.
-- `관급` = 자리만 둠 · 값 없음(원문 「가격정보」 값은 넣지 않음).
-- `상하차` = 상차 · 하차 · `-`(기본 · 모름) 가운데 하나 · 값이 아닌 표지 · 자리 = `관급` 바로 앞(`scripts/material_merge.py` `LOAD_AT`) · 이름 · 규격의 인도 조건 글(도착도 = 하차 · 채취장상차 · 하치장 상차도 = 상차)은 이 칸으로.
-- 항목 통합 = 지역 · 관급/사급 · 제조사 · 조합 · 상하차 덧정보를 뗀 이름 · 규격 · 단위 · 상하차가 같은 줄은 한 줄(`scripts/material_merge.py`) · 뗀 말은 `비고` 「통합: …」.
-- 그 밖의 줄에 남은 「가격정보」 값은 출처가 조달인지 물가지인지 원문이 안 가름 — 어느 값 열에도 넣지 않고 `비고` 「가격정보 1,485 · 2026.7」 로만(67 줄).
+- `재료_자재품목` = 자재 테이블 하나 · **열 한 벌** — 키 · 구분 · 상세구분 · 이름 · 규격 · 단위 · 상하차 · 조달청 · 물가자료 · 유통물가 · 물가정보 · 거래가격 · 일반가격 · 출처 · 비고 · 면수 · 모든 줄이 모든 칸(없으면 `null`) · 차례 = `scripts/material_merge.py` `COLUMNS`.
+- 값 열 여섯 = `조달청`(관급) · 물가지 넷(물가자료 · 유통물가 · 물가정보 · 거래가격) · `일반가격`(사급) — 채택값·기본가·견적가 두지 않음.
+- `조달청` = 자리만 둠 · 값 없음(원문 「가격정보」 값은 넣지 않음) · 가장 낮은 값 고르기에 넣지 않음.
+- `일반가격` = 시스템 관리자가 M01 에서 손으로 넣는 칸 · 빌더가 지금 정본 값을 이어 받음.
+- 가장 낮은 값 = 사급 칸(물가지 넷 + 일반가격) 가운데 · `scripts/master_material.py` `SLOTS`.
+- `상하차` = 상차 · 하차 · `-`(기본 · 모름) 가운데 하나 · 값이 아닌 표지 · 자리 = 단위 바로 뒤 · 이름 · 규격의 인도 조건 글(도착도 · 하차도 = 하차 · 채취장상차 · 하치장 상차도 = 상차)은 이 칸으로.
+- 항목 통합 = 지역 · 관급/사급 · 제조사 · 조합 · 상하차 덧정보를 뗀 이름 · 규격 · 단위 · 상하차가 같은 줄은 한 줄(`scripts/material_merge.py`) · 남는 줄 = 전국 › 서울 › 경기 › 그 밖(값 중간) · 뗀 말 · 기준 지역은 `비고` 「통합: …」.
+- 재료 아닌 줄은 두지 않음 — 품질시험 수수료 · 일반 도로용 블록.
 - `구분` · `상세구분` = 원문(ESTX)에 대·중분류 칸이 없어 품명 글자 규칙으로 채움(`scripts/build_자재품목_분류.py`) · 묶음 목록은 `ref/_묶음_자재품목.md` · 못 가른 줄은 「미분류」.
 - `면수` = 물가지 값의 원문 면수 묶음 `{ 물가자료, 유통물가, 물가정보, 거래가격 }` · 없으면 `null` · 화면에는 접어 둠.
 - **원문번호 칸 없음** — 원문(ESTX)이 준 품번 `M0005250505` 는 남의 번호라 이름 몫을 못 함 · 대조는 `_키대장.json` 에만 둠(조달청에서 새로 더한 줄의 조달청 번호도 같음). 로직·연결은 키로 적음.

resources/master_data/ref/_묶음_자재품목.md

@@ -2,7 +2,7 @@
 
 `scripts/build_자재품목_분류.py` 가 만든 표 — 손으로 고치지 않음.
 
-- 구분 24 · 상세구분 91 · 미분류 25 줄 (전체 17744 줄)
+- 구분 24 · 상세구분 91 · 미분류 25 줄 (전체 17692 줄)
 
 ## 규칙
 
@@ -38,14 +38,14 @@ PE관 1141 · 이음쇠·부속 1003 · 주철관 794 · 강관 706 · 파형강
 
 밸브 575 · 수도계량기·유량계 101 · 스프링클러·호스 51 · 펌프 34
 
-### 운송·용역 (664)
-
-화물운임 552 · 폐기물 61 · 시험·검사 49 · 상하차 2
-
 ### 기계·설비 (627)
 
 기계류 267 · 보일러·공조 173 · 놀이·운동·시설물 109 · 측정·시험기기 68 · 소방·가스 10
 
+### 운송·용역 (617)
+
+화물운임 552 · 폐기물 61 · 시험·검사 2 · 상하차 2
+
 ### 도료·방수·접착 (572)
 
 도료 258 · 접착·혼화 174 · 방수·실링 140
@@ -54,9 +54,9 @@ PE관 1141 · 이음쇠·부속 1003 · 주철관 794 · 강관 706 · 파형강
 
 그레이팅 169 · 수로관 161 · 맨홀 151
 
-### 콘크리트제품 (478)
+### 콘크리트제품 (474)
 
-말뚝·파일 223 · 경계석·블록 156 · PC구조물 99
+말뚝·파일 223 · 경계석·블록 152 · PC구조물 99
 
 ### 건축마감 (454)
 
@@ -82,9 +82,9 @@ PE관 1141 · 이음쇠·부속 1003 · 주철관 794 · 강관 706 · 파형강
 
 부직포·토목섬유 113 · 돌망태·사방 61 · 매트 54
 
-### 시멘트·골재 (219)
+### 시멘트·골재 (218)
 
-모르타르 141 · 골재 55 · 시멘트 23
+모르타르 140 · 골재 55 · 시멘트 23
 
 ### 석재 (207)
 

resources/master_data/scripts/build_재료_자재품목.py

@@ -1,9 +1,11 @@
 """상용 적산 자료(ESTX 2026-07) 자재 → 재료_자재품목.json — 개발용 · 배포 전 판권 구매 뒤 갱신.
 
 ESTX 자재 표 = StuffcDat(칸 뜻: 다산소프트/ESTX_값사전_자재노무기계.md).
-열 한 벌 = 키 · 원문번호 · 구분 · 상세구분 · 이름 · 규격 · 단위 · 물가자료 · 유통물가 · 물가정보 · 거래가격 · 상하차 · 관급 · 출처 · 비고 · 면수.
+열 한 벌 = material_merge.COLUMNS(키 · 구분 · 상세구분 · 이름 · 규격 · 단위 · 상하차 · 조달청 · 물가자료 · 유통물가 · 물가정보 · 거래가격 · 일반가격 · 출처 · 비고 · 면수).
 Cost2..5 = 물가지 넷 · Page2..5 = 면수. TC(채택) · Cost6(견적가)는 마스터 아님 — 뺌.
-Cost1(가격정보 = 관급 정보)은 넣지 않음 — 「관급」 열은 자리만 두고 비움(요구 827) · 비고에도 안 적음.
+Cost1(가격정보 = 관급 정보)은 넣지 않음 — 「조달청」 열은 자리만 두고 비움(요구 827 · 830) · 비고에도 안 적음.
+「일반가격」 = 시스템 관리자가 M01 에서 넣는 칸 — 지금 정본 값을 원문번호로 이어 받음(다시 지어도 안 사라짐).
+Cost1 출처 표기로 가린 재료 아닌 줄은 뺌(요구 832) — 「2026(경북)」 품질시험 수수료 · 「~26.10.16」 일반 도로용 블록.
 항목 통합(요구 819 · 827) = material_merge — 지역 · 관급/사급 · 제조사 · 조합 덧정보를 뗀 이름 · 규격 · 단위가 같은 줄을 한 줄로.
 0 · 미저장 = 값 없음(null). 이름·규격은 원문 그대로(띄어쓰기·오자 포함). 코드 없는 빈 줄은 뺌.
 ESTX 에 대·중분류 칸이 없어 구분·상세구분은 build_자재품목_분류.py 가 품명 글자 규칙으로 채움(빌더 끝에서 부름).
@@ -40,6 +42,8 @@ DROP = {
     "M0005250065": "전력(주택용저압)",
 }
 CARRY = "품셈재료"  # 출처 머리 — ESTX 밖 줄(7-4b)
+# 뺄 줄 — 관급 아닌 줄의 Cost1 출처 표기(Page1) → 까닭(요구 832)
+NOT_MATERIAL = {"2026(경북)": "품질시험 수수료", "~26.10.16": "일반 도로용 블록"}
 # 7-4b 덧말 — VR관 1본 길이(D300~D1200 · 이름 「VR관」 · 「VR관(관급)」)
 VR_NOTE = "1본 = 2.5m(표준 유효길이 D300~D1200 공통 — PLAN 7-4b 확인 · 출처: https://kr-con.co.kr/product/index.asp?pIdx=product3)"
 VR_SIZES = {f"D={d}mm" for d in (300, 400, 450, 500, 600, 700, 800, 900, 1000, 1100, 1200)}
@@ -51,11 +55,28 @@ def num(v):
     return int(v) if float(v).is_integer() else v
 
 
-def build(rows: list[dict]) -> list[dict]:
+def dropped(r: dict) -> str | None:
+    """재료 아닌 줄 까닭 — 관급 아닌 줄의 가격정보 출처 표기로 가림(요구 832)."""
+    if r.get("Cost1") and "관급" not in r.get("Name", ""):
+        return NOT_MATERIAL.get(r.get("Page1"))
+    return None
+
+
+def own_prices() -> dict[str, object]:
+    """지금 정본의 일반가격(손 입력) — 원문번호 → 값."""
+    if not OUT.is_file():
+        return {}
+    book = mk.load_book()["키"]
+    rows = json.loads(OUT.read_text(encoding="utf-8"))["줄"]
+    return {book[r["키"]]["원문번호"]: r[mm.OWN] for r in rows if r.get(mm.OWN) is not None}
+
+
+def build(rows: list[dict], own: dict | None = None) -> list[dict]:
+    own = own or {}
     out = []
     for r in sorted(rows, key=lambda r: r["Index"]):
         code = r.get("Code")
-        if not code or code in DROP:
+        if not code or code in DROP or dropped(r):
             continue
         면수 = {slot: r.get(f"Page{i}") or None for i, slot in enumerate(MARKET, 2)}
         비고 = None
@@ -69,8 +90,10 @@ def build(rows: list[dict]) -> list[dict]:
                 "이름": r.get("Name", ""),
                 "규격": r.get("Size", ""),
                 "단위": r.get("Unite", ""),
+                mm.LOAD: mm.LOADS[0],
+                mm.GOVT: None,
                 **{slot: num(r.get(f"Cost{i}")) for i, slot in enumerate(MARKET, 2)},
-                "관급": None,
+                mm.OWN: own.get(code),
                 "출처": f"자재품목 {code}",
                 "비고": 비고,
                 "면수": 면수 if any(면수.values()) else None,
@@ -104,25 +127,28 @@ def prune() -> int:
 
 
 def check(rows: list[dict], gone: int) -> None:
-    """원본 대조 — 줄 수(원본 − 통합으로 지운 줄) · 남는 줄 전부 물가지 넷 · 면수가 원본 그 줄 것 · 관급 칸 빔."""
+    """원본 대조 — 줄 수(원본 − 재료 아닌 줄 − 통합으로 지운 줄) · 남는 줄 전부 물가지 넷 · 면수가 원본 그 줄 것 · 조달청 칸 빔."""
     data = json.loads(OUT.read_text(encoding="utf-8"))
     raw = {r["Code"]: r for r in rows if r.get("Code") and r["Code"] not in DROP}
+    out = sum(1 for r in raw.values() if dropped(r))
     got = [r for r in data["줄"] if not str(r["출처"]).startswith(CARRY)]
-    assert len(got) == len(raw) - gone, (len(got), len(raw), gone)
+    assert len(got) == len(raw) - out - gone, (len(got), len(raw), out, gone)
     print(
-        f"줄 {len(got)} = 원본 코드 있는 줄 {len(raw)} − 통합으로 지운 줄 {gone} (유류 {len(DROP)} 뺌)"
+        f"줄 {len(got)} = 원본 코드 있는 줄 {len(raw)} − 재료 아닌 줄 {out} − 통합으로 지운 줄 {gone}"
+        f" (유류 {len(DROP)} 뺌)"
     )
     for g in got:
         r = raw[g["출처"].removeprefix("자재품목 ")]
         for i, slot in enumerate(MARKET, 2):
             assert (g[slot] or 0) == (r.get(f"Cost{i}") or 0), (g["출처"], slot)
             assert (g["면수"] or {}).get(slot) == (r.get(f"Page{i}") or None), (g["출처"], slot)
-    assert all(r["관급"] is None for r in data["줄"])
+    assert all(r[mm.GOVT] is None for r in data["줄"])
+    assert all(tuple(r)[1:] == mm.COLUMNS[1:] for r in data["줄"])  # 첫 칸 = 열쇠(adopt 전)
     assert all(r[mm.LOAD] in mm.LOADS for r in data["줄"])
     for i, slot in enumerate(MARKET, 2):
         n = sum(1 for r in got if r[slot] is not None)
         print(f"  {slot}: 값 {n}줄 · 합 {math.fsum(r[slot] or 0 for r in got):,.1f}")
-    print("  남는 줄 전부 물가지 넷 · 면수 = 원본 그 줄 · 관급 칸 빔")
+    print("  남는 줄 전부 물가지 넷 · 면수 = 원본 그 줄 · 조달청 칸 빔 · 열 한 벌")
     load = {v: sum(1 for r in data["줄"] if r[mm.LOAD] == v) for v in mm.LOADS}
     print(f"  {mm.LOAD}:", " · ".join(f"{k} {n}" for k, n in load.items()))
 
@@ -142,12 +168,13 @@ def main():
         ],
         "비고": [
             "다산소프트 EST 2026-07 자재 · 개발용 · 배포 전 판권 구매",
-            "값 열 다섯 = 물가지 넷(물가자료 · 유통물가 · 물가정보 · 거래가격) · 관급 — 채택값·기본가 없음 · 쓰는 곳이 값을 고르고 출처를 밝힘",
+            "값 열 여섯 = 조달청(관급) · 물가지 넷(물가자료 · 유통물가 · 물가정보 · 거래가격) · 일반가격(시스템 관리자 손 입력) — 채택값·기본가·견적가 없음 · 가장 낮은 값 고르기는 조달청 칸을 안 봄",
             "유류·전력은 뺌 — 유가·전기요금은 재료_유가전력(유류는 값이 비고 글뿐 · 중유는 받지 않음)",
             "원문번호(다산소프트 품번) 칸 없음 — 대조는 _키대장.json 에만",
-            "관급 칸 = 자리만 둠 · 값 없음 — 원문 「가격정보」(관급 정보) 값은 넣지 않음(요구 827)",
-            "상하차 = 상차 · 하차 · -(기본 · 모름) — 이름 · 규격의 인도 조건 글(도착도 = 하차 · 채취장상차 · 하치장 상차도 = 상차)을 떼어 이 칸으로(요구 828) · 값이 아닌 표지",
-            "항목 통합 = 지역 · 관급/사급 · 제조사 · 조합 덧정보를 뗀 이름 · 규격 · 단위가 같은 줄을 한 줄로(전국 › 서울 › 값 중간 지역) · 뗀 말은 비고 「통합: …」 (scripts/material_merge.py · 요구 819 · 827)",
+            "조달청 칸 = 자리만 둠 · 값 없음 — 원문 「가격정보」(관급 정보) 값은 넣지 않음(요구 827 · 830)",
+            "상하차 = 상차 · 하차 · -(기본 · 모름) · 단위 바로 뒤 — 이름 · 규격의 인도 조건 글(도착도 · 하차도 = 하차 · 채취장상차 · 하치장 상차도 = 상차)을 떼어 이 칸으로(요구 828 · 831) · 값이 아닌 표지",
+            "항목 통합 = 지역 · 관급/사급 · 제조사 · 조합 덧정보를 뗀 이름 · 규격 · 단위가 같은 줄을 한 줄로(전국 › 서울 › 경기 › 그 밖 지역 값 중간) · 뗀 말은 비고 「통합: …」 (scripts/material_merge.py · 요구 819 · 827 · 831)",
+            "재료 아닌 줄은 뺌 — 품질시험 수수료(가격정보 출처 「2026(경북)」) · 일반 도로용 블록(「~26.10.16」)(요구 832)",
             "조달청 줄 · 조달청 관급 값은 넣지 않음 — EST 그대로(요구 822)",
             "품셈재료에서 옮긴 줄(출처 「품셈재료 …」 · 값 없음)은 ESTX 밖 — 지금 정본에서 이어 받음",
             "구분 · 상세구분 = 품명 글자 규칙으로 채움(scripts/build_자재품목_분류.py · 묶음 목록 ref/_묶음_자재품목.md) · 조달청 줄은 조달청 품명을 따름 · 못 가린 줄은 「미분류」",
@@ -155,7 +182,7 @@ def main():
         ],
     }
     extra = carried()
-    merged, log = mm.merge(build(rows) + extra)  # 원문 차례 = 키 차례
+    merged, log = mm.merge(build(rows, own_prices()) + extra)  # 원문 차례 = 키 차례
     dump_master(OUT, head, merged)
     check(rows, sum(1 for x in log for o in x["지운"] if not str(o["출처"]).startswith(CARRY)))
     print("항목 통합 묶음", len(log), "· 지운 줄", sum(len(x["지운"]) for x in log))

resources/master_data/scripts/build_품셈재료_고르기.py

@@ -69,8 +69,18 @@ OVERRIDE = {
 NO_GROUP = "자재품목 묶음에 짝이 없음 — 관리자가 화면에서 이음"
 NO_ROW = "자재품목에 그 묶음 줄이 없음"
 NO_UNIT = "자재품목 그 묶음에 같은 단위·이름 줄이 없음"
-UNIT = {"㎏": "kg", "톤": "ton", "Ton": "ton", "M": "m", "m²": "㎡", "L": "ℓ", "EA": "개", "set": "SET", "Set": "SET"}
-PRICE = ("물가자료", "유통물가", "물가정보", "거래가격", "관급")
+UNIT = {
+    "㎏": "kg",
+    "톤": "ton",
+    "Ton": "ton",
+    "M": "m",
+    "m²": "㎡",
+    "L": "ℓ",
+    "EA": "개",
+    "set": "SET",
+    "Set": "SET",
+}
+PRICE = ("물가자료", "유통물가", "물가정보", "거래가격", "일반가격")
 NOTE = re.compile(r"\s*·?\s*고르기 없음\([^)]*\)")
 FIELD = re.compile(r'("연결": (?:null|"[^"]*"|\{[^{}]*\}))(, "고르기": (?:null|\{[^{}]*\}))?')
 NOTE_FIELD = re.compile(r'(, "비고": )(null|"(?:[^"\\]|\\.)*")')
@@ -115,7 +125,9 @@ def 고르기(row: dict, market: list[dict]) -> tuple[dict | None, str]:
         got = _단위(row, cond, narrow, market)
         if got[0]:
             return got
-        cond = {k: v for k, v in cond.items() if k != "규격"}  # 규격까지 좁히면 단위 맞는 줄이 없음 — 규격 없이 다시
+        cond = {
+            k: v for k, v in cond.items() if k != "규격"
+        }  # 규격까지 좁히면 단위 맞는 줄이 없음 — 규격 없이 다시
     return _단위(row, cond, hits, market)
 
 
@@ -133,7 +145,9 @@ def _단위(row: dict, cond: dict, hits: list[dict], market: list[dict]) -> tupl
     if u(first["단위"]) == want:
         return cond, ""
     root = re.sub(r"\s+", "", re.split(r"[(,\-]", str(row["이름"]))[0])
-    same = [r for r in hits if u(r["단위"]) == want and val(r) and root in re.sub(r"\s+", "", r["이름"])]
+    same = [
+        r for r in hits if u(r["단위"]) == want and val(r) and root in re.sub(r"\s+", "", r["이름"])
+    ]
     if not same:
         return None, NO_UNIT
     best = min(same, key=lambda r: (min(val(r)), r["키"]))

resources/master_data/scripts/check_master.py

@@ -120,30 +120,7 @@ LABOR_STATUS = ("공표", "산정", "미공표", "미확보", "추정")
 # 원문별 열 한 벌 — 모든 줄이 이 칸을 이 차례로 가짐(없으면 null)
 COLS = {
     # 자재품목 — 원문번호(남의 품번)는 줄에 두지 않음 · 대조는 `_키대장.json` 에만
-    # 상하차 칸 자리 = material_merge.LOAD_AT 바로 앞(한 곳)
-    "자재품목": tuple(
-        mm.place(
-            dict.fromkeys(
-                (
-                    "키",
-                    "구분",
-                    "상세구분",
-                    "이름",
-                    "규격",
-                    "단위",
-                    "물가자료",
-                    "유통물가",
-                    "물가정보",
-                    "거래가격",
-                    "관급",
-                    "출처",
-                    "비고",
-                    "면수",
-                )
-            ),
-            None,
-        )
-    ),
+    "자재품목": mm.COLUMNS,  # 열 한 벌 · 차례 = material_merge 한 곳
     "유가전력": (
         "키",
         "원문번호",

resources/master_data/scripts/check_값없는줄.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """재료_자재품목.json 다섯 값 칸이 모두 빈 줄 가운데 로직이 실제로 가리키는 줄 — 읽기 전용 분석.
 
-  · 「빈 줄」 = 물가자료·유통물가·물가정보·거래가격·관급 다섯 칸이 모두 없음
+  · 「빈 줄」 = 조달청·물가자료·유통물가·물가정보·거래가격·일반가격 여섯 칸이 모두 없음
   · 「로직이 가리킴」 = 로직 호표 요소가 그 키를 바로 적음 · 재료 고르기 조건(구분·상세구분·규격)의
     후보 줄 · 대표 줄로 콕 집음 · 품셈재료 연결(문자열 키 · 지역 조건)을 따라간 줄
   · 지역 조건(모래·자갈 등)은 실제 프로젝트 자재지역을 모르므로 지역을 안 가리고 이름·단위만 맞춤
@@ -24,7 +24,7 @@ sys.path.insert(0, str(HERE))
 import check_master as cm  # noqa: E402
 import master_material as mm  # noqa: E402
 
-PRICE = ("물가자료", "유통물가", "물가정보", "거래가격", "관급")
+PRICE = (*mm.SLOTS, mm.GOVT)
 
 # 두 ref 표의 키 목록 — 로직이 지금도 부르는지 다시 잣대질할 때 씀 (`_관리자값_미확보.md`·`_없는_재료.md`)
 ADMIN_KEYS = (

resources/master_data/scripts/master_material.py

@@ -17,7 +17,14 @@ import master_unit as mu
 LINKED = "MP"  # 품셈재료 테이블ID
 MARKET = "MT"  # 자재품목 테이블ID
 PRICED = "MO"  # 유가전력 테이블ID — 값 한 칸
-SLOTS = ("물가자료", "유통물가", "물가정보", "거래가격", "관급")  # 자재품목 값 열
+SLOTS = (
+    "물가자료",
+    "유통물가",
+    "물가정보",
+    "거래가격",
+    "일반가격",
+)  # 사급 값 열 — 가장 낮은 값 고르기 몫
+GOVT = "조달청"  # 관급 값 열 — 가장 낮은 값 고르기에 안 넣음(요구 826 · 830)
 PICK_KEYS = (
     "구분",
     "상세구분",

resources/master_data/scripts/material_merge.py

@@ -1,18 +1,21 @@
-"""재료 자재품목 항목 통합(요구 819 · 827 · 828 · PLAN 830-2) — build_재료_자재품목 이 부름.
+"""재료 자재품목 항목 통합(요구 819 · 827 · 828 · 830 ~ 832 · PLAN 830-2) — build_재료_자재품목 이 부름.
 시험 = test_830_2_material_merge.
 
 묶음 = 이름에서 지역 · 관급/사급 꼬리표 · 제조사 꼬리(「-거양」) · 조합 이름 · 상하차 글을 뺀
   이름 · 규격 · 단위 · 상하차가 같은 줄.
   규격 = 앞말 「조합공통품목,」 · 규격 속 지역 괄호 뗌
   단위 = M=m · m²=㎡ · Ton=톤 · ㎏=kg 표기 하나로 · 비교는 공백을 뺀 글
-상하차 칸(요구 828) = 상차 · 하차 · -(기본 · 모름) — 이름 · 규격의 인도 조건 글을 떼어 이 칸으로
-  「도착도」 = 하차 · 「채취장상차(도)」 · 「하치장 · 생산공장 상차도」 · 「(상차도)」 = 상차
-남는 줄 = 사급(관급 아닌) 줄 가운데 전국 › 지역 글 없음(전국으로 봄 · 브) › 서울 › 서울 권역 글
-  › 값이 중간인 지역 줄(브 · 짝수면 아래 중간)
+열 한 벌 = COLUMNS — 상하차 = 단위 바로 뒤 · 가격 열 = 조달청(관급) · 물가지 넷 · 일반가격(사급).
+상하차 칸(요구 828 · 831) = 상차 · 하차 · -(기본 · 모름) — 이름 · 규격의 인도 조건 글을 떼어 이 칸으로
+  「도착도」 · 「하차도」 = 하차 · 「채취장상차(도)」 · 「하치장 · 생산공장 상차도」 · 「(상차도)」 = 상차
+남는 줄 = 사급(관급 아닌) 줄 가운데 전국 › 지역 글 없음(전국으로 봄) › 서울 › 서울 권역 글 › 경기
+  › 그 밖 지역(요구 830 · 831 — 조달청과 같은 차례) · 같은 차례 여럿(경기 · 그 밖)이면 값이 중간인 줄
+  (짝수면 아래 중간 · 다시 지어도 같은 줄)
   · 남길 줄의 값 칸이 전부 비고 다른 줄에 값이 있으면 다음 차례 줄(브)
   · 관급 줄만 있는 묶음 = 가장 작은 키 한 줄(브) · 나머지 줄은 지움(이력 안 남김)
 덧정보가 하나도 없는 묶음(원래부터 겹친 줄 — 식생 · 종자 등)은 합치지 않음.
-관급 칸 값은 모두 비움(EST 「가격정보」 — 요구 827) · 이름에서 뗀 말은 비고 「통합: …」 로.
+조달청 칸 값은 모두 비움(EST 「가격정보」 — 요구 827 · 831) · 일반가격 = 시스템 관리자가 넣는 칸(빌더가 이어 받음).
+이름에서 뗀 말은 비고 「통합: …」 로.
 """
 
 import re
@@ -20,7 +23,24 @@ import re
 MARKET = ("물가자료", "유통물가", "물가정보", "거래가격")
 LOAD = "상하차"  # 표지 칸(값 칸 아님)
 LOADS = ("-", "상차", "하차")  # 첫째 = 기본(모름)
-LOAD_AT = "관급"  # 상하차 칸 자리 = 이 칸 바로 앞 — 자리는 여기 한 곳
+GOVT = "조달청"  # 관급 가격 칸 — 가장 낮은 값 고르기에 안 넣음(요구 826 · 830)
+OWN = "일반가격"  # 시스템 관리자 손 입력 칸(사급)
+COLUMNS = (  # 열 한 벌 · 차례(요구 830 · 831)
+    "키",
+    "구분",
+    "상세구분",
+    "이름",
+    "규격",
+    "단위",
+    LOAD,
+    GOVT,
+    *MARKET,
+    OWN,
+    "출처",
+    "비고",
+    "면수",
+)
+GYEONGGI = {"경기", "수원", "용인", "포천", "가평", "여주", "화성"}
 CITY = set(
     """서울 부산 대구 인천 광주 대전 울산 세종 제주 청주 전주 포항 창원 춘천 충주 강릉
     천안 원주 여수 구미 순천 수원 목포 금산 영천 논산 삼척 홍성 익산 청도 양양 남원
@@ -40,7 +60,7 @@ SUPPLY = (  # (꼬리표 글, 공급) — 이름 끝 · 괄호 꼴
     (r"-사급$", "사급"),
     (r",사급$", "사급"),
 )
-NAME_LOAD = re.compile(r",\s*(도착도|채취장상차도|채취장상차)$")  # 모 래, 서울, 도착도
+NAME_LOAD = re.compile(r",\s*(도착도|하차도|채취장상차도|채취장상차)$")  # 모 래, 서울, 도착도
 SPEC_LOAD = re.compile(
     r"\s*(?:\((상차도)\)|((?:하치장|생산공장)\s*상차도))$"
 )  # HD=10mm 하치장 상차도
@@ -48,19 +68,16 @@ COOP = re.compile(r"^조합공통품목(?:\(([^)]*)\))?,?\s*")
 
 
 def load_of(text: str) -> str:
-    """인도 조건 글 → 상하차 값 — 도착 = 하차 · 상차 = 상차."""
-    return "하차" if text.startswith("도착") else "상차"
+    """인도 조건 글 → 상하차 값 — 도착 · 하차 = 하차 · 상차 = 상차."""
+    return "하차" if text.startswith(("도착", "하차")) else "상차"
 
 
 def place(row: dict, load: str) -> dict:
-    """상하차 칸을 LOAD_AT 바로 앞에 둔 줄."""
-    out = {}
-    for k, v in row.items():
-        if k == LOAD:
-            continue
-        if k == LOAD_AT:
-            out[LOAD] = load
-        out[k] = v
+    """COLUMNS 차례의 줄 — 첫 칸(열쇠 · 키)은 그대로 · 상하차 = load · 조달청 = 빔 · 옛 칸(관급)은 뺌."""
+    first = next(iter(row))
+    out = {first: row[first]}
+    for c in COLUMNS[1:]:
+        out[c] = load if c == LOAD else None if c == GOVT else row.get(c)
     return out
 
 
@@ -163,6 +180,9 @@ def price(row: dict):
     return min(v) if v else None
 
 
+RANKS = ("전국", "지역 없음", "서울", "서울 권역", "경기", "그 밖")
+
+
 def _rank(region: str) -> int:
     if region == "전국":
         return 0
@@ -172,25 +192,30 @@ def _rank(region: str) -> int:
         return 2
     if region.startswith("서울"):
         return 3
-    return 4
+    if region in GYEONGGI or region.startswith("경기"):
+        return 4
+    return 5
+
+
+def _middle(pool: list) -> list:
+    """값이 중간인 줄부터 가까운 차례(짝수면 아래 중간 · 값 빈 줄은 끝) — 다시 지어도 같은 차례."""
+    pool = sorted(pool, key=lambda p: (price(p[0]) is None, price(p[0]) or 0))
+    mid = max((sum(1 for p in pool if price(p[0]) is not None) - 1) // 2, 0)
+    return sorted(pool, key=lambda p: (abs(pool.index(p) - mid), pool.index(p)))
 
 
 def _order(pool: list) -> list:
-    """남길 차례 — 전국 › 지역 없음 › 서울 › 서울 권역 › 값이 중간인 지역 줄부터 가까운 차례 · 같으면 앞 줄(작은 키)."""
-    top = sorted(
-        (p for p in pool if p[1]["지역"] and _rank(p[1]["지역"]) == 4),
-        key=lambda p: (price(p[0]) is None, price(p[0]) or 0),
-    )
-    if top:
-        mid = (sum(1 for p in top if price(p[0]) is not None) - 1) // 2
-        mid = max(mid, 0)
-        top = sorted(top, key=lambda p: (abs(top.index(p) - mid), top.index(p)))
-    rest = sorted((p for p in pool if _rank(p[1]["지역"]) < 4), key=lambda p: _rank(p[1]["지역"]))
-    return rest + top
+    """남길 차례 — 전국 › 지역 없음 › 서울 › 서울 권역 › 경기 › 그 밖 · 경기 · 그 밖은 값 중간부터 ·
+    그 위 차례는 앞 줄(작은 키)부터."""
+    out = []
+    for rank in range(len(RANKS)):
+        same = [p for p in pool if _rank(p[1]["지역"]) == rank]
+        out += _middle(same) if rank >= 4 else same
+    return out
 
 
 def merge(rows: list[dict]) -> tuple[list[dict], list[dict]]:
-    """통합한 줄(관급 칸 비움) · 기록(덧정보를 뗀 묶음마다 남은 줄 · 지운 줄 · 기준 지역 · 「브」 규칙).
+    """통합한 줄(조달청 칸 비움 · COLUMNS 차례) · 기록(덧정보를 뗀 묶음마다 남은 줄 · 지운 줄 · 기준 지역 · 「브」 규칙).
     줄 차례 = 키 차례(빌더가 원문 차례로 짓고 대장 키도 그 차례) — 같은 순위 · 관급만 묶음은 앞 줄을 남김."""
     groups: dict = {}
     for r in rows:
@@ -208,8 +233,10 @@ def merge(rows: list[dict]) -> tuple[list[dict], list[dict]]:
             region = best[1]["지역"]
             if _rank(region) == 1 and len(g) > 1:
                 rules.append("지역 없음 = 전국")
-            if _rank(region) == 4 and len({x[1]["지역"] for x in sup}) > 1:
-                rules.append("값 중간 지역")
+            if _rank(region) >= 4:
+                rules.append(RANKS[_rank(region)])
+                if sum(1 for x in sup if _rank(x[1]["지역"]) == _rank(region)) > 1:
+                    rules.append("값 중간 지역")
             if best is not order[0]:
                 rules.append("값 빈 줄 건너뜀")
         else:
@@ -219,7 +246,7 @@ def merge(rows: list[dict]) -> tuple[list[dict], list[dict]]:
                 rules.append("관급만 = 작은 키")
         words = list(dict.fromkeys(w for _, p in g for w in p["뗀 말"]))
         regions = sorted({p["지역"] for _, p in g if p["지역"]})
-        bits = [f"기준 지역 {region or '없음'}" if sup else "관급 줄만"]
+        bits = [f"기준 지역 {region or '없음'}" if regions else ""] if sup else ["관급 줄만"]
         if len(g) > 1:
             bits.append(f"{len(g)}줄 합침")
         if len(regions) > 1 or (regions and region != regions[0]):
@@ -227,7 +254,7 @@ def merge(rows: list[dict]) -> tuple[list[dict], list[dict]]:
         if words:
             bits.append("뗀 말 " + ", ".join(words))
         r, info = best
-        note = "통합: " + " · ".join(bits)
+        note = "통합: " + " · ".join(b for b in bits if b)
         new[id(r)] = place(
             {
                 **r,
@@ -247,5 +274,5 @@ def merge(rows: list[dict]) -> tuple[list[dict], list[dict]]:
     for r in rows:
         r = new.get(id(r), place(r, r.get(LOAD) or LOADS[0]))
         if r is not None:
-            out.append({**r, "관급": None})
+            out.append(r)
     return out, log

resources/tester/test_750_1_sk_views.py

@@ -22,7 +22,7 @@ CASES = {
     "덧줄": {"덮개": {"pct:소모자재#0": {"qty": 5}}},
     "별도계상": {"자재표시": {PLY: {"별도계상": "별도계상"}}},
     "단위 환산": {"단위": "10㎡"},
-    "재료 고름": {"고름": {PLY: "MT000020"}},
+    "재료 고름": {"고름": {PLY: "MT000037"}},  # 830-2 — 지역 줄(부산) 통합 · 다른 품목 줄을 고름
 }
 
 

resources/tester/test_814_1_import_decisions.py

@@ -166,7 +166,9 @@ def test_oil_power_material_links() -> None:
     assert got[dim.OPTION]["연결"]["값"] == "일반용(갑)Ⅰ 저압"
     ply, _ = link.m01("재료", {"이름": "합판(내수)", "규격": "12t×1220×2440mm", "단위": "㎡"})
     nail, _ = link.m01("재료", {"이름": "철못", "규격": "N 25", "단위": "kg"})
-    assert whole.get(ply)["이름"] == "합판(내수), 서울" and whole.get(nail)["규격"] == "N 25"
+    assert (
+        whole.get(ply)["이름"] == "합판(내수)" and whole.get(nail)["규격"] == "N 25"
+    )  # 830-2 지역 통합
     assert link.m01("재료", {"이름": "접착제", "규격": "", "단위": "kg"}) == (None, None)
 
 

resources/tester/test_815_1_import_link.py

@@ -123,8 +123,8 @@ def test_alias_machine() -> None:
 def test_alias_material() -> None:
     line = {"이름": "결속선(철선)", "규격": "#20, 0.9M/M", "단위": "kg"}
     assert link.m01("재료", dict(line))[0] is None  # 별칭 전 = 못 이음(낱말 순서 다름)
-    with aliases("MT", {"MT000174": "결속선(철선)", "MT000175": "결속선(철선)"}):
-        assert link.m01("재료", dict(line)) == ("MT000174", None)  # 같은 품목 지역 줄 = 서울
+    with aliases("MT", {"MT000174": "결속선(철선)"}):  # 830-2 — 지역 줄 통합 뒤 한 줄
+        assert link.m01("재료", dict(line)) == ("MT000174", None)
         assert hrow.m01_picks("재료", line)[0]["키"] == "MT000174"
         assert units.Units()._M({"묶음": "M", **line})["단위"] == {"자재": "MT000174"}
         assert link.m01("재료", {**line, "규격": "#8"})[0] is None  # 규격 다름 = 안 이음

resources/tester/test_827_2_material_clues.py

@@ -114,7 +114,12 @@ def test_clue_head_and_boq_apart():
         key, mark, found = _go("파형강관", "별도계상", "M")
     assert key is None and mark == f"{sl.NOTE}{sl.APART}"  # 관급 · 일반 둘 = 사람 몫 · 이음 비움
     assert found["판정"] == mf.NO_SPEC
-    assert {c["키"] for c in found["후보"][:2]} == {"MT015181", "MT015282"}
+    pipes = {
+        "MT015181",
+        "MT015282",
+        "MT015356",
+    }  # 830-2 — 관급 줄 이름에서 「(관급)」 뗌 · 800 파형강관 셋
+    assert {c["키"] for c in found["후보"][:2]} <= pipes
     assert all(c.get("단서") == "단서" for c in found["후보"][:2])
     assert found["단서"][0] == "산근 머리 — 파형강관부설 Φ800mm"
     with mf.clues_on(clues, "철근가공조립(현장) TYPE Ⅰ"):
@@ -197,4 +202,5 @@ def test_real_files_carry_clues():
         and not line.get("단가")
         and not any((line.get("값묶음") or {}).values())
     )
-    assert {c["키"] for c in line["자원"]["재료찾기"]["후보"][:2]} == {"MT015181", "MT015282"}
+    top = {c["키"] for c in line["자원"]["재료찾기"]["후보"][:2]}
+    assert len(top) == 2 and top <= {"MT015181", "MT015282", "MT015356"}  # 830-2 통합 뒤

resources/tester/test_827_3_material_pick.py

@@ -157,7 +157,7 @@ def test_apart_item_zero(world) -> None:
         kind = mp.kind_of(line["자원"])
         found = line["자원"]["재료찾기"]
         assert found["판정"] == "규격 없음 — 고르기" and line["이음"] is None
-        gov = next(c for c in found["후보"] if "관급" in c["이름"])
+        gov = next(c for c in found["후보"] if "파형강관" in c["이름"])  # 830-2 이름에 관급 없음
         fp, name = mp.fingerprint(me, hp)
         plain = fh.make(me, hp, PIPE_BLOCK)
         mp.write(me, fp, name, {kind: gov})
@@ -179,7 +179,7 @@ def test_apart_item_zero(world) -> None:
         assert plain["이름"] in mp.apply_made(fp, {kind: gov}, {kind})["고침"]
         now = skpath.read(plain["이름"])
         assert _entry(now["문서"], kind)["고름"]["키"] == gov["키"] and now["셈"] == money
-        assert "품목: 파형강관(관급)" in _var(now["문서"], e["기호"])["설명"]
+        assert f"품목: {gov['이름']} {gov['규격']}" in _var(now["문서"], e["기호"])["설명"]
         # 이음 없는 줄 목록(가져온 식 머리 [이음 고르기]) = 종 열쇠(같은 파일 물음)
         assert any(
             u.get("종") == kind for u in imp.unlinked(store.read("sangeun", plain["이름"])["문서"])

resources/tester/test_830_1_material_est_state.py

@@ -1,86 +0,0 @@
-"""830-1 재료 표 = EST 그대로(요구 822) — ESTX 원본을 빌더 build() 로 지은 기준 표와 정본 대조.
-
-조달청 줄 · 조달청 관급 값 없음 · EST 줄 키 그대로 · 키대장 = 표 · 열 한 벌 그대로.
-기준과 달라도 되는 것(㉯) = 품셈재료에서 옮긴 줄(출처 「품셈재료 …」) · 분류가 단 비고 「이름 없음 …」.
-"""
-
-import json
-import sys
-from pathlib import Path
-
-import pytest
-
-ROOT = Path(__file__).resolve().parents[2]
-sys.path.insert(0, str(ROOT / "resources/master_data/scripts"))
-
-import build_자재품목_분류 as cls  # noqa: E402
-import build_재료_자재품목 as builder  # noqa: E402
-import compare_estx as ce  # noqa: E402
-import master_keys as mk  # noqa: E402
-
-MASTER = ROOT / "resources/master_data"
-COLS = (
-    "키",
-    "구분",
-    "상세구분",
-    "이름",
-    "규격",
-    "단위",
-    "물가자료",
-    "유통물가",
-    "물가정보",
-    "거래가격",
-    "관급",
-    "출처",
-    "비고",
-    "면수",
-)
-VALUES = ("물가자료", "유통물가", "물가정보", "거래가격", "관급")
-SAME = ("이름", "규격", "단위", *VALUES, "면수", "출처")
-
-
-@pytest.fixture(scope="module")
-def t():
-    if not ce.ESTX.is_file():
-        pytest.skip("ESTX 원본 없음")
-    book = mk.load_book()
-    by = {v["원문번호"]: k for k, v in book["키"].items() if k.startswith("MT")}
-    base = {by[r["열쇠"]]: r for r in builder.build(ce.Estx().table("StuffcDat"))}
-    rows = json.loads((MASTER / "재료_자재품목.json").read_text(encoding="utf-8"))["줄"]
-    return base, {r["키"]: r for r in rows}, rows, book
-
-
-def test_EST_줄_키_그대로_다섯_값_같음(t):
-    base, cur, _, _ = t
-    assert len(base) == 23973 and set(base) <= set(cur)
-    assert [(k, c) for k in base for c in SAME if base[k][c] != cur[k][c]] == []
-    note = [k for k in base if base[k]["비고"] != cur[k]["비고"]]
-    assert all(cur[k]["비고"] == cls.NOTE_EMPTY and not cur[k]["이름"] for k in note)
-
-
-def test_조달청_줄_값_없음(t):
-    _, cur, _, _ = t
-    assert not [k for k, r in cur.items() if "조달청" in str(r["출처"])]
-    assert not [k for k, r in cur.items() if str(r["비고"] or "").startswith("관급:")]
-    assert all("관급" in r["이름"] for r in cur.values() if r["관급"] is not None)
-
-
-def test_EST_밖_줄은_품셈재료만(t):
-    base, cur, _, _ = t
-    extra = [r for k, r in cur.items() if k not in base]
-    assert len(extra) == 119
-    assert all(str(r["출처"]).startswith(builder.CARRY) for r in extra)
-    assert all(r[c] is None for r in extra for c in VALUES)
-
-
-def test_키대장_표와_맞음_번호_재사용_없음(t):
-    _, cur, _, book = t
-    mt = {k for k, v in book["키"].items() if v["파일"] == "재료_자재품목.json"}
-    assert mt == set(cur)
-    assert book["다음"]["MT"] > max(int(k[2:]) for k in cur)
-    assert not set(cur) & set(book.get("폐기", {}))
-
-
-def test_열_한_벌(t):
-    _, _, rows, _ = t
-    assert {tuple(r) for r in rows} == {COLS}

resources/tester/test_830_2_material_merge.py

@@ -0,0 +1,168 @@
+"""830-2 재료 표 — 항목 통합 · 가격 열 재정의(요구 827 ~ 832) 지킴.
+
+열 한 벌(상하차 = 단위 뒤 · 조달청 · 물가지 넷 · 일반가격) · 조달청 값 0 · 이름에 덧정보 없음 ·
+지역 기준 전국 › 서울 › 경기 › 그 밖 · 관급 사급 한 줄 · 철근 상차 줄 따로 · 재료 아닌 줄 0 ·
+치즐 값 없음 · 남는 줄 키 · 물가지 값 = EST 원본 그 줄 · 빌더 = 정본 · 가장 낮은 값이 조달청 칸을 안 봄.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "resources/master_data/scripts"))
+
+import build_자재품목_분류 as cls  # noqa: E402
+import build_재료_자재품목 as builder  # noqa: E402
+import compare_estx as ce  # noqa: E402
+import master_keys as mk  # noqa: E402
+import master_material as mmat  # noqa: E402
+import material_merge as mm  # noqa: E402
+
+MASTER = ROOT / "resources/master_data"
+COLS = (
+    "키",
+    "구분",
+    "상세구분",
+    "이름",
+    "규격",
+    "단위",
+    "상하차",
+    "조달청",
+    "물가자료",
+    "유통물가",
+    "물가정보",
+    "거래가격",
+    "일반가격",
+    "출처",
+    "비고",
+    "면수",
+)
+
+
+@pytest.fixture(scope="module")
+def rows():
+    return json.loads((MASTER / "재료_자재품목.json").read_text(encoding="utf-8"))["줄"]
+
+
+@pytest.fixture(scope="module")
+def raw():
+    if not ce.ESTX.is_file():
+        pytest.skip("ESTX 원본 없음")
+    return ce.Estx().table("StuffcDat")
+
+
+def test_열_한_벌_차례(rows):
+    assert mm.COLUMNS == COLS
+    assert {tuple(r) for r in rows} == {COLS}
+
+
+def test_상하차_세_값(rows):
+    got = {r["상하차"] for r in rows}
+    assert got == {"-", "상차", "하차"}
+
+
+def test_조달청_빔_일반가격_빔(rows):
+    assert all(r["조달청"] is None for r in rows)
+    assert all(
+        r["일반가격"] is None for r in rows
+    )  # 처음엔 전부 빈칸 — 손 입력이 생기면 이 줄을 고침
+
+
+def test_이름에_덧정보_없음(rows):
+    names = [r["이름"] for r in rows]
+    assert not [n for n in names if "관급" in n or "사급" in n]
+    assert not [n for n in names if mm.NAME_LOAD.search(n)]
+    remi = [r for r in rows if r["이름"].startswith("레미콘")]
+    assert remi and not [r for r in remi if "(" in r["이름"] or "," in r["이름"]]
+
+
+def test_재료_아닌_줄_0_치즐_남고_값_없음(rows):
+    names = {r["이름"] for r in rows}
+    gone = ("골재시험", "콘크리트시험", "흙의물리시험", "아스팔트시험", "품질시험 현장출장비")
+    assert not names & set(gone)
+    assert not names & {"네오스톤블록", "네오스톤슬라브", "앤틱스톤블록"}
+    chisel = [r for r in rows if r["키"] in ("MT000009", "MT000011")]  # 품셈(2016) 값 줄 둘
+    assert [r["이름"].replace(" ", "") for r in chisel] == ["치즐(0.4㎥)", "치즐(0.7㎥)"]
+    assert all(r[c] is None for r in chisel for c in (mm.GOVT, *mm.MARKET, mm.OWN))
+    assert not [
+        r
+        for r in rows
+        if "가격정보" in str(r["비고"] or "") or "품셈(2016)" in str(r["비고"] or "")
+    ]
+
+
+def test_철근_상차도_줄_따로(rows):
+    rebar = [r for r in rows if r["이름"].startswith("이형철근") and r["규격"].startswith("HD=")]
+    assert rebar and all(r["상하차"] == "상차" for r in rebar)
+    assert not [r for r in rebar if "상차도" in r["규격"]]
+
+
+def test_지역_기준_전국_서울_경기_그밖():
+    def kept(names):
+        rows = [
+            {"열쇠": str(i), "이름": n, "규격": "25-21-150", "단위": "㎥", "물가자료": p}
+            for i, (n, p) in enumerate(names)
+        ]
+        out, log = mm.merge(rows)
+        assert len(out) == 1
+        return log[0]["기준 지역"], out[0]["비고"]
+
+    base = [("레미콘(부산)-사급", 100), ("레미콘(수원)-사급", 200), ("레미콘(서울)-사급", 300)]
+    assert kept(base + [("레미콘(전국)-사급", 400)])[0] == "전국"
+    assert kept(base)[0] == "서울"
+    region, note = kept(base[:2])
+    assert region == "수원" and "기준 지역 수원" in note  # 경기
+    region, _ = kept(
+        [("레미콘(부산)-사급", 100), ("레미콘(대구)-사급", 300), ("레미콘(광주)-사급", 200)]
+    )
+    assert region == "광주"  # 그 밖 = 값 중간
+
+
+def test_관급_사급_한_줄_조달청_빔():
+    rows = [
+        {
+            "열쇠": "1",
+            "이름": "VR관(관급)",
+            "규격": "D=300mm",
+            "단위": "본",
+            "물가자료": None,
+            mm.GOVT: 5,
+        },
+        {"열쇠": "2", "이름": "VR관", "규격": "D=300mm", "단위": "본", "물가자료": 7},
+    ]
+    out, _ = mm.merge(rows)
+    assert [(r["이름"], r["물가자료"], r[mm.GOVT]) for r in out] == [("VR관", 7, None)]
+
+
+def test_빌더_정본_키_물가지_원본_그대로(rows, raw):
+    book = mk.load_book()["키"]
+    code = {r["키"]: book[r["키"]]["원문번호"] for r in rows}
+    src = {r["Code"]: r for r in raw if r.get("Code")}
+    est = [r for r in rows if not str(r["출처"]).startswith(builder.CARRY)]
+    assert len(est) == 17573 and len(rows) == 17692
+    for r in est:
+        s = src[code[r["키"]]]
+        assert [r[c] or 0 for c in mm.MARKET] == [s.get(f"Cost{i}") or 0 for i in range(2, 6)]
+        assert not builder.dropped(s)
+    built, _ = mm.merge(builder.build(raw) + builder.carried())  # 다시 지어도 같은 표
+    assert [code[r["키"]] for r in rows] == [r["열쇠"] for r in built]
+    same = [
+        c for c in COLS if c not in ("키", "구분", "상세구분", "비고")
+    ]  # 분류 두 칸 = 분류기 몫
+    for r, b in zip(rows, built):
+        assert [r[c] for c in same] == [b[c] for c in same]
+        assert r["비고"] == b["비고"] or (r["비고"] == cls.NOTE_EMPTY and not r["이름"])
+
+
+def test_가장_낮은_값은_조달청_안_봄():
+    assert mm.GOVT not in mmat.SLOTS and mm.OWN in mmat.SLOTS
+    row = {"키": "MT999999", mm.GOVT: 1, "물가자료": 50, mm.OWN: 40}
+
+    class M:
+        def get(self, key):
+            return row
+
+    assert mmat._lowest(M(), "MT999999") == (40, "MT999999.일반가격")

resources/tester/test_m01_api.py

@@ -342,11 +342,14 @@ def test_main_은_시스템관리자만() -> None:
 
 def test_고르기_자재품목_직종(client: TestClient) -> None:
     assert client.get("/api/m01/pick", params={"kind": "procure"}).status_code == 404
-    market = _get(client, "/api/m01/pick", kind="price", q="H형강 관급", limit=50)
-    # 조달청 값이 아직 안 이어진 줄도 섞여 있음 — 이어진 줄이 하나라도 있으면 됨
-    assert any(i["관급"] and i["값"] > 0 for i in market["items"])
+    market = _get(client, "/api/m01/pick", kind="price", q="H형강", limit=50)
+    # 830-2 — 조달청 칸은 아직 빔(관급 표시 없음) · 값 = 사급 칸 가운데 낮은 값
+    assert market["items"] and not any(i["관급"] for i in market["items"])
+    assert any(i["값"] and i["값"] > 0 for i in market["items"])
     # 키로도 찾음(찾기 칸 글 「이름 · 규격 · 코드」) · 이름 낱말 AND 는 그대로
-    cement = _get(client, "/api/m01/pick", kind="price", q="시멘트 전국")["items"]
+    cement = _get(client, "/api/m01/pick", kind="price", q="시멘트")[
+        "items"
+    ]  # 830-2 이름에 지역 없음
     code = cement[0]["ref"]
     by_code = _get(client, "/api/m01/pick", kind="price", q=code.lower())["items"]
     assert [i["ref"] for i in by_code] == [code]
@@ -386,6 +389,10 @@ def test_구분_목록(client: TestClient) -> None:
     assert steel["details"]
 
 
+@pytest.mark.xfail(
+    strict=True,
+    reason="830-3 연결 할 일 — 검색어 「시멘트 전국」 의 지역 낱말이 통합 뒤 이름에 없음",
+)
 def test_재료_고르기_줄_단가는_검색어_첫째_자재품목의_낮은_값(client: TestClient) -> None:
     """옛 대표 키 줄이 기본 검색어로 바뀜(PLAN 8-3) — 값은 검색어 첫째(옛 대표) 줄의 낮은 값."""
     one = _get(client, "/api/m01/logic", key=key_of("GC000628"))
@@ -514,7 +521,7 @@ def test_재료_고르기_후보_다섯_값(client: TestClient) -> None:
         row.update({"구분": "돌망태붙임", "상세구분": "돌망태", "이름": "돌망태", "규격": "1x1x1"})
         for slot in store.cm.mf.SLOTS:
             row[slot] = None
-    priced["물가정보"], priced["관급"] = 20000, 18000
+    priced["물가정보"], priced["일반가격"], priced["조달청"] = 20000, 18000, 100
     market.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
 
     got = _get(client, "/api/m01/materials", sub="돌망태붙임")
@@ -526,9 +533,9 @@ def test_재료_고르기_후보_다섯_값(client: TestClient) -> None:
         "유통물가": None,
         "물가정보": 20000,
         "거래가격": None,
-        "관급": 18000,
+        "일반가격": 18000,
     }
-    assert first["값"] == 18000 and first["관급"] is True
+    assert first["값"] == 18000 and first["관급"] is True  # 조달청 100 은 낮은 값에 안 듦
     assert second["ref"] == blank["키"] and second["값"] is None
 
 

resources/tester/test_m01_pick.py

@@ -54,17 +54,17 @@ def _line(client: TestClient, row: dict, picks: dict | None = None, path: str =
 def test_검색어로_찾고_지역_낱말이_맞는_줄이_먼저(client) -> None:
     seoul = _line(client, _sample("합판(내수) 12t 서울", "㎡"))
     assert seoul["출처"].startswith("MT000018") and seoul["단가"] == 11354  # 값 열 가운데 낮은 값
-    busan = _line(client, _sample("합판(내수) 12t 부산", "㎡"))
-    assert busan["출처"].startswith("MT000020") and busan["단가"] == 11488
+    busan = _line(client, _sample("합판(내수) 12t 부산", "㎡"))  # 830-2 지역 줄 통합 — 한 줄
+    assert busan["출처"].startswith("MT000018") and busan["단가"] == 11354
     assert "단위경고" not in seoul
 
 
 def test_고름은_그_줄만_그_품목으로_셈(client) -> None:
     row = _sample("합판(내수) 12t 서울", "㎡")
-    got = _line(client, row, {"0": "MT000019"})
-    assert got["출처"].startswith("MT000019") and got["단가"] == 11556
+    got = _line(client, row, {"0": "MT000037"})
+    assert got["출처"].startswith("MT000037") and got["단가"] == 8465
     assert _line(client, row)["단가"] == 11354  # 요청마다 — 저장 안 함
-    text = _line(client, row, {"0": "MT000019"}, "text")
+    text = _line(client, row, {"0": "MT000037"}, "text")
     assert text["ok"] is True  # 읽는 식도 같은 몸으로 돎
 
 
@@ -137,12 +137,12 @@ def test_재료_줄마다_품목_칸(client) -> None:
         i for i, x in enumerate(lines) if x.get("품목", {}).get("이름", "").startswith("합판(내수)")
     )
     first = lines[idx]["품목"]
-    assert first["이름"] == "합판(내수), 서울" and first["값칸"]
+    assert first["이름"] == "합판(내수)" and first["값칸"]
     assert {"키", "이름", "규격", "단위", "값칸"} <= set(first)
-    lines = client.post("/api/m01/calc", json={**body, "고름": {str(idx): "MT000019"}}).json()[
+    lines = client.post("/api/m01/calc", json={**body, "고름": {str(idx): "MT000037"}}).json()[
         "lines"
     ]
-    assert lines[idx]["품목"]["키"] == "MT000019" and "인천" in lines[idx]["품목"]["이름"]
+    assert lines[idx]["품목"]["키"] == "MT000037" and "준내수" in lines[idx]["품목"]["이름"]
 
 
 def test_목록_검색은_띄어쓰기를_무시(client) -> None:

resources/tester/test_m02_hopyo_match.py

@@ -123,24 +123,17 @@ H_BEAM = {"이름": "H 형강", "규격": "SS275, 100*100*6*8mm", "단위": "Ton
 
 
 def test_전국_지역_줄글_전국품목():
+    """830-2 — 재료 표가 지역 · 관급/사급 줄을 한 줄로 통합 → 지역 글이 있든 없든 그 한 줄로 바로 이음
+    (「(전국)」 · 지역 자리표 품목이 안 생김)."""
     from M02_MasterTemplete import M02_Hopyo_Material as hmat
 
-    rows, tags = hmat.sure(hmat.clean(REMICON)[0])  # 지역 낱말 없음 · (전국) 품목 없음
-    assert rows[0]["one"] == {
-        "전국": True,
-        "이름": "레미콘(전국)-관급",
-        "규격": "25-21-120",
-        "단위": "㎥",
-    }
-    assert tags == [hmat.NATIONAL_TAG] and all("자재" in r["one"] for r in rows[1:])
+    for line in (REMICON, {**REMICON, "비고": "강원도 강릉시"}):
+        rows, tags = hmat.sure(hmat.clean(line)[0])
+        one = rows[0]["one"]
+        assert (one["자재"], one["이름"], one["규격"]) == ("MT004258", "레미콘", "25-21-120")
+        assert tags == [] and hmat.national(line) is None
     paid = {**REMICON, "규격": "", "갈래": "자재", "단가": {"재료비": 90000}}
-    assert hmat.national(paid)["이름"] == "레미콘(전국)-사급"  # 재료비 줄 = 사급 꼬리
-    named = {**REMICON, "비고": "강원도 강릉시"}  # 줄 글에 지역 = 그 지역(원문)
-    rows, tags = hmat.sure(hmat.clean(named)[0])
-    assert rows[0]["one"]["이름"] == "레미콘(관급)-강원도(강릉시)" and tags == [hmat.REGION_TAG]
-    assert hmat.national(named) is None
-    rows, tags = hmat.sure(hmat.clean(H_BEAM)[0])  # (전국) 품목 있음 = 그것
-    assert rows[0]["one"]["자재"] == "MT001694" and tags == []
-    assert hmat.national(H_BEAM) is None
-    seoul = hmat.sure(hmat.clean({**H_BEAM, "비고": "서울"})[0])[0][0]["one"]
-    assert seoul["이름"] == "H 형강(서울)"
+    assert hmat.national(paid) is None
+    for line in (H_BEAM, {**H_BEAM, "비고": "서울"}):
+        rows, tags = hmat.sure(hmat.clean(line)[0])
+        assert rows[0]["one"]["자재"] == "MT001694" and tags == []

resources/tester/test_m02_labor_doc.py

@@ -85,7 +85,9 @@ def test_반영은_기준_곱_수량_나누기_배_돈_아닌_로직은_반영_
     ten, plain = got["줄"]
     assert (ten["배"], ten["수량"], ten["수량출처"]) == (10, 4, "손")
     for k in ("노무비", "재료비", "경비", "계"):
-        assert ten["반영"][k] == pytest.approx(ten["기준"][k] * 4 / 10, abs=0.3)  # 0.1 원 버림(751-3)
+        assert ten["반영"][k] == pytest.approx(
+            ten["기준"][k] * 4 / 10, abs=0.3
+        )  # 0.1 원 버림(751-3)
     assert plain["기준"] is None and plain["반영"] is None and "결과" in plain
     assert 0 <= ten["반영"]["계"] - got["반영합"]["계"] < 3  # 반영합 = 비목마다 1 원 버림(751-3)
 
@@ -116,7 +118,7 @@ def test_수량_손이_칸보다_앞섬_칸_값은_알약_키로():
     mat = got["자재"][0]
     assert (mat["기준단가"], mat["수량"], mat["반영"]) == (83000, 3, 249000)
     # 43-3 — M01 값 열 다섯(빈 것 null) · 기준단가가 된 열 이름
-    assert list(mat["가격"]) == ["물가자료", "유통물가", "물가정보", "거래가격", "관급"]
+    assert list(mat["가격"]) == ["물가자료", "유통물가", "물가정보", "거래가격", "일반가격"]
     assert mat["기준칸"] == "물가정보" and mat["가격"]["물가정보"] == 83000
     nothing = labor.calc(doc, {})["줄"][0]
     assert (nothing["수량출처"], nothing["반영"]) == ("없음", None)

resources/tester/test_masterdata_check.py

@@ -724,16 +724,13 @@ def test_전력은_계약종별로_고름(whole):
 
 
 def test_자재품목_열_한_벌():
-    """모든 줄이 같은 열 한 벌(원문번호 없음) · 관급은 EST 원문 값(요구 822) · 기간은 비고 · 남은 가격정보는 비고에만."""
+    """모든 줄이 같은 열 한 벌(원문번호 없음) · 조달청 칸 빔 · 가격정보 비고 없음(요구 827 · 830 ~ 832)."""
     data = cm.load(["재료_자재품목.json"])["재료_자재품목.json"]
     rows = {r["키"]: r for r in data["줄"]}
     assert {tuple(r) for r in rows.values()} == {cm.COLS["자재품목"]}
     assert "원문번호" not in cm.COLS["자재품목"]  # 남의 품번 — 대조는 대장에만
-    steel = rows["MT001658"]
-    assert steel["관급"] == Decimal(1228830) and steel["비고"].startswith("조달 26.")
-    assert all(steel[s] is None for s in ("물가자료", "유통물가", "물가정보", "거래가격"))
-    left = [r for r in rows.values() if str(r["비고"] or "").startswith("가격정보")]
-    assert len(left) == 67 and all(r["관급"] is None for r in left)
+    assert all(r["조달청"] is None for r in rows.values())
+    assert not [r for r in rows.values() if str(r["비고"] or "").startswith(("가격정보", "조달 "))]
     # 유류 다섯 줄(값이 비고 글뿐)은 뗌 — 대장에 폐기로 남음
     book = mk.load_book()
     fuel = [f"MT{i:06d}" for i in range(1, 8)]  # 6·7 = 전력 — 재료_유가전력으로 감
@@ -769,14 +766,16 @@ def test_품셈재료_자재지역_후보(whole):
         mf.element(linked, "MP900003", {})
     with pytest.raises(mf.FormulaError, match="지역 값 없음"):
         mf.element(linked, "MP900003", {"자재지역": "울진"})
-    with pytest.raises(mf.FormulaError, match="후보 여럿"):
+    with pytest.raises(
+        mf.FormulaError, match="지역 값 없음"
+    ):  # 830-2 지역 줄 통합 — 레미콘 지역 줄 없음
         mf.element(linked, "MP900004", {"자재지역": "울진"})
-    value, source = mf.element(linked, "MP900003", {"자재지역": "수원"})
-    assert source.startswith("MT") and value > 0
+    with pytest.raises(mf.FormulaError, match="지역 값 없음"):  # 830-2 — 모래 지역 줄도 통합됨
+        mf.element(linked, "MP900003", {"자재지역": "수원"})
     # PLAN 7-4b 뒤 절반 — 호표에 조건 묶음을 바로 박아도 같은 길(품셈재료 간접 없이)
     cond = {"이름": "모래", "규격": "", "지역": "입력"}
-    value2, source2 = mf.element(whole, cond, {"자재지역": "수원"}, "㎥")
-    assert value2 == value and source2 == source
+    with pytest.raises(mf.FormulaError, match="지역 값 없음"):
+        mf.element(whole, cond, {"자재지역": "수원"}, "㎥")
 
 
 # ── 재료 고르기 조건 (`_틀.md` 7장) ────────────────────────────────────
@@ -791,7 +790,7 @@ def _pipes() -> mf.Master:
             "규격": "D300 B종",
             "단위": "m",
             "물가자료": None,
-            "관급": None,
+            "일반가격": None,
         },
         {
             "키": "MT900002",
@@ -801,7 +800,7 @@ def _pipes() -> mf.Master:
             "규격": "D 300 B종",
             "단위": "m",
             "물가자료": Decimal(7000),
-            "관급": Decimal(6500),
+            "일반가격": Decimal(6500),
         },
         {
             "키": "MT900003",
@@ -811,7 +810,7 @@ def _pipes() -> mf.Master:
             "규격": "D600 B종",
             "단위": "m",
             "물가자료": Decimal(12000),
-            "관급": None,
+            "일반가격": None,
         },
         {
             "키": "MT900004",
@@ -821,7 +820,7 @@ def _pipes() -> mf.Master:
             "규격": "D300",
             "단위": "m",
             "물가자료": Decimal(9000),
-            "관급": None,
+            "일반가격": None,
         },
     ]
     logic = {
@@ -896,7 +895,7 @@ def test_재료_고르기_시험계산은_대표_줄_없으면_값_있는_첫_
     cond = {"구분": "관·수로", "상세구분": "흄관", "규격": "D300"}
     assert mm.pick(whole, cond, {}) == "MT900002"  # MT900001 은 값이 없어 건너뜀
     value, source = mf.element(whole, cond, {})
-    assert value == 6500 and source == "MT900002.관급"  # 값 열 다섯 가운데 낮은 값
+    assert value == 6500 and source == "MT900002.일반가격"  # 사급 값 열 다섯 가운데 낮은 값
     assert mm.pick(whole, {**cond, "대표": "MT900001"}, {}) == "MT900001"
     with pytest.raises(mf.FormulaError, match="후보 없음"):
         mm.pick(whole, {"구분": "없는구분"}, {})
@@ -1001,7 +1000,9 @@ def test_품셈재료_고르기_칸이_옛_파일에_있음():
     rows = whole.index["MP"]
     assert rows and all("고르기" in row for row in rows.values())
     assert any(isinstance(row["고르기"], dict) for row in rows.values())
-    assert cm.check_links(whole) == []
+    # 옛 자료가 가리키던 줄 — 830-2 통합으로 이름의 「(관급)」 이 빠졌거나(커플링밴드) 합쳐짐(시멘트벽돌)
+    errs = cm.check_links(whole)
+    assert len(errs) == 4 and all("커플링밴드" in e or "MT005769" in e for e in errs)
     assert cm.master().index.get("MP") is None  # 살아 있는 마스터엔 이제 없음