diff --git a/A00_Common/design/design_structure_form.ts b/A00_Common/design/design_structure_form.ts
new file mode 100644
index 000000000..e6df8ec91
--- /dev/null
+++ b/A00_Common/design/design_structure_form.ts
@@ -0,0 +1,253 @@
+/* =============================================================================
+ * design_structure_form.ts
+ * 구조물 명세(`design_structure_spec`) 그리기 — B05 · B06 「구조물 배치」 칸이 같은 노드를 씀.
+ *
+ * · 필수 컨테이너 = 늘 보임(한 벌) · 선택 컨테이너 = [추가] 로 인스턴스를 늘리고 인스턴스마다 [빼기]
+ * · 항목: 고르기(상위 값에 따른 선택지 · 저장 키) · 숫자(맞물림 = 길이 · 전 · 후) · 자동(읽기만)
+ * · 인스턴스마다 「구조물 조합」 잇기 줄(`buildSummaryRow` · 고르기 모달 = 패널의 그룹 [고르기] 길 그대로) —
+ *   값은 패널 `group_items` 에 `linkOf` 키로 둠(빼면 뒤 인스턴스 잇기를 한 칸씩 당김)
+ * · 값은 폼이 쥠 — 저장은 패널이 `read()` 로 읽어 정본 자리(옵션)에 씀
+ * · 칸 표식 = `data-spec-item="{컨테이너}.{항목}"`(정의 규칙 · 그룹 상자가 안 건드리게 옵션 키 표식 안 씀)
+ * ========================================================================== */
+
+import {
+  branchOf,
+  choiceLabel,
+  choicesOf,
+  containerTitle,
+  itemLabel,
+  linkOf,
+  readState,
+  solveSplit,
+  writeOptions,
+  type SpecContainer,
+  type SpecItem,
+  type SpecNames,
+  type SpecState,
+  type SplitRole,
+  type StructureSpec,
+} from "./design_structure_spec";
+import {
+  group,
+  grid,
+  labeled,
+  numberInput,
+  stepper,
+} from "../../B05_Profile/B05_Profile_UI_Drainage_Facility_Fields";
+import { buildSummaryRow } from "../../B05_Profile/B05_Profile_UI_Structures_Summary_Row";
+import type { GroupItems, SummaryItem } from "../../common_util/common_util_summary_item";
+
+/** 잇기 값 자리 — 패널 그룹 값(`group_items`)을 그대로 씀. */
+export interface SpecLinks {
+  get: () => GroupItems;
+  pick: (key: string) => void;
+  /** [해제] — 패널이 풀고 반영. */
+  clear: (key: string) => void;
+  /** 값만 옮김(빼기 뒤 당김) — 반영은 뒤이은 폼 변경 알림이 함. */
+  set: (key: string, item: SummaryItem | null) => void;
+}
+
+export interface SpecFormHooks {
+  /** 자동 항목 값 글(빈 글 = 「—」). */
+  auto?: (c: SpecContainer, item: SpecItem, state: SpecState) => string;
+  /** 숫자 칸 빈 칸 안내. */
+  hint?: (c: SpecContainer, item: SpecItem, state: SpecState) => string;
+  onChange?: (c: SpecContainer, item: SpecItem) => void;
+}
+
+export interface SpecForm {
+  root: HTMLElement;
+  /** 명세 · 저장 값으로 다시 그림. `names` = 정의 이름 바꿈 · `groupNames` = 정의 그룹 이름. */
+  write: (
+    spec: StructureSpec,
+    options: Record<string, string | number>,
+    names?: SpecNames,
+    groupNames?: Record<string, string>,
+  ) => void;
+  read: () => Record<string, string | number>;
+  state: () => SpecState;
+  /** 한 항목 값을 바꿔 그림(B06 조정창 맞춤 등) — change 알림은 안 함. */
+  setValue: (containerId: string, itemId: string, value: string) => void;
+  /** 필수 컨테이너 끝에 붙일 자리(B06 조정 행). */
+  slot: (containerId: string) => HTMLElement;
+  /** 잇기 값이 바뀌었을 때 줄을 다시 그림. */
+  paintLinks: () => void;
+  refresh: () => void;
+}
+
+export function createSpecForm(links: SpecLinks | null, hooks: SpecFormHooks = {}): SpecForm {
+  const root = document.createElement("div");
+  root.className = "b05-structure__spec";
+  let spec: StructureSpec | null = null;
+  let state: SpecState = {};
+  let names: SpecNames = {};
+  let groupNames: Record<string, string> = {};
+  const recent = new Map<Instance, SplitRole[]>();
+  const slots = new Map<string, HTMLElement>();
+  const rows: Array<{ key: string; set: (item: SummaryItem | null) => void }> = [];
+  type Instance = Record<string, string>;
+
+  const slotOf = (id: string): HTMLElement => {
+    let slot = slots.get(id);
+    if (!slot) {
+      slot = document.createElement("div");
+      slot.className = "b05-structure__adjust-slot";
+      slots.set(id, slot);
+    }
+    return slot;
+  };
+
+  const control = (c: SpecContainer, item: SpecItem, values: Instance): HTMLElement => {
+    if (item.kind === "select") {
+      const select = document.createElement("select");
+      const choices = choicesOf(item, values);
+      select.replaceChildren(
+        new Option("— 안 정함 —", ""),
+        ...choices.map((ch) => new Option(choiceLabel(c, item, ch, names), ch.value)),
+      );
+      const now = values[item.id] ?? "";
+      // 선택지 밖 옛 값은 그 값만 남겨 보임(지운 값을 몰래 바꾸지 않음)
+      if (now && !choices.some((ch) => ch.value === now)) select.add(new Option(now, now));
+      select.value = now;
+      return select;
+    }
+    const input = numberInput(String(item.step ?? 0.1), "0", hooks.hint?.(c, item, state) ?? "");
+    if (item.kind === "auto") {
+      input.type = "text";
+      input.readOnly = true;
+      input.value = hooks.auto?.(c, item, state) || "—";
+      input.title = "자동 계산 — 고치지 않음";
+      return input;
+    }
+    input.value = values[item.id] ?? "";
+    return stepper(input, item.step ?? 0.1);
+  };
+
+  const onEdit = (c: SpecContainer, item: SpecItem, values: Instance, raw: string): void => {
+    values[item.id] = raw;
+    if (item.split) {
+      const order = [item.split, ...(recent.get(values) ?? []).filter((r) => r !== item.split)];
+      recent.set(values, order);
+      const role = (r: SplitRole) => c.items.find((i) => i.split === r)!;
+      const solved = solveSplit(
+        {
+          length: values[role("length").id],
+          before: values[role("before").id],
+          after: values[role("after").id],
+        },
+        order,
+      );
+      for (const r of ["length", "before", "after"] as SplitRole[])
+        values[role(r).id] = solved[r] ?? "";
+    }
+    // 위 항목이 바뀌면 갈래(선택지 · 저장 키)가 달라짐 — 선택지 밖 값은 비움
+    for (const child of c.items.filter((i) => i.by?.item === item.id)) {
+      const allowed = choicesOf(child, values);
+      if (child.kind === "select" && !allowed.some((ch) => ch.value === values[child.id]))
+        values[child.id] = "";
+    }
+    paint();
+    hooks.onChange?.(c, item);
+  };
+
+  const instanceBox = (c: SpecContainer, values: Instance, index: number): HTMLElement => {
+    const title = containerTitle(c, names, groupNames[c.link]);
+    const box = group(c.required ? title : `${title} ${index + 1}`);
+    box.root.dataset.specContainer = c.id;
+    const fields = c.items
+      .filter((item) => item.kind === "auto" || !item.by || branchOf(item, values))
+      .map((item) => {
+        const input = control(c, item, values);
+        const wrap = labeled(itemLabel(c, item, names), input);
+        wrap.dataset.specItem = `${c.id}.${item.id}`;
+        const target = input.querySelector?.("input, select") ?? input;
+        target.addEventListener("change", () =>
+          onEdit(c, item, values, (target as HTMLInputElement | HTMLSelectElement).value),
+        );
+        return wrap;
+      });
+    box.body.append(grid(...fields));
+    if (c.required) box.body.append(slotOf(c.id));
+    if (links) {
+      const key = linkOf(c, index + 1);
+      const row = buildSummaryRow();
+      row.root.querySelector(".b05-structure__summary-label")!.textContent = "구조물 조합";
+      row.root.dataset.specLink = key;
+      row.set(links.get()[key] ?? null);
+      row.bind({ pick: () => links.pick(key), clear: () => links.clear(key) });
+      rows.push({ key, set: row.set });
+      box.body.append(row.root);
+    }
+    if (!c.required) {
+      const remove = document.createElement("button");
+      remove.type = "button";
+      remove.className = "b05-route__irregular-btn";
+      remove.textContent = "빼기";
+      remove.dataset.specRemove = c.id;
+      remove.addEventListener("click", () => {
+        const list = state[c.id];
+        // 잇기는 인스턴스 차례를 따름 — 뒤 것을 한 칸씩 당기고 마지막 키는 풂
+        if (links) {
+          const now = links.get();
+          for (let n = index + 1; n < list.length; n++)
+            links.set(linkOf(c, n), now[linkOf(c, n + 1)] ?? null);
+          links.set(linkOf(c, list.length), null);
+        }
+        list.splice(index, 1);
+        paint();
+        hooks.onChange?.(c, c.items[0]);
+      });
+      box.root.querySelector("legend")!.append(" ", remove);
+    }
+    return box.root;
+  };
+
+  function paint(): void {
+    rows.length = 0;
+    const boxes: HTMLElement[] = [];
+    for (const c of spec?.containers ?? []) {
+      const list = (state[c.id] ??= c.required ? [{}] : []);
+      list.forEach((values, index) => boxes.push(instanceBox(c, values, index)));
+      if (c.required) continue;
+      const add = document.createElement("button");
+      add.type = "button";
+      add.className = "b05-route__irregular-btn b05-structure__spec-add";
+      add.textContent = `+ ${containerTitle(c, names, groupNames[c.link])}`;
+      add.title = "추가";
+      add.dataset.specAdd = c.id;
+      add.addEventListener("click", () => {
+        list.push({});
+        paint();
+        hooks.onChange?.(c, c.items[0]);
+      });
+      boxes.push(add);
+    }
+    root.replaceChildren(...boxes);
+  }
+
+  return {
+    root,
+    write(next, options, nextNames = {}, nextGroups = {}) {
+      spec = next;
+      names = nextNames;
+      groupNames = nextGroups;
+      state = readState(next, options);
+      recent.clear();
+      paint();
+    },
+    read: () => (spec ? writeOptions(spec, state) : {}),
+    state: () => state,
+    setValue(containerId, itemId, value) {
+      const values = state[containerId]?.[0];
+      if (!values) return;
+      values[itemId] = value;
+      paint();
+    },
+    slot: slotOf,
+    paintLinks() {
+      const now = links?.get() ?? {};
+      rows.forEach((row) => row.set(now[row.key] ?? null));
+    },
+    refresh: paint,
+  };
+}
diff --git a/A00_Common/design/design_structure_pipe.ts b/A00_Common/design/design_structure_pipe.ts
new file mode 100644
index 000000000..c72f84c0b
--- /dev/null
+++ b/A00_Common/design/design_structure_pipe.ts
@@ -0,0 +1,187 @@
+/* =============================================================================
+ * design_structure_pipe.ts
+ * 횡단배수 › 배관 명세 — 사용자 구조물 표 01(`docs/raw/구조물정의_표/01_횡단배수_배관.md`) 그대로.
+ *
+ * 컨테이너 다섯: 관(필수) · 관 보호공(유입)(필수) · 관 보호공(유출)(필수) · 흙막이 추가(선택 · 여러 개) ·
+ * 도수로/돌붙임(선택 · 여러 개). 구조 · 정본 = 이 명세 · 이름만 정의(M02)에서 바꿈.
+ * 저장 키 = pipe_points.json 옛 키 그대로(B06 횡단 · B07 · B08 이 읽는 자리) — 흙막이 값은 옛 「기슭막이」
+ * (`inlet_type` · `*_revet_*`)에 둠. 새 키 = 집수정 높이 · 선택 컨테이너(`soil_add_{n}_*` · `chute_add_{n}_*`).
+ * 정함(PLAN 52): 유출 형태 = 흙막이 6가지 · 도수로/돌붙임 = 구조만 · 길이 = 전 + 후 맞물림.
+ * 계산(관 길이 · 높이 안내)은 `design_structure_pipe_calc`.
+ * import 없음 — 시험이 이 파일만 옮겨 돌림.
+ * ========================================================================== */
+
+import type { SpecChoice, SpecItem, StructureSpec } from "./design_structure_spec";
+
+const SOIL = "기슭막이"; // 저장 값(옛 키 그대로) — 화면 이름은 흙막이
+const BASIN = "집수정";
+const SOIL_FORMS: SpecChoice[] = [
+  { value: "돌쌓기(찰)", label: "돌 쌓기(찰)" },
+  { value: "돌쌓기(메)", label: "돌 쌓기(메)" },
+  { value: "콘크리트", label: "콘크리트" },
+  { value: "돌망태", label: "돌망태" },
+  { value: "통나무·목재틀", label: "통나무/목재틀" },
+  { value: "바자", label: "바자" },
+];
+const BASIN_FORMS: SpecChoice[] = [
+  { value: "I", label: "I형" },
+  { value: "L", label: "L형" },
+  { value: "U", label: "ㄷ형" },
+];
+
+/** 형태 · 길이 · 높이 · 전 · 후 — 필수 보호공은 구조 갈래마다 옛 키 · 선택 흙막이는 인스턴스 키. */
+function guardItems(keys?: Record<string, Record<string, string>>): SpecItem[] {
+  const by = (field: string, choices?: Record<string, SpecChoice[]>) =>
+    keys
+      ? {
+          item: "structure",
+          map: Object.fromEntries(
+            Object.entries(keys).map(([structure, k]) => [
+              structure,
+              { key: k[field], choices: choices?.[structure] },
+            ]),
+          ),
+        }
+      : undefined;
+  return [
+    {
+      id: "form",
+      label: "형태",
+      kind: "select",
+      choices: SOIL_FORMS,
+      by: by("form", { [BASIN]: BASIN_FORMS, [SOIL]: SOIL_FORMS }),
+    },
+    { id: "length", label: "길이 (m)", kind: "number", split: "length", step: 1, by: by("length") },
+    { id: "height", label: "높이 (m)", kind: "number", step: 0.1, by: by("height") },
+    {
+      id: "before",
+      label: "기준측점 전 (m)",
+      kind: "number",
+      split: "before",
+      step: 0.5,
+      by: by("before"),
+    },
+    {
+      id: "after",
+      label: "기준측점 후 (m)",
+      kind: "number",
+      split: "after",
+      step: 0.5,
+      by: by("after"),
+    },
+  ];
+}
+
+const revetKeys = (side: "inlet" | "outlet"): Record<string, string> => ({
+  form: `${side}_revet_form`,
+  length: `${side}_revet_length_m`,
+  height: `${side}_revet_height_m`,
+  before: `${side}_revet_before_m`,
+  after: `${side}_revet_after_m`,
+});
+
+export const PIPE_SPEC: StructureSpec = {
+  typeId: "pipe",
+  containers: [
+    {
+      id: "pipe",
+      title: "관",
+      required: true,
+      link: "grv6lny", // 정의 그룹 「관」(46장) — 집계표 잇기 자리 그대로
+      items: [
+        {
+          id: "diameter",
+          label: "관경",
+          kind: "select",
+          key: "pipe_diameter_mm",
+          asNumber: true,
+          choices: ["800", "1000", "1200", "1500"].map((v) => ({ value: v, label: v })),
+        },
+        { id: "length", label: "관 길이 (m)", kind: "auto" },
+      ],
+    },
+    {
+      id: "inlet",
+      title: "관 보호공 (유입)",
+      required: true,
+      link: "gnbf9m9",
+      items: [
+        {
+          id: "structure",
+          label: "구조",
+          kind: "select",
+          key: "inlet_type",
+          choices: [
+            { value: BASIN, label: "집수정" },
+            { value: SOIL, label: "흙막이", also: { inlet_structure: "revet" } },
+          ],
+        },
+        ...guardItems({
+          [BASIN]: {
+            form: "inlet_structure",
+            length: "inlet_basin_length_m",
+            height: "inlet_basin_height_m",
+            before: "inlet_basin_before_m",
+            after: "inlet_basin_after_m",
+          },
+          [SOIL]: revetKeys("inlet"),
+        }),
+      ],
+    },
+    {
+      id: "outlet",
+      title: "관 보호공 (유출)",
+      required: true,
+      link: "g9lq9uk",
+      items: [
+        {
+          id: "structure",
+          label: "구조",
+          kind: "select",
+          key: "outlet_type",
+          choices: [{ value: SOIL, label: "흙막이" }],
+        },
+        ...guardItems({ [SOIL]: revetKeys("outlet") }),
+      ],
+    },
+    {
+      id: "soil_add",
+      title: "흙막이 추가",
+      required: false,
+      prefix: "soil_add",
+      link: "gsoiladd",
+      items: [
+        {
+          id: "structure",
+          label: "구조",
+          kind: "select",
+          choices: [{ value: SOIL, label: "흙막이" }],
+        },
+        ...guardItems(),
+      ],
+    },
+    {
+      id: "chute_add",
+      title: "도수로/돌붙임",
+      required: false,
+      prefix: "chute_add",
+      link: "gchuteadd",
+      items: [
+        {
+          id: "structure",
+          label: "구조",
+          kind: "select",
+          choices: [
+            { value: "도수로", label: "도수로" },
+            { value: "돌붙임", label: "돌붙임" },
+          ],
+        },
+      ],
+    },
+  ],
+  // 표 01 에 없는 옛 칸 — 화면에서 빼고 값은 남김(지난 정의 값)
+  retired: ["pipe_kind", "wing_wall_type", "inlet_basin_form", "inlet_basin_material"],
+};
+
+/** 명세로 그리는 종류 — 종류 키 → 명세(표가 오는 대로 더함). */
+export const STRUCTURE_SPECS: Readonly<Record<string, StructureSpec>> = { pipe: PIPE_SPEC };
diff --git a/A00_Common/design/design_structure_pipe_calc.ts b/A00_Common/design/design_structure_pipe_calc.ts
new file mode 100644
index 000000000..d6432aabe
--- /dev/null
+++ b/A00_Common/design/design_structure_pipe_calc.ts
@@ -0,0 +1,42 @@
+/* =============================================================================
+ * design_structure_pipe_calc.ts
+ * 배관 명세 계산 — 관 길이(자동) · 보호공 높이 안내. 계산 자리 = ② TS 를 서버 Node 로:
+ * 관 길이는 횡단 기하 `computeStoredLayouts`(B06 · 서버 Node 진입점이 같은 함수로 `pipe_length_m` 를
+ * 셈 · 시험 test_b06_pipe_length) 그대로 — 여기서 새로 셈하지 않음 · 화면에 보이기만(저장 안 함).
+ * 높이 = 손 입력 · 횡단도 조정 높이는 B06 `withSpecDefaults` 가 같은 키(`*_revet_height_m`)에 실음 ·
+ * 빈 칸 안내 = 관경 기준 최소 높이(`pipeWallMinHeightM` ↔ 파이썬 `pipe_wall_min_height_m` 짝).
+ * ========================================================================== */
+
+import { pipeWallMinHeightM } from "../../common_util/common_util_culvert_sets";
+import type { CrossSection } from "../../B06_Section/B06_Section_Api_Fetch";
+import { computeStoredLayouts } from "../../B06_Section/B06_Section_Structure_Layouts";
+import { PIPE_MATCH_M } from "./design_selection";
+
+/** 횡단 측점 목록을 대는 곳 — 횡단 보기가 자료를 받으면 걸어 둠(종단만 연 동안은 없음). */
+let sectionsSource: (() => readonly CrossSection[] | null) | null = null;
+export function setPipeSectionsSource(source: () => readonly CrossSection[] | null): void {
+  sectionsSource = source;
+}
+
+/** 관 길이(m) — 그 관의 주인 측점(관 자리에서 가장 가까운 측점) 횡단 기하 값 · 못 세우면 저장된
+ *  `pipe_length_m` · 그것도 없으면 null. */
+export function pipeLengthM(chainageM: number | null): number | null {
+  const sections = sectionsSource?.() ?? null;
+  if (chainageM === null || !sections?.length) return null;
+  const holders = sections.filter(
+    (s) => Math.abs((s.culvert?.chainage_m ?? Infinity) - chainageM) < PIPE_MATCH_M,
+  );
+  if (!holders.length) return null;
+  const owner = holders.reduce((a, b) =>
+    Math.abs(b.chainage_m - chainageM) < Math.abs(a.chainage_m - chainageM) ? b : a,
+  );
+  const drawn = computeStoredLayouts(owner, sections)?.culvert?.pipe?.lengthM;
+  const length = typeof drawn === "number" && drawn > 0 ? drawn : owner.design?.pipe_length_m;
+  return typeof length === "number" && length > 0 ? length : null;
+}
+
+/** 흙막이 높이 빈 칸 안내 — 관경 기준 최소 높이(엔진이 빈 칸을 이 값으로 그림). */
+export function guardHeightHint(diameterMm: string): string {
+  const d = Number(diameterMm || "1000") / 1000;
+  return `비우면 관경 기준 ${pipeWallMinHeightM(d)}`;
+}
diff --git a/A00_Common/design/design_structure_spec.ts b/A00_Common/design/design_structure_spec.ts
new file mode 100644
index 000000000..506858418
--- /dev/null
+++ b/A00_Common/design/design_structure_spec.ts
@@ -0,0 +1,239 @@
+/* =============================================================================
+ * design_structure_spec.ts
+ * 구조물 명세 공용 틀(PLAN 52) — 화면 요소 없는 순수 규칙. 사용자 구조물 표 한 장 = 명세 한 벌.
+ *
+ * · 종류 = 기본 옵션(기준 측점 No + 거리 · 패널 위치 칸이 받음) + 컨테이너[] + 항목[]
+ * · 컨테이너 = 제목 · 필수(늘 한 벌) / 선택([추가] · [빼기] · 여러 개)
+ * · 항목 꼴 = 고르기 · 숫자 · 자동(계산이 채움 · 저장 안 함) · 맞물림(길이 = 전 + 후)
+ * · 상위 값에 따른 선택지 · 저장 키 = `by`(같은 컨테이너 안 상위 항목 값 → 갈래)
+ * · 저장 = 정본 자리 옵션 그대로(관이면 pipe_points.json `options`) — 필수 컨테이너는 항목 `key` ·
+ *   선택 컨테이너는 인스턴스마다 `{prefix}_{n}_{항목}`(n 은 1부터)
+ * · 구조물 조합 잇기(`group_items`) 키 = 필수는 `link`(정의 그룹 id) · 선택은 `{link}{n}`
+ * · 이름 = 정의 `종류.{종류}.이름` 이 있으면 그것(M02 바꿈) · 그룹 이름 · 없으면 명세 글
+ * import 없음 — 시험이 이 파일만 옮겨 돌림.
+ * ========================================================================== */
+
+export interface SpecChoice {
+  value: string;
+  label: string;
+  /** 이 값을 고르면 함께 적는 옵션(하류가 읽는 옛 칸 · 예: 흙막이 = inlet_structure revet). */
+  also?: Record<string, string>;
+}
+
+/** 상위 값 하나에 걸린 갈래 — 저장 키 · 선택지. */
+export interface SpecBranch {
+  key: string;
+  choices?: SpecChoice[];
+}
+
+export type SplitRole = "length" | "before" | "after";
+
+export interface SpecItem {
+  id: string;
+  label: string;
+  kind: "select" | "number" | "auto";
+  /** 저장 키(필수 컨테이너 · `by` 없을 때). */
+  key?: string;
+  choices?: SpecChoice[];
+  /** 같은 컨테이너 상위 항목 값 → 갈래. 갈래가 없으면(상위 비었음) 칸을 가림. */
+  by?: { item: string; map: Record<string, SpecBranch> };
+  /** 길이 = 전 + 후 맞물림 몫. */
+  split?: SplitRole;
+  /** 고르기 값을 수로 저장(관경 등 옛 저장이 수). */
+  asNumber?: boolean;
+  step?: number;
+  /** 빈 칸 안내 — 함수면 지금 값으로 셈. */
+  hint?: string | ((values: Record<string, string>) => string);
+}
+
+export interface SpecContainer {
+  id: string;
+  title: string;
+  required: boolean;
+  /** 선택 컨테이너 저장 키 머리 — `{prefix}_{n}_{항목}`. */
+  prefix?: string;
+  /** 구조물 조합 잇기 키 — 필수는 정의 그룹 id 그대로 · 선택은 뒤에 n. */
+  link: string;
+  items: SpecItem[];
+}
+
+export interface StructureSpec {
+  typeId: string;
+  containers: SpecContainer[];
+  /** 명세가 화면에서 뺀 옛 키 — 값은 그대로 남고 「지난 정의 값」으로 보임. */
+  retired: string[];
+}
+
+/** 컨테이너 인스턴스 한 벌 값 `{항목 id: 글}`. */
+export type Instance = Record<string, string>;
+export type SpecState = Record<string, Instance[]>;
+
+/** 항목의 지금 갈래 — `by` 없으면 항목 자체. 상위가 비었으면 null(가림 · 저장 안 함). */
+export function branchOf(item: SpecItem, values: Instance): SpecBranch | null {
+  if (!item.by)
+    return item.key || item.choices ? { key: item.key ?? "", choices: item.choices } : null;
+  return item.by.map[values[item.by.item] ?? ""] ?? null;
+}
+
+const instanceKey = (c: SpecContainer, n: number, item: SpecItem): string =>
+  `${c.prefix}_${n}_${item.id}`;
+
+/** 항목 저장 키 — 자동 항목 · 갈래 없음 = null. */
+export function keyOf(
+  c: SpecContainer,
+  item: SpecItem,
+  n: number,
+  values: Instance,
+): string | null {
+  if (item.kind === "auto") return null;
+  if (!c.required) return instanceKey(c, n, item);
+  return branchOf(item, values)?.key || null;
+}
+
+/** 지금 고를 수 있는 값 — 갈래 선택지가 앞섬. */
+export function choicesOf(item: SpecItem, values: Instance): SpecChoice[] {
+  return branchOf(item, values)?.choices ?? item.choices ?? [];
+}
+
+/** 인스턴스 잇기 키 — 필수 = 그룹 id · 선택 = `{link}{n}`. */
+export const linkOf = (c: SpecContainer, n: number): string =>
+  c.required ? c.link : `${c.link}${n}`;
+
+const text = (value: unknown): string =>
+  value === undefined || value === null ? "" : String(value);
+
+/** 옵션 → 컨테이너 값. 필수는 한 벌(상위 항목 먼저 읽어 갈래 키를 앎) · 선택은 저장된 n 차례대로. */
+export function readState(
+  spec: StructureSpec,
+  options: Record<string, string | number>,
+): SpecState {
+  const state: SpecState = {};
+  for (const c of spec.containers) {
+    if (c.required) {
+      const values: Instance = {};
+      const plain = c.items.filter((item) => !item.by);
+      for (const item of [...plain, ...c.items.filter((item) => item.by)]) {
+        const key = keyOf(c, item, 1, values);
+        if (key) values[item.id] = text(options[key]);
+      }
+      state[c.id] = [values];
+      continue;
+    }
+    const head = new RegExp(`^${c.prefix}_(\\d+)_`);
+    const ns = [
+      ...new Set(
+        Object.keys(options)
+          .map((k) => head.exec(k)?.[1])
+          .filter((n): n is string => !!n)
+          .map(Number),
+      ),
+    ].sort((a, b) => a - b);
+    state[c.id] = ns.map((n) =>
+      Object.fromEntries(c.items.map((item) => [item.id, text(options[instanceKey(c, n, item)])])),
+    );
+  }
+  return state;
+}
+
+/** 컨테이너 값 → 옵션(빈 칸 뺌 · 숫자 칸은 수 · 선택 컨테이너는 차례대로 1 부터 다시 매김). */
+export function writeOptions(
+  spec: StructureSpec,
+  state: SpecState,
+): Record<string, string | number> {
+  const out: Record<string, string | number> = {};
+  for (const c of spec.containers) {
+    (state[c.id] ?? []).forEach((values, index) => {
+      for (const item of c.items) {
+        const key = keyOf(c, item, index + 1, values);
+        const raw = (values[item.id] ?? "").trim();
+        if (!key || raw === "") continue;
+        if (item.kind === "number" || item.asNumber) {
+          const n = Number(raw);
+          if (Number.isFinite(n)) out[key] = Math.round(n * 100) / 100;
+          continue;
+        }
+        out[key] = raw;
+        if (c.required)
+          Object.assign(out, choicesOf(item, values).find((ch) => ch.value === raw)?.also);
+      }
+    });
+  }
+  return out;
+}
+
+/** 명세가 다루는 키 전부(필수 갈래 · also 포함) + 선택 컨테이너 머리 — 지난 정의 값 판정 · 저장 병합. */
+export function specKeys(spec: StructureSpec): { keys: string[]; prefixes: string[] } {
+  const keys = new Set<string>();
+  const prefixes: string[] = [];
+  for (const c of spec.containers) {
+    if (!c.required) {
+      prefixes.push(`${c.prefix}_`);
+      continue;
+    }
+    for (const item of c.items) {
+      const branches = item.by ? Object.values(item.by.map) : [branchOf(item, {})];
+      for (const branch of branches) {
+        if (branch?.key) keys.add(branch.key);
+        for (const ch of branch?.choices ?? item.choices ?? [])
+          Object.keys(ch.also ?? {}).forEach((k) => keys.add(k));
+      }
+    }
+  }
+  return { keys: [...keys], prefixes };
+}
+
+/**
+ * 길이 = 전 + 후 맞물림 — 마지막에 고친 둘을 지키고 나머지 하나를 셈(정함 52).
+ * `recent` = 고친 차례(최근이 앞) · 둘이 안 차면 길이 → 전 → 후 차례로 채움. 지킬 둘 중 빈 칸이 있으면 안 셈.
+ */
+export function solveSplit(
+  values: Partial<Record<SplitRole, string>>,
+  recent: SplitRole[],
+): Partial<Record<SplitRole, string>> {
+  const keep = [...new Set([...recent, "length", "before", "after"] as SplitRole[])].slice(0, 2);
+  const num = (role: SplitRole): number | null => {
+    const raw = (values[role] ?? "").trim();
+    const n = Number(raw);
+    return raw !== "" && Number.isFinite(n) ? n : null;
+  };
+  const [a, b] = keep.map(num);
+  if (a === null || b === null) return values;
+  const free = (["length", "before", "after"] as SplitRole[]).find((r) => !keep.includes(r))!;
+  const got = { length: num("length"), before: num("before"), after: num("after") };
+  const result =
+    free === "length"
+      ? (got.before ?? 0) + (got.after ?? 0)
+      : Math.max((got.length ?? 0) - (free === "before" ? (got.after ?? 0) : (got.before ?? 0)), 0);
+  return { ...values, [free]: String(Math.round(result * 100) / 100) };
+}
+
+/** 이름 바꿈 표(정의 `종류.{종류}.이름`) — 키 `{컨테이너}` · `{컨테이너}.{항목}` · `{컨테이너}.{항목}={값}`. */
+export type SpecNames = Record<string, string>;
+
+export const containerTitle = (c: SpecContainer, names: SpecNames, groupName?: string): string =>
+  names[c.id] ?? groupName ?? c.title;
+export const itemLabel = (c: SpecContainer, item: SpecItem, names: SpecNames): string =>
+  names[`${c.id}.${item.id}`] ?? item.label;
+export const choiceLabel = (
+  c: SpecContainer,
+  item: SpecItem,
+  ch: SpecChoice,
+  names: SpecNames,
+): string => names[`${c.id}.${item.id}=${ch.value}`] ?? ch.label;
+
+/** 명세의 이름 키 전부(정의 파일에 올릴 표) — `{키: 명세 글}`. */
+export function nameTable(spec: StructureSpec): SpecNames {
+  const out: SpecNames = {};
+  for (const c of spec.containers) {
+    if (!c.required) out[c.id] = c.title; // 필수 컨테이너 이름 = 정의 그룹 이름(M02 그룹 표에서 바꿈)
+    for (const item of c.items) {
+      out[`${c.id}.${item.id}`] = item.label;
+      const all = [
+        ...(item.choices ?? []),
+        ...Object.values(item.by?.map ?? {}).flatMap((b) => b.choices ?? []),
+      ];
+      for (const ch of all) out[`${c.id}.${item.id}=${ch.value}`] = ch.label;
+    }
+  }
+  return out;
+}
diff --git a/A00_Common/design/design_view_cross.ts b/A00_Common/design/design_view_cross.ts
index 32f187eb0..a2174fee4 100644
--- a/A00_Common/design/design_view_cross.ts
+++ b/A00_Common/design/design_view_cross.ts
@@ -73,6 +73,7 @@ import {
   createStandardSlot,
 } from "../../B06_Section/B06_Section_UI_Page_Panel";
 import type { DesignPageHost } from "./design_page";
+import { setPipeSectionsSource } from "./design_structure_pipe_calc";
 import {
   bindDesignView,
   bindPipeOptions,
@@ -94,6 +95,8 @@ export async function mountCrossView(
   const projectId = shared.projectId || null;
   let currentRouteId: number | null = null;
   let sectionDetail: SectionDetailResponse | null = null;
+  // 배관 명세 관 길이(자동) = 이 횡단 자료의 기하(PLAN 52-1)
+  setPipeSectionsSource(() => sectionDetail?.cross_sections ?? null);
   let stationInterval: number | undefined;
 
   // 표준 횡단면 설정 패널 자리. context 로드 후 config 기본값으로 채운다.
diff --git a/A00_Common/spreadsheet/spreadsheet_links.css b/A00_Common/spreadsheet/spreadsheet_links.css
index 01a82b2c9..30694cd8e 100644
--- a/A00_Common/spreadsheet/spreadsheet_links.css
+++ b/A00_Common/spreadsheet/spreadsheet_links.css
@@ -195,3 +195,72 @@
   transform: translate(-100%, 0);
   pointer-events: none;
 }
+
+/* 칸을 골랐을 때 그 칸의 알약 — 굵은 테두리 + 바깥 고리(칸이 바뀐 첫 그림만 한 번 반짝) */
+.ss-link.is-here {
+  outline: 2px solid var(--color-accent);
+  outline-offset: 2px;
+  font-weight: 600;
+}
+
+.ss-link.is-pop {
+  animation: ss-link-pop 1.2s ease-out 1 both;
+}
+
+@keyframes ss-link-pop {
+  0%,
+  40%,
+  80% {
+    box-shadow: 0 0 0 4px color-mix(in srgb, var(--color-accent) 55%, transparent);
+  }
+  20%,
+  60%,
+  100% {
+    box-shadow: 0 0 0 0 transparent;
+  }
+}
+
+/* 일위대가에 없는 알약 — ⚠ + 점선 붉은 테두리 + [×] */
+.ss-link.is-orphan {
+  border: 1px dashed var(--color-danger);
+  color: var(--color-danger);
+}
+
+.ss-link__x {
+  margin-left: 2px;
+  padding: 0 4px;
+  border-radius: 50%;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+.ss-link__x:hover {
+  background: color-mix(in srgb, var(--color-danger) 20%, transparent);
+}
+
+.ss-link-cell.is-orphan {
+  outline: 1px dashed var(--color-danger);
+  outline-offset: -2px;
+}
+
+/* 보낸 범위(도면 표) — 점선 테두리(채움 없음) + 왼위 이름표 */
+.ss-link-range {
+  position: absolute;
+  z-index: 3;
+  box-sizing: border-box;
+  border: 2px dashed var(--color-accent);
+  pointer-events: none;
+}
+
+.ss-link-range__tag {
+  position: absolute;
+  left: -2px;
+  bottom: 100%;
+  padding: 0 4px;
+  border-radius: 3px 3px 0 0;
+  background: var(--color-accent);
+  color: var(--color-canvas);
+  font-size: 10px;
+  line-height: 14px;
+  white-space: nowrap;
+}
diff --git a/A00_Common/spreadsheet/spreadsheet_links.ts b/A00_Common/spreadsheet/spreadsheet_links.ts
index 978a9c8b4..7525085a4 100644
--- a/A00_Common/spreadsheet/spreadsheet_links.ts
+++ b/A00_Common/spreadsheet/spreadsheet_links.ts
@@ -15,7 +15,7 @@
 import "./spreadsheet_links.css";
 import { createMapContextMenu } from "@ui/ui_template_context_menu";
 import { el, showToast } from "@ui/ui_template_elements";
-import { parseA1, quoteSheet, toA1 } from "./spreadsheet_address";
+import { inRange, parseA1, parseRange, quoteSheet, toA1 } from "./spreadsheet_address";
 import { applyCommand } from "./spreadsheet_commands";
 import { askShare } from "./spreadsheet_link_ask";
 import { linkHues } from "./spreadsheet_link_color";
@@ -53,6 +53,11 @@ export interface LinkOptions {
   onItemsChange?: (항목: LinkItem[]) => void;
   /** 자재DB 찾기(빈 글 = 처음 목록) — 자재 모드만 */
   자재찾기?: (글: string) => Promise<LinkMaterial[]>;
+  /** 입력 모드 — 호스트가 항목 목록을 믿을 수 있게 받았음(받기 실패 · 빈 목록 구분) · true 일 때만
+   * 목록에 없는 연결 알약에 ⚠ + [×] */
+  확정?: boolean;
+  /** 다른 곳으로 보낸 칸 범위 표시(예: 도면 표) — 시트 id · 범위 · 이름표 · 마우스 올림 글 */
+  표시범위?: { 시트: string; 범위: string; 이름: string; 설명?: string }[];
 }
 
 export interface Links extends PartHandle {
@@ -74,6 +79,8 @@ const TEXT = {
   fail: "자재 목록을 못 받음",
   picked: "칸을 고른 뒤 새 알약을 누르면 연결",
   dup: "이미 목록에 있는 자재",
+  orphan: "일위대가에 없는 알약 — 연결을 풀면 [저장] 때 남음",
+  orphanX: "연결 풀기",
 };
 
 type RowCol = Extract<Command, { 종류: "행넣기" | "행지우기" | "열넣기" | "열지우기" }>;
@@ -146,6 +153,8 @@ export function mountLinks(
   let dragging: LinkItem | null = null;
   const dropMark = el("div", { className: "ss-link-drop" });
   let pick: HTMLElement | null = null;
+  /** 마지막으로 강조를 판정한 칸(시트 id!칸) — 바뀔 때만 반짝 · 스크롤 */
+  let lastAt = "";
 
   /** 키 → 연결(시트 · 줄) */
   function found(): Map<string, { sheet: Sheet; link: CellLink }> {
@@ -204,6 +213,8 @@ export function mountLinks(
     item: LinkItem,
     hit: { sheet: Sheet; link: CellLink } | undefined,
     hue: number | undefined,
+    orphan: boolean,
+    here: string,
   ) {
     const where = hit
       ? hit.sheet.id === ctx.selection.시트
@@ -211,15 +222,30 @@ export function mountLinks(
         : `${quoteSheet(hit.sheet.이름)}!${hit.link.칸}`
       : "";
     const b = el("button", {
-      className: hit ? "ss-link is-linked" : "ss-link",
-      attrs: { type: "button", title: hit ? TEXT.linked : TEXT.free, "data-key": item.키 },
+      className: `ss-link${hit ? " is-linked" : ""}${orphan ? " is-orphan" : ""}${
+        here ? ` is-here${here === "new" ? " is-pop" : ""}` : ""
+      }`,
+      attrs: {
+        type: "button",
+        title: orphan ? TEXT.orphan : hit ? TEXT.linked : TEXT.free,
+        "data-key": item.키,
+      },
       children: [
-        el("span", { text: item.이름 }),
+        el("span", { text: orphan ? `⚠ ${item.이름}` : item.이름 }),
         ...(item.단위 ? [el("small", { text: item.단위 })] : []),
         ...(where ? [el("code", { text: where })] : []),
       ],
     });
     if (hue !== undefined) b.style.setProperty("--ss-link-h", String(hue));
+    if (orphan && !ctx.readOnly) {
+      const x = el("span", {
+        className: "ss-link__x",
+        text: "×",
+        attrs: { role: "button", title: TEXT.orphanX },
+      });
+      x.addEventListener("click", (e) => (e.stopPropagation(), unlink(), back()));
+      b.append(x);
+    }
     b.draggable = !ctx.readOnly;
     b.addEventListener("dragstart", (e) => {
       dragging = item;
@@ -233,13 +259,13 @@ export function mountLinks(
     // 초점은 격자에 둠 — 끌 수 있는 알약은 막으면 끌기가 안 돼 그대로(누른 뒤 `back` 이 격자로 돌림)
     if (!b.draggable) b.addEventListener("mousedown", (e) => e.preventDefault());
     b.addEventListener("click", () => (hit ? goTo(hit.sheet, hit.link.칸) : void link(item)));
-    const unlink = (): void => {
+    function unlink(): void {
       if (hit)
         put(
           hit.sheet,
           (hit.sheet.연결 ?? []).filter((l) => l.키 !== item.키),
         );
-    };
+    }
     b.addEventListener("contextmenu", (e) => {
       e.preventDefault();
       const inList = opts?.모드 === "자재" && !item.고정 && items.some((i) => i.키 === item.키);
@@ -307,7 +333,17 @@ export function mountLinks(
           : { 키: link.키, 이름: link.이름 ?? link.키, 단위: link.단위 },
       );
     const hues = linkHues(map.keys());
-    const pills = shown.map((item) => pill(item, map.get(item.키), hues.get(item.키)));
+    const listed = new Set(items.map((i) => i.키));
+    const sure = opts.모드 === "입력" && opts.확정 === true;
+    // 칸을 고르면 그 칸에 이은 알약 강조 — 칸이 바뀐 첫 그림만 한 번 반짝("new")
+    const at = `${ctx.selection.시트}!${toA1(ctx.selection.활성.r, ctx.selection.활성.c)}`;
+    const fresh = at !== lastAt;
+    lastAt = at;
+    const pills = shown.map((item) => {
+      const hit = map.get(item.키);
+      const here = hit && `${hit.sheet.id}!${hit.link.칸}` === at ? (fresh ? "new" : "same") : "";
+      return pill(item, hit, hues.get(item.키), sure && !!hit && !listed.has(item.키), here);
+    });
     if (opts.모드 === "자재" && opts.자재찾기 && !ctx.readOnly) {
       const more = el("button", {
         className: "ss-link ss-link--add",
@@ -318,6 +354,8 @@ export function mountLinks(
       pills.push(more);
     }
     bar.replaceChildren(...pills);
+    if (fresh)
+      bar.querySelector(".is-here")?.scrollIntoView?.({ block: "nearest", inline: "nearest" });
   }
 
   /** 이은 칸 — 알약 색 옅은 배경 + 왼아래 작은 세모 · 칸이 든 판 층에 얹어 스크롤을 따라감 */
@@ -325,6 +363,8 @@ export function mountLinks(
     for (const d of dots) d.remove();
     dots = [];
     const hues = linkHues(found().keys());
+    const listed = new Set(items.map((i) => i.키));
+    const sure = opts?.모드 === "입력" && opts.확정 === true;
     // 칸마다 이은 알약(이은 차례) — 색 = 먼저 이은 알약 · 둘 넘으면 수
     const byCell = new Map<string, CellLink[]>();
     for (const l of ctx.sheet().연결 ?? []) byCell.set(l.칸, [...(byCell.get(l.칸) ?? []), l]);
@@ -340,6 +380,7 @@ export function mountLinks(
       dot.style.left = `${box.x}px`;
       dot.style.top = `${box.y + box.h - 7}px`;
       const marks = [tint, dot];
+      if (sure && !listed.has(first.키)) tint.classList.add("is-orphan");
       if (list.length > 1) {
         const count = el("div", { className: "ss-link-count", text: String(list.length) });
         count.style.left = `${box.x + box.w}px`;
@@ -350,6 +391,22 @@ export function mountLinks(
       layer.append(...marks);
       dots.push(...marks);
     }
+    // 보낸 범위(도면 표 등) — 채움 없는 점선 테두리 + 왼위 이름표(알약 색 채움과 안 겹침)
+    for (const mark of opts?.표시범위 ?? []) {
+      const g = mark.시트 === ctx.sheet().id ? parseRange(mark.범위) : null;
+      if (!g) continue;
+      const { layer, box } = slot(ctx, g.r0, g.c0);
+      const end = slot(ctx, g.r1, g.c1).box;
+      if (!box.w || !box.h) continue;
+      const frame = el("div", {
+        className: "ss-link-range",
+        attrs: { "data-range": mark.범위 },
+        children: [el("span", { className: "ss-link-range__tag", text: mark.이름 })],
+      });
+      frame.style.cssText = `left:${box.x}px;top:${box.y}px;width:${Math.max(box.w, end.x + end.w - box.x)}px;height:${Math.max(box.h, end.y + end.h - box.y)}px`;
+      layer.append(frame);
+      dots.push(frame);
+    }
   }
 
   /** 칸에 마우스를 올리면 이은 알약 이름들(격자 title) — 이은 칸이 아니면 지움 */
@@ -360,6 +417,11 @@ export function mountLinks(
     const names = a1
       ? (ctx.sheet().연결 ?? []).filter((l) => l.칸 === a1).map((l) => l.이름 ?? l.키)
       : [];
+    if (hit && hit.r >= 0 && hit.c >= 0)
+      for (const m of opts?.표시범위 ?? []) {
+        const g = m.시트 === ctx.sheet().id ? parseRange(m.범위) : null;
+        if (g && inRange(g, hit.r, hit.c)) names.push(m.설명 ?? m.이름);
+      }
     if (names.length) ctx.grid.root.title = names.join(" · ");
     else if (tipped) ctx.grid.root.removeAttribute("title");
     tipped = names.length > 0;
diff --git a/B05_Profile/B05_Profile_Api_Structures.ts b/B05_Profile/B05_Profile_Api_Structures.ts
index 02146289b..c3fb9948f 100644
--- a/B05_Profile/B05_Profile_Api_Structures.ts
+++ b/B05_Profile/B05_Profile_Api_Structures.ts
@@ -14,6 +14,13 @@
 import { readState, writeState } from "../A00_Common/b_page_state";
 import type { GroupItems, SummaryItem } from "../common_util/common_util_summary_item";
 import { API_BASE_URL, API_TIMEOUT_MS } from "@config/config_frontend";
+import {
+  type DefinedRule,
+  type DefinedShape,
+  type DefinedSpot,
+  type StructureDefinition,
+  withDefinition,
+} from "./B05_Profile_UI_Structures_Define";
 
 /** 배치형태 — 점형(측점 1개) / 구간형(시~종점) / 부지형(위치+면적). */
 export type StructurePlacement = "point" | "interval" | "site";
@@ -27,7 +34,7 @@ export interface StructureOptionField {
   default: string | number | null;
   /** 미확정 항목(기본값 없음) — 사용자가 값을 넣어야 저장된다. */
   required?: boolean;
-  /** 거짓이면 폼에 **회색으로** 그려지고 못 고른다 — 칸은 남기되 잠그는 자리. */
+  /** 거짓 = 「안 씀」(48 정의 틀 3장) — 폼에 안 그림 · 옛 값은 그대로 남음. */
   enabled?: boolean;
   /** 입력 시점 — B05는 유무·종류·위치만 받고 상세 치수(detail)는 B06/B07에서 받는다
    *  (2026-08-17 사용자 확정). detail이면 required여도 B05 폼에 그리지 않는다. */
@@ -79,6 +86,18 @@ export interface StructureType {
   enabled: boolean;
   /** 옵션 그룹(M02 PLAN 46) — 폼의 보조 컨테이너(제목 = name) · 안의 옵션 키 · 빈 그룹도 됨. */
   groups?: StructureOptionGroup[];
+  /** 구조물군 이름(48 정의 `구조물군`) — 없으면 화면 기본 이름. */
+  group_name?: string;
+  /** 기준 측점 칸 보임(48 정의 `종류.기준측점`) — false 일 때만 가림. */
+  show_anchor?: boolean;
+  /** 손코딩 특수 동작 이름(48 정의 `종류.동작`) — 그 동작이 붙은 칸 · 폼을 그대로 살림. */
+  behaviors?: string[];
+  /** 옵션 키 → 배치 칸(48 정의 `배치`). */
+  spots?: Record<string, DefinedSpot> | null;
+  /** 상위 → 하위 규칙(48 정의 `규칙` 중 이 종류 것). */
+  rules?: DefinedRule[] | null;
+  /** 구조물 명세 이름 바꿈(52 정의 `종류.이름` · `{컨테이너}[.{항목}[={값}]]: 이름`). */
+  spec_names?: Record<string, string>;
 }
 
 /** 옵션 그룹 한 개 — 서버가 M02 「구조물 옵션 보이기」 그룹 표로 채움. */
@@ -86,6 +105,8 @@ export interface StructureOptionGroup {
   id: string;
   name: string;
   options: string[];
+  /** 그룹이 받을 형상 칸(48 정의 그룹 `형상`) — 길이 · 높이 · 전 · 후 받기 켬끔 + 뜻. */
+  shape?: DefinedShape;
 }
 
 export interface StructureInstance {
@@ -181,10 +202,14 @@ let typesCache: Promise<StructureType[]> | null = null;
  */
 export function fetchStructureTypes(includeDisabled = false): Promise<StructureType[]> {
   if (!typesCache) {
+    // 구조물 정의(48) 덧칸 — 못 받으면 옛 화면 그대로(정의 없음 = 지금 차례 · 2열)
+    const definition = requestJson<StructureDefinition>("/m02/structure-definition", {
+      method: "GET",
+    }).catch(() => null);
     typesCache = requestJson<StructureTypesResponse>("/projects/structure-types", {
       method: "GET",
     })
-      .then((payload) => payload.types)
+      .then(async (payload) => withDefinition(payload.types, await definition))
       .catch((error) => {
         typesCache = null; // 실패한 약속을 남겨 두면 다시 시도할 수 없다.
         throw error;
diff --git a/B05_Profile/B05_Profile_Structures_Repository.py b/B05_Profile/B05_Profile_Structures_Repository.py
index 273874bef..bc2ad31ed 100644
--- a/B05_Profile/B05_Profile_Structures_Repository.py
+++ b/B05_Profile/B05_Profile_Structures_Repository.py
@@ -12,7 +12,11 @@ import os
 import uuid
 from typing import Any, Iterable
 
-from B05_Profile.B05_Profile_Structures_Schema import StructureInstance, structure_type_map
+from B05_Profile.B05_Profile_Structures_Schema import (
+    StructureInstance,
+    definition_version,
+    structure_type_map,
+)
 from common_util.common_util_json import atomic_write_json
 from M02_MasterTemplete.StructOptions.M02_SO_Options import hidden_keys
 
@@ -125,6 +129,8 @@ def save_structures(
         "revision": revision,
         "structures": [item.model_dump(mode="json") for item in items],
         "migrated_legacy": sorted(history),
+        # 저장 때 구조물 정의 판(PLAN 48-1) — 뒤에 정의가 바뀌어도 이 값이 어느 정의로 적혔는지 앎
+        "definition_version": definition_version(),
     }
     atomic_write_json(structures_file_path(project_root), payload)
     return revision
@@ -192,12 +198,15 @@ def _validate_options(item: StructureInstance, definition, hidden: set[str] = fr
     for key, value in item.options.items():
         option = allowed.get(key)
         if option is None:
-            raise ValueError(f"{definition.name}에 정의되지 않은 옵션입니다: {key}")
+            # 지금 정의에 없는 키 = 지난 정의 값 — 버리지 않고 그대로 남김(PLAN 48-0 ② · 오류 없음)
+            continue
         if option.input == "number":
             if isinstance(value, bool) or not isinstance(value, (int, float)):
                 raise ValueError(f"{definition.name}의 {option.label}은(는) 숫자여야 합니다.")
             if not (value == value and abs(value) != float("inf")) or value < 0:
                 raise ValueError(f"{definition.name}의 {option.label}은(는) 0 이상이어야 합니다.")
+        elif option.input == "bool" and not isinstance(value, bool):
+            raise ValueError(f"{definition.name}의 {option.label}은(는) 예 · 아니오여야 합니다.")
         elif option.input == "select" and option.choices and str(value) not in option.choices:
             raise ValueError(f"{definition.name}의 {option.label} 값이 선택지에 없습니다: {value}")
     for option in definition.options:
diff --git a/B05_Profile/B05_Profile_Structures_Schema.py b/B05_Profile/B05_Profile_Structures_Schema.py
index b98fe87e4..3c37ca035 100644
--- a/B05_Profile/B05_Profile_Structures_Schema.py
+++ b/B05_Profile/B05_Profile_Structures_Schema.py
@@ -1,13 +1,15 @@
 """B05 구조물 타입 레지스트리·인스턴스 검증 모델.
 
-구조물 타입 정의는 코드가 아니라 데이터(`B05_Profile_Structure_Types.json`)다. 리스트가
-바뀌어도 코드를 고치지 않도록 분리했고, 프론트는 `GET /structure-types`로 같은 정본을 받는다.
+구조물 타입 정의는 코드가 아니라 데이터(M02 마스터 `resources/master_template/구조물정의.json`
+`types` · PLAN 48-1)다. 리스트가 바뀌어도 코드를 고치지 않도록 분리했고, 프론트는
+`GET /structure-types`로 같은 정본을 받는다. 정의 틀 = `docs/raw/M02_구조물옵션정의/정의_틀.md`.
 
 인스턴스 정본은 `B05_Profile/route/structures.json` **하나뿐**이다(2026-08-16 사용자 확정).
 DB에는 참조 메타만 남긴다 — 두 곳에 같은 값을 두면 어긋난 쪽이 화면에 뜬다(관 매설 지점의
 "복원 유령" 전례).
 """
 
+import copy
 import json
 import os
 from functools import lru_cache
@@ -21,8 +23,12 @@ from common_util.common_util_summary_item import parse_group_items, parse_summar
 STRUCTURE_PLACEMENTS = ("point", "interval", "site")
 STRUCTURE_SIDES = ("left", "right", "center", "cross")
 
-_REGISTRY_PATH = os.path.join(
-    os.path.dirname(os.path.abspath(__file__)), "B05_Profile_Structure_Types.json"
+# 시험은 사본으로 바꿈 — 읽기 캐시는 (경로 · 고친 시각 · 크기)로 갈려 저장 즉시 새로 읽음
+DEFINITION_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "resources",
+    "master_template",
+    "구조물정의.json",
 )
 
 Placement = Literal["point", "interval", "site"]
@@ -35,7 +41,7 @@ class StructureOptionField(BaseModel):
 
     key: str
     label: str
-    input: Literal["select", "number", "text"]
+    input: Literal["select", "number", "text", "bool"]
     choices: list[str] = Field(default_factory=list)
     unit: str | None = None
     default: Any = None
@@ -99,14 +105,37 @@ class StructureType(BaseModel):
     enabled: bool = True
 
 
-@lru_cache(maxsize=1)
-def load_structure_types() -> tuple[StructureType, ...]:
-    """레지스트리 정본을 읽어 타입 목록을 돌려준다(프로세스 수명 동안 1회 로드)."""
-    with open(_REGISTRY_PATH, encoding="utf-8") as handle:
-        payload = json.load(handle)
+def _stamp() -> tuple[str, int, int]:
+    stat = os.stat(DEFINITION_PATH)
+    return DEFINITION_PATH, stat.st_mtime_ns, stat.st_size
+
+
+@lru_cache(maxsize=4)
+def _read_definition(path: str, _mtime: int, _size: int) -> dict[str, Any]:
+    with open(path, encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+@lru_cache(maxsize=4)
+def _read_types(path: str, mtime: int, size: int) -> tuple[StructureType, ...]:
+    payload = _read_definition(path, mtime, size)
     return tuple(StructureType.model_validate(item) for item in payload["types"])
 
 
+def load_definition() -> dict[str, Any]:
+    """구조물 정의 한 벌(사본) — `{판, types, 표시, 그룹, 종류, 배치, 규칙, 동작, …}`."""
+    return copy.deepcopy(_read_definition(*_stamp()))
+
+
+def definition_version() -> int:
+    return int(_read_definition(*_stamp()).get("판", 1))
+
+
+def load_structure_types() -> tuple[StructureType, ...]:
+    """정의 정본을 읽어 타입 목록을 돌려준다(파일이 바뀔 때만 다시 읽음)."""
+    return _read_types(*_stamp())
+
+
 def structure_type_map() -> dict[str, StructureType]:
     return {item.type_id: item for item in load_structure_types()}
 
@@ -132,8 +161,7 @@ def station_planting_labels() -> set[str]:
 
 
 def registry_schema_version() -> int:
-    with open(_REGISTRY_PATH, encoding="utf-8") as handle:
-        return int(json.load(handle).get("schema_version", 1))
+    return int(_read_definition(*_stamp()).get("schema_version", 1))
 
 
 class StructureInstance(BaseModel):
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Facility.ts b/B05_Profile/B05_Profile_UI_Drainage_Facility.ts
index ee870d18b..e7371d120 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Facility.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Facility.ts
@@ -7,10 +7,9 @@
  * 시설 종류는 구조물 배치의 "종류" 드롭다운이, 위치(시작·기준·종료 측점)는 위치
  * 칸이 담당하므로 여기에는 부속 옵션 필드만 있다.
  *
- * 배관 부속(2026-08-17 UI 개편): 관종·관경(기본 1000) 한 행 + 유입구·유출구
- * 소그룹. 유입구는 집수정/기슭막이 택일이고, 유출구는 기슭막이뿐이다(현재 다른
- * 선택지 없음). 기슭막이 조각은 형태·길이·높이·바닥 보호공을 한 벌로 묶어
- * 유입·유출·독립 구조물(D4 기슭막이)이 **같은 인터페이스**를 쓴다.
+ * 배관 부속(PLAN 52-1): 사용자 구조물 표 01 명세 폼(`A00_Common/design/design_structure_pipe`)
+ * — 관 · 관 보호공(유입 · 유출) · 흙막이 추가 · 도수로/돌붙임 컨테이너. 저장 키는 옛 키 그대로 ·
+ * 옛 관종 · 날개벽 · 집수정 형식 칸은 화면에서 빠지고 값은 남음(지난 정의 값).
  *
  * 보호공(2026-08-17 사용자 지시): 구 "돌붙임 있음/없음 + 표면처리(찰/메)" 두 축을
  * `돌붙임(찰)·돌붙임(메)·도수로` 한 축으로 합쳤다. 도수로·산비탈수로(B4)는 유출부에서
@@ -38,26 +37,23 @@ import type {
 import {
   BOX_SIZE_CUSTOM,
   BOX_SIZE_PRESETS,
-  createBasinSplitFields,
-  createRevetmentFields,
   createRevetSideGroup,
   createWingFields,
   grid,
   group,
-  INLET_KINDS,
   INLET_REVET_KEYS,
-  inletKindOf,
   type InletStructureKind,
   labeled,
   numberInput,
   optionalSelect,
   OUTLET_REVET_KEYS,
   putNumber,
-  stepper,
   WING_IN_KEYS,
   WING_OUT_KEYS,
 } from "./B05_Profile_UI_Drainage_Facility_Fields";
-import { pipeWallMinHeightM } from "../common_util/common_util_culvert_sets";
+import { createSpecForm, type SpecLinks } from "../A00_Common/design/design_structure_form";
+import { PIPE_SPEC } from "../A00_Common/design/design_structure_pipe";
+import { guardHeightHint, pipeLengthM } from "../A00_Common/design/design_structure_pipe_calc";
 import {
   hasLinks,
   linkFields,
@@ -206,7 +202,17 @@ export interface FacilityOptionsForm {
     options?: Record<string, string | number>,
     /** 담당 유역의 설계유량(㎥/s) — 물넘이·세월교 개략 단면의 입력. 없으면 안내만. */
     designFlow?: number | null,
+    /** 종류 정의 — 배관 명세 이름 바꿈(`spec_names`) · 그룹 이름(PLAN 52). */
+    definition?: {
+      spec_names?: Record<string, string>;
+      groups?: Array<{ id: string; name: string }>;
+    } | null,
   ) => void;
+  /** 배관 명세 컨테이너 「구조물 조합」 잇기 자리 — 폼이 패널 그룹 값에 이음(PLAN 52-1). */
+  bindLinks: (links: SpecLinks) => void;
+  paintLinks: () => void;
+  /** 고른 관 측점 — 관 길이(자동) 계산에 씀. */
+  setChainage: (chainageM: number | null) => void;
   /** 현재 필드 값을 시설 옵션으로 읽는다(빈 값 생략). 숨긴 칸은 폼이 받은 옛 값 그대로. */
   readOptions: () => Record<string, string | number>;
   /** 「구조물 옵션 보이기」에서 끈 레지스트리 옵션 키 — 그 칸을 가린다(값은 옛 값 보존).
@@ -244,87 +250,56 @@ export function createFacilityOptionsForm(
   root.className = "b05-drainage__facility";
   root.hidden = true;
 
-  // ── 배관 본체 — 관종 > 관경 한 행(2026-08-17 사용자 지시 4) ──────────────
-  // 기본값(관종 파형강관 · 관경 1000 · 등록부)은 시설이 생길 때 칸에 실제 값으로 들어옴(PLAN 46-7).
+  // ── 관종 · 관경 한 행 — 세월교 몫(배관은 아래 명세 폼 · PLAN 52-1) ─────────
   const pipeMaterial = optionalSelect("— 안 정함 —", ["흄관", "VR관", "파형강관"]);
   const pipeDiameter = document.createElement("select");
   pipeDiameter.replaceChildren(
     new Option("— 안 정함 —", ""),
     ...["800", "1000", "1200", "1500"].map((size) => new Option(`Ø${size}`, size)),
   );
-  // 관보호공 날개벽 — **개소당 원단위**가 형식마다 붙박이라 고르는 칸이 있어야 물량이 선다
-  // (2026-09-09, 계획서 4-13 · 소광리 원본 탭 다섯). 비우면 날개벽을 안 센다.
-  const wingWall = optionalSelect("안 놓음", ["A-TYPE", "C-TYPE", "A-TYPE+집수정"]);
   const pipeRow = grid(
     labeled("관종", pipeMaterial, "pipe_kind"),
     labeled("관경", pipeDiameter, "pipe_diameter_mm"),
   );
-  const wingRow = grid(labeled("관보호공 날개벽", wingWall, "wing_wall_type"));
 
-  // ── 유입구 — 집수정 또는 기슭막이 택일(사용자 지시 5~9) ─────────────────
-  const inletGroup = group("유입구");
-  // 「안 정함」이면 기슭막이 칸을 보이되 값은 안 실음.
-  const inletType = document.createElement("select");
-  inletType.replaceChildren(
-    new Option("— 안 정함 —", ""),
-    ...INLET_KINDS.map((kind) => new Option(kind.label, kind.label)),
-  );
-  const basinForm = optionalSelect("선택", [
-    "동물이동형",
-    "□형(기본형)",
-    "돌집수정 ㄴ형",
-    "돌집수정 ㄷ형",
-  ]);
-  // 집수정도 재질·표면처리를 형태 한 축으로 합친다(사용자 지시 1).
-  const basinMaterial = optionalSelect("선택", [
-    "콘크리트",
-    "조립식 주철맨홀",
-    "돌쌓기(찰)",
-    "돌쌓기(메)",
-  ]);
-  const basinMaterialField = labeled("형태", basinMaterial, "inlet_basin_material");
-  // 집수정 종방향 길이 — 3D 예상형상용, 전후 동일 배분·기본 2m(2026-08-23 사용자).
-  const basinLength = numberInput("0.1", "0");
-  // 기준측점 전 · 후 — 옛 횡단 조정창에만 있던 칸을 폼으로(계획서 24-4a).
-  const basinSplit = createBasinSplitFields(basinLength);
-  basinSplit.onChange(() => emit());
-  const basinRows = [
-    grid(
-      labeled("형식", basinForm, "inlet_basin_form"),
-      labeled("길이 (m)", stepper(basinLength, 1), "inlet_basin_length_m"),
-    ),
-    basinSplit.row,
-  ];
-  const height = (): string =>
-    String(pipeWallMinHeightM(Number(pipeDiameter.value || "1000") / 1000));
-  const inletRevet = createRevetmentFields(INLET_REVET_KEYS, { height });
-  // 첫 행 = [구조][형태] — 구조에 따라 집수정 형태와 기슭막이 형태가 갈아 끼워진다
-  // (2026-08-17 사용자 지시 3).
-  // 조정창에서 옮겨 오는 행(단 수·옵션)이 붙을 자리(2026-08-29 사용자 지시 4).
-  // 비어 있으면 아무 자리도 차지하지 않는다.
-  const inletSlot = document.createElement("div");
-  inletSlot.className = "b05-structure__adjust-slot";
-  const outletSlot = inletSlot.cloneNode() as HTMLDivElement;
-  inletGroup.body.append(
-    grid(
-      labeled("구조", inletType, ["inlet_type", "inlet_structure"]),
-      basinMaterialField,
-      inletRevet.formField,
-    ),
-    ...basinRows,
-    ...inletRevet.rows,
-    inletSlot,
-  );
-
-  // ── 유출구 — 구조 선택지는 기슭막이뿐이지만 양식을 맞춘다(사용자 지시 2·4) ──
-  const outletGroup = group("유출구");
-  const outletType = optionalSelect("— 안 정함 —", ["기슭막이"]);
-  const outletRevet = createRevetmentFields(OUTLET_REVET_KEYS, { height });
-  outletGroup.body.append(
-    grid(labeled("구조", outletType, "outlet_type"), outletRevet.formField),
-    ...outletRevet.rows,
-    outletSlot,
+  // ── 배관 = 사용자 구조물 표 01 명세(PLAN 52-1) — 컨테이너 다섯 · 옛 관종 · 날개벽 칸은 뺌(지난 정의 값) ──
+  let linkSource: SpecLinks | null = null;
+  let chainage: number | null = null;
+  const pipeForm = createSpecForm(
+    {
+      get: () => linkSource?.get() ?? {},
+      pick: (key) => linkSource?.pick(key),
+      clear: (key) => linkSource?.clear(key),
+      set: (key, item) => linkSource?.set(key, item),
+    },
+    {
+      auto: (_c, item) => {
+        if (item.id !== "length") return "";
+        const length = pipeLengthM(chainage);
+        return length === null ? "횡단 설계 뒤 셈" : length.toFixed(2);
+      },
+      hint: (c, item, state) => {
+        const soil = c.id !== "inlet" || state.inlet?.[0]?.structure === "기슭막이";
+        return item.id === "height" && soil ? guardHeightHint(state.pipe?.[0]?.diameter ?? "") : "";
+      },
+      onChange: (c, item) => {
+        if (c.id === "inlet" && (item.id === "structure" || item.id === "form"))
+          inletStructureHandler?.(inletStructureOf());
+        emit();
+      },
+    },
   );
+  // 조정창에서 옮겨 오는 행(단 수·옵션)이 붙을 자리 — 유입 · 유출 컨테이너 끝(2026-08-29 지시 4)
+  const inletSlot = pipeForm.slot("inlet");
+  const outletSlot = pipeForm.slot("outlet");
+  /** 유입 보호공 구조 → B06 유입측 형식 값(조정창과 같은 값). */
+  const inletStructureOf = (): InletStructureKind => {
+    const inlet = pipeForm.state().inlet?.[0] ?? {};
+    if (inlet.structure === "기슭막이") return "revet";
+    return inlet.structure === "집수정" && ["I", "L", "U"].includes(inlet.form ?? "")
+      ? (inlet.form as InletStructureKind)
+      : "auto";
+  };
 
   // ── 추가 기슭막이(다단) — 횡단도에서 다단 벽을 고를 때만 뜬다(2026-08-30 사용자
   // 지시 4). 유입구·유출구와 같은 양식이되, 값은 조정창 사본의 행이 그대로 옮겨 온다
@@ -425,13 +400,11 @@ export function createFacilityOptionsForm(
   root.append(
     saveNote,
     pipeRow,
-    wingRow,
+    pipeForm.root,
     ford.widthRow,
     ford.slopeRow,
     ford.countRow,
     ford.summary,
-    inletGroup.root,
-    outletGroup.root,
     extraGroup.root,
     revetTopRow,
     revetInlet.root,
@@ -448,12 +421,8 @@ export function createFacilityOptionsForm(
     if (current === null) return;
     const isPipe = current === "pipe";
     const isBox = current === "box_culvert";
-    // 관종·관경은 배수관과 세월교가 공유한다.
-    pipeRow.hidden = !isPipe && current !== "ford_bridge";
-    // 관보호공 날개벽 원단위는 **배수관 Ø800·Ø1000** 것뿐이다 — 다른 시설에서는 숨긴다.
-    wingRow.hidden = !isPipe;
-    inletGroup.root.hidden = !isPipe;
-    outletGroup.root.hidden = !isPipe;
+    pipeRow.hidden = current !== "ford_bridge";
+    pipeForm.root.hidden = !isPipe;
     boxWrap.hidden = !isBox;
     // 날개벽은 BOX암거와 세월교가 같은 옵션 한 벌을 쓴다(2026-08-25 사용자 확정).
     const hasWing = isBox || current === "ford_bridge";
@@ -482,17 +451,6 @@ export function createFacilityOptionsForm(
       wingInFields.syncVisibility();
       wingOutFields.syncVisibility();
     }
-    if (isPipe) {
-      // 유입구 구조에 따라 집수정 칸과 기슭막이 칸을 갈아 끼운다(사용자 지시 6~8).
-      // 병합 목록이라 판정은 라벨이 아니라 매핑된 정본 종류로 한다(2026-08-29).
-      const kind = inletKindOf(inletType.value);
-      const basin = kind.type === "집수정";
-      const revet = kind.type === "기슭막이";
-      basinRows.forEach((row) => (row.hidden = !basin));
-      basinMaterialField.hidden = !basin;
-      inletRevet.formField.hidden = !revet;
-      inletRevet.rows.forEach((row) => (row.hidden = !revet));
-    }
   }
 
   function emit(): void {
@@ -500,11 +458,6 @@ export function createFacilityOptionsForm(
     callbacks.onChange?.();
   }
 
-  [inletType, outletType, wingWall, basinForm, basinMaterial, basinLength].forEach((input) =>
-    input.addEventListener("change", emit),
-  );
-  inletRevet.onChange(emit);
-  outletRevet.onChange(emit);
   revetInlet.fields.onChange(emit);
   revetOutlet.fields.onChange(emit);
   revetSide.addEventListener("change", emit);
@@ -521,9 +474,6 @@ export function createFacilityOptionsForm(
 
   /** 유입구 구조 변경 수신자(B06 유입측 형식 제어). B05는 비워 둔다. */
   let inletStructureHandler: ((value: InletStructureKind) => void) | null = null;
-  inletType.addEventListener("change", () =>
-    inletStructureHandler?.(inletKindOf(inletType.value).structure),
-  );
 
   return {
     root,
@@ -538,23 +488,31 @@ export function createFacilityOptionsForm(
       revetSideLabels = labels;
       syncVisibility();
     },
-    inletStructure: () => inletKindOf(inletType.value).structure,
+    inletStructure: inletStructureOf,
     setInletStructure(value) {
-      // 지금 고른 정본 종류(기슭막이/집수정)는 지키고 형식만 맞춘다.
-      const type = inletKindOf(inletType.value).type;
-      const hit =
-        INLET_KINDS.find((kind) => kind.type === type && kind.structure === value) ??
-        INLET_KINDS.find((kind) => kind.structure === value);
-      if (hit) inletType.value = hit.label;
+      // 조정창 형식 → 유입 보호공 구조 · 형태(자동 = 고른 구조는 지키고 형태만 비움)
+      if (value === "revet") pipeForm.setValue("inlet", "structure", "기슭막이");
+      else if (value !== "auto") pipeForm.setValue("inlet", "structure", "집수정");
+      if (value !== "revet" && pipeForm.state().inlet?.[0]?.structure === "집수정")
+        pipeForm.setValue("inlet", "form", value === "auto" ? "" : value);
       syncVisibility();
     },
+    bindLinks(links) {
+      linkSource = links;
+      pipeForm.paintLinks();
+    },
+    paintLinks: () => pipeForm.paintLinks(),
+    setChainage(chainageM) {
+      chainage = chainageM;
+      if (current === "pipe") pipeForm.refresh();
+    },
     onInletStructureChange(handler) {
       inletStructureHandler = handler;
     },
     setHiddenOptions(facility, registryKeys) {
       hiddenOptions.set(facility, registryKeys);
     },
-    setFacility(facility, options = {}, designFlow = null) {
+    setFacility(facility, options = {}, designFlow = null, definition = null) {
       current = facility;
       hiddenOptions.remember(options);
       ford.setDesignFlow(designFlow ?? null);
@@ -567,25 +525,10 @@ export function createFacilityOptionsForm(
       // 받은 값만 칸에 — 없으면 「안 정함」(새 시설은 부르는 쪽이 등록부 기본값을 실어 줌 · 46-7).
       pipeMaterial.value = text("pipe_kind");
       pipeDiameter.value = text("pipe_diameter_mm");
-      // 병합 목록: 저장된 정본 둘(inlet_type·inlet_structure)로 라벨을 되찾는다.
-      const savedType = text("inlet_type");
-      const savedStructure = text("inlet_structure");
-      inletType.value = savedType
-        ? (
-            INLET_KINDS.find(
-              (kind) =>
-                kind.type === savedType && (!savedStructure || kind.structure === savedStructure),
-            ) ?? inletKindOf(savedType)
-          ).label
-        : "";
-      outletType.value = text("outlet_type");
-      wingWall.value = text("wing_wall_type");
-      basinForm.value = text("inlet_basin_form");
-      basinMaterial.value = text("inlet_basin_material");
-      basinLength.value = text("inlet_basin_length_m");
-      basinSplit.write(options);
-      inletRevet.write(options);
-      outletRevet.write(options);
+      if (facility === "pipe") {
+        const groups = Object.fromEntries((definition?.groups ?? []).map((g) => [g.id, g.name]));
+        pipeForm.write(PIPE_SPEC, options, definition?.spec_names ?? {}, groups);
+      }
       // 저장된 폭·높이가 프리셋과 맞으면 그 프리셋을, 아니면 "사용자 지정"을 고른다.
       // 값이 없으면 「안 정함」.
       const savedWidth = Number.parseFloat(text("body_width_m"));
@@ -625,24 +568,7 @@ export function createFacilityOptionsForm(
         if (pipeMaterial.value) options.pipe_kind = pipeMaterial.value;
       };
       if (current === "pipe") {
-        putPipe();
-        const inletKind = inletKindOf(inletType.value);
-        if (wingWall.value) options.wing_wall_type = wingWall.value;
-        // B06 유입측 형식(조정창과 같은 값) — 병합 드롭다운이 함께 정한다(2026-08-29).
-        if (inletType.value) {
-          options.inlet_type = inletKind.type;
-          options.inlet_structure = inletKind.structure;
-        }
-        if (inletKind.type === "집수정") {
-          if (basinForm.value) options.inlet_basin_form = basinForm.value;
-          if (basinMaterial.value) options.inlet_basin_material = basinMaterial.value;
-          putNumber(options, "inlet_basin_length_m", basinLength.value);
-          basinSplit.read(options);
-        } else {
-          inletRevet.read(options);
-        }
-        if (outletType.value) options.outlet_type = outletType.value;
-        outletRevet.read(options);
+        Object.assign(options, pipeForm.read()); // 명세 컨테이너 값 = 옛 키 그대로(PLAN 52-1)
       } else if (current === "box_culvert") {
         // 프리셋을 골랐든 사용자 지정을 적었든 정본은 폭·높이 두 칸이다.
         putNumber(options, "body_width_m", boxWidth.value);
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Facility_Merge.ts b/B05_Profile/B05_Profile_UI_Drainage_Facility_Merge.ts
index 9a33297c5..4e6afd657 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Facility_Merge.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Facility_Merge.ts
@@ -26,15 +26,14 @@ const wingKeys = (side: "in" | "out"): string[] => [
 
 /** 시설 종류별로 **폼이 적는 칸** — `createFacilityOptionsForm().readOptions()` 가 쓰는 키 전부. */
 export const FORM_OPTION_KEYS: Readonly<Record<string, readonly string[]>> = {
+  // 배관 = 표 01 명세 키(PLAN 52-1 · `design_structure_pipe`) — 옛 관종 · 날개벽 · 집수정 형식은 폼에서
+  // 빠져 이어 붙임(지난 정의 값) · 선택 컨테이너 키는 `FORM_OPTION_PREFIXES`
   pipe: [
     "pipe_diameter_mm",
-    "pipe_kind",
-    "wing_wall_type",
     "inlet_type",
     "inlet_structure",
-    "inlet_basin_form",
-    "inlet_basin_material",
     "inlet_basin_length_m",
+    "inlet_basin_height_m",
     "inlet_basin_before_m",
     "inlet_basin_after_m",
     ...revetKeys("inlet"),
@@ -55,6 +54,11 @@ export const FORM_OPTION_KEYS: Readonly<Record<string, readonly string[]>> = {
   revetment: ["side", ...revetKeys("inlet"), ...revetKeys("outlet")],
 };
 
+/** 폼이 인스턴스 번호를 붙여 적는 키 머리(명세 선택 컨테이너 · `{머리}{n}_{항목}`) — 빼면 지워짐. */
+export const FORM_OPTION_PREFIXES: Readonly<Record<string, readonly string[]>> = {
+  pipe: ["soil_add_", "chute_add_"],
+};
+
 /** 독립 기슭막이 레지스트리 키 → 폼은 유입·유출 두 채널 키로 적는다. */
 const REVETMENT_FIELDS = ["form", "length_m", "height_m", "before_m", "after_m"];
 
@@ -95,7 +99,10 @@ export function mergeFacilityOptions<T extends MergeableAttributes>(
 ): T {
   if (!previous || previous.facility !== next.facility) return next;
   const managed = new Set(FORM_OPTION_KEYS[next.facility] ?? []);
-  const kept = Object.entries(previous.options ?? {}).filter(([key]) => !managed.has(key));
+  const heads = FORM_OPTION_PREFIXES[next.facility] ?? [];
+  const kept = Object.entries(previous.options ?? {}).filter(
+    ([key]) => !managed.has(key) && !heads.some((head) => key.startsWith(head)),
+  );
   const options = { ...Object.fromEntries(kept), ...(next.options ?? {}) };
   const summary =
     next.summary_item === undefined && previous.summary_item !== undefined
diff --git a/B05_Profile/B05_Profile_UI_Structures_Define.ts b/B05_Profile/B05_Profile_UI_Structures_Define.ts
new file mode 100644
index 000000000..4c5ecf599
--- /dev/null
+++ b/B05_Profile/B05_Profile_UI_Structures_Define.ts
@@ -0,0 +1,217 @@
+/* =============================================================================
+ * B05_Profile_UI_Structures_Define.ts
+ * 구조물 정의 → 「구조물 배치」 칸 모양 (PLAN 48-3 · 48-4) — 화면 요소 없는 순수 규칙.
+ *
+ * 정의(`resources/master_template/구조물정의.json` · GET /structure-types 가 실어 줌)를 읽어
+ * 칸 차례 · 격자 · 안 씀 · 규칙(상위 값 → 하위 선택지 · 보이기 · 기본값)을 낸다. 틀 =
+ * `docs/raw/M02_구조물옵션정의/정의_틀.md`. 선택지를 줄이면(숨김) 옛 값은 그 값만 남겨 보임.
+ * 그리기는 `_Structures_Panel_Options`(레지스트리 칸) · `_Structures_Define_Form`(시설 폼 칸).
+ * 값에 따른 계산 · 연동 제어는 여기 없음(48-5).
+ * import 없음 — 시험이 이 파일만 옮겨 돌림.
+ * ========================================================================== */
+
+/** 정의가 옵션 하나에 실어 주는 몫 — 칸 그리기가 쓰는 것만. */
+export interface DefinedOption {
+  key: string;
+  label: string;
+  input: string;
+  choices: string[];
+  default: string | number | null;
+  visible?: boolean;
+  /** 거짓 = 「안 씀」(정의 틀 3장) — 칸을 안 그림 · 옛 값은 그대로 남음. */
+  enabled?: boolean;
+}
+
+/** 상위 → 하위 규칙 한 줄(정의 `규칙`) — 상위 칸 값이 `만약.값들` 중 하나면 하위 칸에 `그러면` 을 씀. */
+export interface DefinedRule {
+  종류?: string;
+  만약: { 옵션: string; 값들: Array<string | number> };
+  그러면: {
+    옵션: string;
+    /** 하위 칸 선택지를 이 목록으로 좁힘. */
+    선택지?: string[];
+    /** 하위 칸을 보이거나 가림. */
+    보이기?: boolean;
+    /** 상위 값이 바뀌어 이 줄이 걸리면 하위 칸 값을 이 값으로. */
+    기본값?: string | number | null;
+  };
+}
+
+/** 배치 격자 한 칸 — 정의 `배치` 의 `{줄, 칸, 너비}`(1부터). */
+export interface DefinedSpot {
+  줄?: number;
+  칸?: number;
+  너비?: number;
+}
+
+export interface DefinedType {
+  options: DefinedOption[];
+  /** 종류 덧칸 — 기준 측점 칸 보임(기본 보임). */
+  show_anchor?: boolean;
+  /** 옵션 키 → 배치 칸. 비면 정의 옵션 차례대로 2열. */
+  spots?: Record<string, DefinedSpot> | null;
+  rules?: DefinedRule[] | null;
+}
+
+/** 칸 하나의 지금 모양 — 규칙을 건 뒤. */
+export interface OptionState {
+  visible: boolean;
+  choices: string[];
+}
+
+const whole = (n: unknown): number | null =>
+  typeof n === "number" && Number.isInteger(n) && n >= 1 ? n : null;
+
+/** 그릴 옵션 차례 — 배치가 있으면 (줄, 칸) 차례 · 없는 칸은 뒤에 정의 차례로. 안 씀 · 숨김은 뺌. */
+export function orderedOptions<T extends DefinedOption>(type: {
+  options: T[];
+  spots?: Record<string, DefinedSpot> | null;
+}): T[] {
+  const spots = type.spots ?? {};
+  const rank = (key: string): [number, number] => {
+    const spot = spots[key];
+    return [whole(spot?.줄) ?? Infinity, whole(spot?.칸) ?? Infinity];
+  };
+  return type.options
+    .map((option, index) => ({ option, index, at: rank(option.key) }))
+    .filter(({ option }) => option.enabled !== false && option.visible !== false)
+    .sort((a, b) => a.at[0] - b.at[0] || a.at[1] - b.at[1] || a.index - b.index)
+    .map(({ option }) => option);
+}
+
+/** 한 줄 칸 수 — 배치가 쓰는 가장 오른쪽 칸(1 ~ 6) · 배치 없으면 2. */
+export function columnsOf(type: { spots?: Record<string, DefinedSpot> | null }): number {
+  let widest = 0;
+  for (const spot of Object.values(type.spots ?? {})) {
+    const col = whole(spot.칸) ?? 1;
+    widest = Math.max(widest, col + (whole(spot.너비) ?? 1) - 1);
+  }
+  return widest ? Math.min(Math.max(widest, 2), 6) : 2;
+}
+
+/** 칸 하나의 CSS 격자 자리 — 배치 없으면 null(흐름대로). */
+export function gridPlace(
+  spot: DefinedSpot | undefined,
+  columns: number,
+): { row: string; column: string } | null {
+  if (!spot) return null;
+  const row = whole(spot.줄);
+  const col = whole(spot.칸);
+  const span = Math.min(whole(spot.너비) ?? 1, columns);
+  return {
+    row: row ? String(row) : "",
+    column: col ? `${Math.min(col, columns)} / span ${span}` : `span ${span}`,
+  };
+}
+
+/** 기준 측점 칸을 보일지 — 정의가 끈 때만 가림. */
+export function showsAnchor(type: { show_anchor?: boolean }): boolean {
+  return type.show_anchor !== false;
+}
+
+const same = (a: unknown, b: unknown): boolean => String(a ?? "") === String(b ?? "");
+
+/** 규칙을 지금 값에 건 칸 모양 — 걸린 줄의 선택지 · 보이기가 정의 기본을 덮음(뒤 줄이 이김). */
+export function ruleStates(
+  type: DefinedType,
+  values: Record<string, string | number | undefined>,
+): Map<string, OptionState> {
+  const states = new Map<string, OptionState>();
+  for (const option of type.options)
+    states.set(option.key, { visible: true, choices: [...option.choices] });
+  for (const rule of type.rules ?? []) {
+    const state = states.get(rule.그러면.옵션);
+    // 가려진 상위 칸에 매인 줄은 안 걸림 — 가림이 사슬로 이어짐(정의 차례대로 적용)
+    if (!state || states.get(rule.만약.옵션)?.visible === false) continue;
+    if (!hits(rule, values)) continue;
+    const pick = rule.그러면.선택지;
+    if (pick) state.choices = pick.filter((c) => state.choices.includes(c));
+    if (typeof rule.그러면.보이기 === "boolean") state.visible = rule.그러면.보이기;
+  }
+  return states;
+}
+
+const hits = (rule: DefinedRule, values: Record<string, unknown>): boolean =>
+  rule.만약.값들.some((value) => same(value, values[rule.만약.옵션]));
+
+/** 상위 값이 바뀌었을 때 하위 칸에 넣을 기본값 `{하위 키: 값}` — 걸린 줄 중 기본값이 있는 것만. */
+export function ruleDefaults(
+  type: DefinedType,
+  parent: string,
+  values: Record<string, string | number | undefined>,
+): Record<string, string | number> {
+  const out: Record<string, string | number> = {};
+  for (const rule of type.rules ?? []) {
+    const value = rule.그러면.기본값;
+    if (rule.만약.옵션 !== parent || value === undefined || value === null) continue;
+    if (hits(rule, values)) out[rule.그러면.옵션] = value;
+  }
+  return out;
+}
+
+/** 지금 정의에 없는 키의 값 — 「지난 정의 값」 읽기만 칸으로 보임. `known` = 폼이 아는 키 전부. */
+export function staleValues(
+  values: Record<string, string | number> | undefined,
+  known: Iterable<string>,
+): Array<[string, string | number]> {
+  const keys = new Set(known);
+  return Object.entries(values ?? {}).filter(([key]) => !keys.has(key));
+}
+
+/** 그룹 형상 칸(정의 틀 4장) — 길이 · 높이 · 기준 측점 전 · 후 마다 받기 켬끔 + 뜻. */
+export type ShapeName = "길이" | "높이" | "전" | "후";
+export const SHAPE_FIELDS: ReadonlyArray<{ name: ShapeName; suffix: string; label: string }> = [
+  { name: "길이", suffix: "length_m", label: "길이 (m)" },
+  { name: "높이", suffix: "height_m", label: "높이 (m)" },
+  { name: "전", suffix: "before_m", label: "기준측점 전 (m)" },
+  { name: "후", suffix: "after_m", label: "기준측점 후 (m)" },
+];
+export type DefinedShape = Partial<Record<ShapeName, { 받기?: boolean; 뜻?: string }>>;
+
+/** 그룹 형상 값 저장 키 — 구조물 옵션에 `{그룹 id}__{칸}` 으로 둠. */
+export const shapeKey = (groupId: string, suffix: string): string => `${groupId}__${suffix}`;
+
+/** 그룹이 받는 형상 칸 — 받기 켠 것만 정해진 차례로. */
+export function shapeFields(
+  shape: DefinedShape | undefined,
+): Array<{ suffix: string; label: string; meaning: string }> {
+  return SHAPE_FIELDS.filter((f) => shape?.[f.name]?.받기 === true).map((f) => ({
+    suffix: f.suffix,
+    label: f.label,
+    meaning: shape?.[f.name]?.뜻 ?? "",
+  }));
+}
+
+/** 정의 한 벌(GET /m02/structure-definition) 중 화면이 쓰는 칸. */
+export interface StructureDefinition {
+  판?: number;
+  구조물군?: Record<string, string>;
+  종류?: Record<string, { 기준측점?: boolean; 동작?: string[]; 이름?: Record<string, string> }>;
+  그룹?: Record<string, Array<{ id: string; 이름?: string; 형상?: DefinedShape }>>;
+  배치?: Record<string, Record<string, DefinedSpot>>;
+  규칙?: DefinedRule[];
+}
+
+/** 종류 목록에 정의 덧칸을 얹음 — 구조물군 이름 · 기준 측점 · 동작 · 배치 · 규칙 · 그룹 형상.
+ *  정의를 못 받았으면(null) 그대로 — 지금 화면과 같음. */
+export function withDefinition<
+  T extends { type_id: string; group: string; groups?: Array<{ id: string }> },
+>(types: T[], definition: StructureDefinition | null): T[] {
+  if (!definition) return types;
+  return types.map((type) => {
+    const kind = definition.종류?.[type.type_id] ?? {};
+    const shapes = new Map((definition.그룹?.[type.type_id] ?? []).map((g) => [g.id, g.형상]));
+    return {
+      ...type,
+      group_name: definition.구조물군?.[type.group],
+      show_anchor: kind.기준측점,
+      behaviors: kind.동작 ?? [],
+      spec_names: kind.이름 ?? {},
+      spots: definition.배치?.[type.type_id] ?? null,
+      rules: (definition.규칙 ?? []).filter((rule) => rule.종류 === type.type_id),
+      ...(type.groups
+        ? { groups: type.groups.map((g) => ({ ...g, shape: shapes.get(g.id) })) }
+        : {}),
+    };
+  });
+}
diff --git a/B05_Profile/B05_Profile_UI_Structures_Define_Form.ts b/B05_Profile/B05_Profile_UI_Structures_Define_Form.ts
new file mode 100644
index 000000000..e3e44d790
--- /dev/null
+++ b/B05_Profile/B05_Profile_UI_Structures_Define_Form.ts
@@ -0,0 +1,85 @@
+/* =============================================================================
+ * B05_Profile_UI_Structures_Define_Form.ts
+ * 손코딩 시설 폼(동작 「계곡통과시설」)에 정의를 붙임(PLAN 48-3 · 48-4) — 숨긴 선택지 · 규칙.
+ *
+ * · 칸은 `labeled(..., 옵션키)` 가 붙인 `data-option-keys` 표식으로 찾음(키 하나인 칸만) · 찾는 자리 =
+ *   폼 본문 전체(그룹 상자로 옮겨 간 칸까지).
+ * · 칸 배치 · 이름은 손코딩 그대로(동작이 그림) — 안 씀은 끈 옵션과 같은 길(`_Drainage_Facility_Hidden`).
+ * · 선택지 = 정의 · 규칙 선택지 — 새 선택지는 보기를 더하고 밖 보기는 `hidden` 으로만 가림(옛 값은 그대로).
+ *   여러 키를 함께 적는 칸(유입구 구조 · 본체 규격)은 키 하나 표식이 아니라 안 건드림.
+ * · 규칙이 가린 칸 = `is-rule-hidden`(끈 옵션 표식 `is-option-hidden` 과 따로).
+ * ========================================================================== */
+
+import type { StructureType } from "./B05_Profile_Api_Structures";
+import { ruleDefaults, ruleStates } from "./B05_Profile_UI_Structures_Define";
+import { isOptionVisible } from "./B05_Profile_UI_Structures_Summary";
+
+/** 시설 폼이 가릴 옵션 키 — 「구조물 옵션 보이기」에서 끈 것 + 정의 「안 씀」. */
+export function hiddenOptionKeys(type: StructureType | null): string[] {
+  return (type?.options ?? []).filter((o) => !isOptionVisible(o)).map((o) => o.key);
+}
+
+export interface FacilityDefinition {
+  /** 지금 종류 정의로 칸 모양을 맞춤 — 시설 폼을 채운 뒤마다 부름. */
+  apply: (type: StructureType | null) => void;
+}
+
+export function createFacilityDefinition(root: HTMLElement): FacilityDefinition {
+  let type: StructureType | null = null;
+  const wrapOf = (key: string): HTMLElement | null =>
+    [...root.querySelectorAll<HTMLElement>("[data-option-keys]")].find(
+      (node) => node.dataset.optionKeys === key,
+    ) ?? null;
+  const controlOf = (key: string): HTMLInputElement | HTMLSelectElement | null =>
+    wrapOf(key)?.querySelector<HTMLInputElement | HTMLSelectElement>("select, input") ?? null;
+  const values = (): Record<string, string> =>
+    Object.fromEntries((type?.options ?? []).map((o) => [o.key, controlOf(o.key)?.value ?? ""]));
+
+  const paint = (): void => {
+    if (!type) return;
+    const states = ruleStates(type, values());
+    for (const option of type.options) {
+      const wrap = wrapOf(option.key);
+      const state = states.get(option.key);
+      if (!wrap || !state) continue;
+      wrap.classList.toggle("is-rule-hidden", !state.visible);
+      const control = controlOf(option.key);
+      if (!(control instanceof HTMLSelectElement)) continue;
+      // 정의에 새로 든 선택지는 보기를 더하고, 정의 · 규칙 밖 보기는 가림(빈 보기 · 지금 값은 그대로)
+      const have = new Set([...control.options].map((item) => item.value));
+      for (const choice of state.choices)
+        if (!have.has(choice)) control.add(new Option(choice, choice));
+      for (const item of control.options) {
+        item.hidden =
+          !!item.value && !state.choices.includes(item.value) && item.value !== control.value;
+      }
+    }
+  };
+
+  // 상위 칸이 바뀌면 걸린 규칙의 기본값을 하위 칸에 넣고, 그 칸의 change 로 폼 반영(시설 폼 emit)을 잇는다.
+  root.addEventListener("change", (event) => {
+    if (!type) return;
+    const key = (event.target as HTMLElement).closest<HTMLElement>("[data-option-keys]")?.dataset
+      .optionKeys;
+    if (key) {
+      for (const [child, value] of Object.entries(ruleDefaults(type, key, values()))) {
+        const control = controlOf(child);
+        if (!control || control.value === String(value)) continue;
+        control.value = String(value);
+        control.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+    }
+    paint();
+  });
+
+  return {
+    apply(next) {
+      type = next;
+      root
+        .querySelectorAll(".is-rule-hidden")
+        .forEach((node) => node.classList.remove("is-rule-hidden"));
+      root.querySelectorAll<HTMLOptionElement>("option[hidden]").forEach((o) => (o.hidden = false));
+      paint();
+    },
+  };
+}
diff --git a/B05_Profile/B05_Profile_UI_Structures_Fields.ts b/B05_Profile/B05_Profile_UI_Structures_Fields.ts
index 2581b79ee..ed31f4ce4 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Fields.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Fields.ts
@@ -74,7 +74,12 @@ export function optionControl(
   const tip = option.not_in_table ?? option.empty_means ?? "";
   if (option.input === "select") {
     const blank = option.required ? "— 선택 —" : "— 안 정함 —";
-    const element = select([["", blank], ...option.choices.map((c) => [c, c] as [string, string])]);
+    // 정의에서 뺀 선택지(48)를 고른 옛 값 — 그 값만 남겨 보임(값을 잃지 않음)
+    const kept = value && !option.choices.includes(value) ? [value] : [];
+    const element = select([
+      ["", blank],
+      ...[...option.choices, ...kept].map((c) => [c, c] as [string, string]),
+    ]);
     element.value = value;
     if (tip) element.title = tip;
     return element;
diff --git a/B05_Profile/B05_Profile_UI_Structures_Form.ts b/B05_Profile/B05_Profile_UI_Structures_Form.ts
index 980e75b36..c0e28f3fc 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Form.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Form.ts
@@ -24,6 +24,10 @@ import {
 import { createFacilityOptionsForm } from "./B05_Profile_UI_Drainage_Facility";
 import { buildSummaryRow, type SummaryRow } from "./B05_Profile_UI_Structures_Summary_Row";
 import { createGroupBoxes, type GroupBoxes } from "./B05_Profile_UI_Structures_Groups";
+import {
+  createFacilityDefinition,
+  type FacilityDefinition,
+} from "./B05_Profile_UI_Structures_Define_Form";
 
 export interface StructuresFormElements {
   root: HTMLElement;
@@ -46,6 +50,10 @@ export interface StructuresFormElements {
   /** 버튼 묶음 — 패널이 그 앞에 메모 칸을 끼워 넣는다. */
   actions: HTMLElement;
   facilityOptions: ReturnType<typeof createFacilityOptionsForm>;
+  /** 「지난 정의 값」 읽기만 상자(48-3) — 지금 정의에 없는 키의 값. */
+  staleBox: HTMLElement;
+  /** 시설 폼(손코딩)에 정의 붙이기(48-3 · 48-4) — 숨긴 선택지 · 규칙. */
+  facilityDefinition: FacilityDefinition;
   primary: HTMLButtonElement;
   removeButton: HTMLButtonElement;
   resetButton: HTMLButtonElement;
@@ -148,15 +156,27 @@ export function buildStructuresForm(options: {
   const summary = buildSummaryRow();
   summary.root.hidden = true;
   const groupBoxes = createGroupBoxes();
+  // 배관 명세 컨테이너 「구조물 조합」 잇기 = 그룹 값(`group_items`)과 같은 자리 · 같은 [고르기] 길(PLAN 52-1)
+  facilityOptions.bindLinks({
+    get: groupBoxes.get,
+    pick: groupBoxes.pick,
+    clear: groupBoxes.clear,
+    set: groupBoxes.setOne,
+  });
+  groupBoxes.watch(facilityOptions.paintLinks);
+  const staleBox = document.createElement("fieldset");
+  staleBox.className = "b05-structure__group b05-structure__stale";
+  staleBox.hidden = true;
 
   body.append(
     typeRow,
     ownerNote,
     positionRow,
+    summary.root, // 종류 단위 「구조물 조합」 잇기 — 기준 측점 바로 아래(PLAN 52-1 · 컨테이너 없는 종류)
     positionDivider,
     optionRow,
     facilityOptions.root,
-    summary.root,
+    staleBox,
     groupBoxes.root,
     actions,
   );
@@ -178,6 +198,8 @@ export function buildStructuresForm(options: {
     optionRow,
     actions,
     facilityOptions,
+    staleBox,
+    facilityDefinition: createFacilityDefinition(body),
     primary,
     removeButton,
     resetButton,
diff --git a/B05_Profile/B05_Profile_UI_Structures_Groups.ts b/B05_Profile/B05_Profile_UI_Structures_Groups.ts
index 1f7fce79d..f41119d99 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Groups.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Groups.ts
@@ -10,6 +10,8 @@
  *   독립 기슭막이 채널 키는 `hiddenFormKeys` 로 넓힘).
  * · 그룹 연결 값(`{그룹 id: 참조}`)은 정의가 사라진 그룹 것도 그대로 쥠(값 보존 · 경고 한 줄).
  * · 저장은 패널이 한다(`group_items` 칸) — 여기는 값만 쥠.
+ * · 그룹 형상 칸(48 정의 그룹 `형상` · 길이 · 높이 · 전 · 후 받기 켬끔) — 값은 구조물 옵션
+ *   `{그룹 id}__{칸}` 으로 저장(패널이 옵션에 얹음) · 계산은 안 함(48-5).
  * ========================================================================== */
 
 import { openItemPicker } from "@ui/ui_template_item_picker";
@@ -17,6 +19,10 @@ import { pipeStructureId } from "@ui/ui_template_item_picker_project";
 import type { StructureType } from "./B05_Profile_Api_Structures";
 import { hiddenFormKeys } from "./B05_Profile_UI_Drainage_Facility_Merge";
 import { buildSummaryRow, type SummaryRow } from "./B05_Profile_UI_Structures_Summary_Row";
+import { isOptionVisible } from "./B05_Profile_UI_Structures_Summary";
+import { SHAPE_FIELDS, shapeFields, shapeKey } from "./B05_Profile_UI_Structures_Define";
+import { field, numberInput } from "./B05_Profile_UI_Structures_Fields";
+import { STRUCTURE_SPECS } from "../A00_Common/design/design_structure_pipe";
 import {
   GROUP_JOIN,
   type GroupItems,
@@ -33,8 +39,25 @@ export interface GroupBoxes {
   set: (items: GroupItems) => void;
   /** 한 그룹 값 — null = 해제. */
   setOne: (groupId: string, item: SummaryItem | null) => void;
-  /** [고르기] · [해제] 배선 — 패널이 한 번 부른다. */
-  bind: (handlers: { pick: (groupId: string) => void; clear: (groupId: string) => void }) => void;
+  /** [고르기] · [해제] · 형상 칸 고침 배선 — 패널이 한 번 부른다. */
+  bind: (handlers: GroupHandlers) => void;
+  /** 형상 칸 값 `{그룹 id}__{칸}: 수` — 빈 칸은 뺌. 옵션에 얹어 저장. */
+  shapes: () => Record<string, number>;
+  /** 지금 종류 그룹의 형상 키 전부(받기 끈 칸 포함) — 저장 병합 · 지난 정의 값 판정. */
+  shapeKeys: (type?: StructureType | null) => string[];
+  /** 구조물 옵션에서 형상 값을 실음(폼 불러오기). */
+  setShapes: (options: Record<string, string | number> | undefined) => void;
+  /** 명세 컨테이너 잇기 줄(PLAN 52-1)이 쓰는 [고르기] · [해제] — 그룹 상자와 같은 길. */
+  pick: (groupId: string) => void;
+  clear: (groupId: string) => void;
+  /** 값이 바뀔 때마다 부름(명세 컨테이너 잇기 줄 다시 그림). */
+  watch: (listener: () => void) => void;
+}
+
+interface GroupHandlers {
+  pick: (groupId: string) => void;
+  clear: (groupId: string) => void;
+  change?: () => void;
 }
 
 export function createGroupBoxes(): GroupBoxes {
@@ -43,7 +66,14 @@ export function createGroupBoxes(): GroupBoxes {
   root.dataset.b05Groups = "";
   root.hidden = true;
   let items: GroupItems = {};
-  let handlers: { pick: (id: string) => void; clear: (id: string) => void } | null = null;
+  let handlers: GroupHandlers | null = null;
+  let shapes: Record<string, string> = {};
+  let current: StructureType | null = null;
+  const listeners: Array<() => void> = [];
+  const changed = (): void => listeners.forEach((listener) => listener());
+  const keysOf = (type: StructureType | null | undefined): string[] =>
+    (type?.groups ?? []).flatMap((g) => SHAPE_FIELDS.map((f) => shapeKey(g.id, f.suffix)));
+  const shapeInputs = new Map<string, HTMLInputElement>();
   const rows = new Map<string, SummaryRow>();
   /** 옮긴 칸 · 제자리 표지 */
   const moved: Array<{ node: HTMLElement; mark: Comment }> = [];
@@ -83,13 +113,16 @@ export function createGroupBoxes(): GroupBoxes {
     render(type, scopes, facility) {
       restore();
       rows.clear();
-      const groups = type?.groups ?? [];
+      shapeInputs.clear();
+      current = type;
+      // 명세 종류(PLAN 52 · 배관)는 컨테이너가 잇기 줄을 가짐 — 그룹 상자를 안 세움
+      const groups = type && STRUCTURE_SPECS[type.type_id] ? [] : (type?.groups ?? []);
       const boxes: HTMLElement[] = [];
       bodies = [];
       // 「구조물 옵션 보이기」에서 끈 칸 — 시설 폼 밖으로 옮긴 칸도 같은 규칙으로 가림(Hidden 과 같은 식)
       const off = hiddenFormKeys(
         facility,
-        (type?.options ?? []).filter((o) => o.visible === false).map((o) => o.key),
+        (type?.options ?? []).filter((o) => !isOptionVisible(o)).map((o) => o.key),
       );
       for (const group of groups) {
         const keys = hiddenFormKeys(facility, group.options);
@@ -133,6 +166,19 @@ export function createGroupBoxes(): GroupBoxes {
             }
           }
         }
+        for (const shape of shapeFields(group.shape)) {
+          const key = shapeKey(group.id, shape.suffix);
+          const input = numberInput("0.1", "0");
+          input.value = shapes[key] ?? "";
+          input.dataset.shapeKey = key;
+          input.title = shape.meaning;
+          input.addEventListener("change", () => {
+            shapes = { ...shapes, [key]: input.value.trim() };
+            handlers?.change?.();
+          });
+          shapeInputs.set(key, input);
+          body.append(field(shape.label, input));
+        }
         if (!body.childElementCount) {
           const none = document.createElement("p");
           none.className = "b05-structure__owner-note";
@@ -150,7 +196,10 @@ export function createGroupBoxes(): GroupBoxes {
         boxes.push(box);
         bodies.push(body);
       }
-      const stale = type ? paintStale(new Set(groups.map((g) => g.id))) : null;
+      const stale =
+        type && !STRUCTURE_SPECS[type.type_id]
+          ? paintStale(new Set(groups.map((g) => g.id)))
+          : null;
       root.replaceChildren(...boxes, ...(stale ? [stale] : []));
       root.hidden = !type || (!boxes.length && !stale);
       // 잠금은 계곡 통과 시설 서브폼(`inert`)을 따름 — 레지스트리 칸은 칸마다 disabled 라 그대로
@@ -167,6 +216,7 @@ export function createGroupBoxes(): GroupBoxes {
     set(next) {
       items = { ...next };
       for (const [id, row] of rows) row.set(items[id] ?? null);
+      changed();
     },
     setOne(groupId, item) {
       if (item) items = { ...items, [groupId]: item };
@@ -175,10 +225,31 @@ export function createGroupBoxes(): GroupBoxes {
         items = rest;
       }
       rows.get(groupId)?.set(item);
+      changed();
     },
+    pick: (groupId) => handlers?.pick(groupId),
+    clear: (groupId) => handlers?.clear(groupId),
+    watch: (listener) => listeners.push(listener),
     bind(next) {
       handlers = next;
     },
+    shapes() {
+      const out: Record<string, number> = {};
+      for (const key of shapeInputs.keys()) {
+        const text = (shapes[key] ?? "").trim();
+        if (text !== "" && Number.isFinite(Number(text))) out[key] = Number(text);
+      }
+      return out;
+    },
+    shapeKeys: (type) => keysOf(type === undefined ? current : type),
+    setShapes(options) {
+      shapes = Object.fromEntries(
+        Object.entries(options ?? {})
+          .filter(([key]) => key.includes(GROUP_JOIN))
+          .map(([key, value]) => [key, String(value)]),
+      );
+      for (const [key, input] of shapeInputs) input.value = shapes[key] ?? "";
+    },
   };
 }
 
@@ -193,6 +264,8 @@ export function bindSummaryPickers(opts: {
   editingId: () => string | null;
   selectedPipeChainage: () => number | null;
   commitSummary: () => void;
+  /** 형상 칸 고침 반영 — 고치는 중이면 곧바로(새 항목은 [추가]가 확정). */
+  liveCommit: () => void;
 }): void {
   const base = (): string | null => {
     const pipe = opts.selectedPipeChainage();
@@ -214,6 +287,7 @@ export function bindSummaryPickers(opts: {
     },
   });
   opts.groups.bind({
+    change: opts.liveCommit,
     pick: (groupId) => {
       const id = base();
       void pick(
diff --git a/B05_Profile/B05_Profile_UI_Structures_Panel.ts b/B05_Profile/B05_Profile_UI_Structures_Panel.ts
index 149903454..7f1c2ffe0 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Panel.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Panel.ts
@@ -23,7 +23,11 @@ import {
 import type { PipeFacility } from "../B04_PreProcess/B04_PreProcess_Api_Fetch";
 import { type FacilityAttributes } from "./B05_Profile_UI_Drainage_Facility";
 import { field, optionDefaults } from "./B05_Profile_UI_Structures_Fields";
-import { renderOptionFields as renderOptionFieldsInto } from "./B05_Profile_UI_Structures_Panel_Options";
+import {
+  hasSpecContainers,
+  paintStale,
+  renderOptionFields as renderOptionFieldsInto,
+} from "./B05_Profile_UI_Structures_Panel_Options";
 import { bindSummaryPickers } from "./B05_Profile_UI_Structures_Groups";
 import { buildStructuresForm } from "./B05_Profile_UI_Structures_Form";
 import {
@@ -38,7 +42,8 @@ import {
   loadPipeForm as loadPipeFormInto,
 } from "./B05_Profile_UI_Structures_Panel_Commit";
 import { renderStructureList } from "./B05_Profile_UI_Structures_List";
-import { isOptionVisible } from "./B05_Profile_UI_Structures_Summary";
+import { showsAnchor } from "./B05_Profile_UI_Structures_Define";
+import { hiddenOptionKeys } from "./B05_Profile_UI_Structures_Define_Form";
 import { stationLabel as formatStation } from "../common_util/common_util_station";
 import { PIPE_MATCH_M, resolveSelection } from "../A00_Common/design/design_selection";
 
@@ -52,11 +57,9 @@ import {
   hasComputedRange,
   readBeforeOption,
   readLengthOption,
-} from "./B05_Profile_UI_Structures_Panel_Types";
-import type {
-  PipeFacilityItem,
-  StructuresCallbacks,
-  StructuresSection,
+  type PipeFacilityItem,
+  type StructuresCallbacks,
+  type StructuresSection,
 } from "./B05_Profile_UI_Structures_Panel_Types";
 
 export function createStructuresSection(
@@ -86,6 +89,8 @@ export function createStructuresSection(
     optionRow,
     actions,
     facilityOptions,
+    staleBox,
+    facilityDefinition,
     primary,
     removeButton,
     resetButton,
@@ -222,7 +227,7 @@ export function createStructuresSection(
       !!type && !managed && type.placement === "interval" && !hasComputedRange(type);
     positionRow.hidden = !type;
     positionDivider.hidden = !type;
-    summary.root.hidden = !type;
+    summary.root.hidden = !type || hasSpecContainers(type); // 컨테이너 종류는 컨테이너마다 잇기(52-1)
     startFields.wrap.hidden = !isInterval;
     endFields.wrap.hidden = !isInterval;
     primary.disabled = !type;
@@ -232,6 +237,8 @@ export function createStructuresSection(
       ? `${type.design_owner}에서 관리 — 여기서 넣어도 제원·수량은 그쪽 값을 씁니다.`
       : "";
     ownerNote.hidden = !type?.design_owner;
+    // 정의가 기준 측점을 끈 종류(48-3) — 기준 측점이 곧 위치인 종류(점형 · 범위 계산)는 늘 보임
+    anchorFields.wrap.hidden = isInterval && !showsAnchor(type!);
     anchorFields.wrap.querySelector("span")!.textContent = isInterval
       ? "기준 측점 (비우면 시작)"
       : "기준 측점";
@@ -244,13 +251,14 @@ export function createStructuresSection(
     designFlow: number | null = null,
   ): void {
     const kind = facilityFormKind(currentType());
-    facilityOptions.setFacility(kind, options ?? newDefaults(), designFlow);
+    facilityOptions.setChainage(selectedPipeChainage ?? tempPipeChainage); // 관 길이(자동 · 52-1)
+    facilityOptions.setFacility(kind, options ?? newDefaults(), designFlow, currentType());
+    if (kind)
+      paintStale(staleBox, currentType(), options, kind, groupBoxes.shapeKeys(currentType()));
     // 「구조물 옵션 보이기」에서 끈 옵션은 시설 폼에서도 가림(값은 옛 값 그대로 저장)
-    facilityOptions.setHiddenOptions(
-      kind,
-      (currentType()?.options ?? []).filter((o) => !isOptionVisible(o)).map((o) => o.key),
-    );
+    facilityOptions.setHiddenOptions(kind, hiddenOptionKeys(currentType()));
     regroup();
+    facilityDefinition.apply(kind ? currentType() : null); // 숨긴 선택지 · 규칙(48-3 · 48-4)
     syncOptionLock();
   }
 
@@ -321,6 +329,8 @@ export function createStructuresSection(
   /** 타입의 옵션 스키마대로 입력 칸을 다시 그린다 — 그리는 규칙은 `_Structures_Panel_Options`. */
   function renderOptionFields(values?: Record<string, string | number>): void {
     renderOptionFieldsInto(optionContext, values ?? newDefaults());
+    if (!facilityFormKind(currentType()))
+      paintStale(staleBox, currentType(), values, null, groupBoxes.shapeKeys(currentType()));
     regroup();
   }
 
@@ -506,8 +516,7 @@ export function createStructuresSection(
     },
     summary: () => summary.get(),
     setSummary: (value) => summary.set(value),
-    groupItems: () => groupBoxes.get(),
-    setGroupItems: (value) => groupBoxes.set(value),
+    groupBoxes,
   };
   bindStructuresEvents(panelContext);
   // 집계 항목(본체 · 옵션 그룹) — [고르기]는 21-5 모달 · 배선은 `_Structures_Groups`
@@ -518,6 +527,7 @@ export function createStructuresSection(
     editingId: () => editingId,
     selectedPipeChainage: () => selectedPipeChainage,
     commitSummary,
+    liveCommit,
   });
   body.insertBefore(field("메모", memoField), actions);
   syncButtons();
@@ -530,11 +540,11 @@ export function createStructuresSection(
     hasSelection: () => editingId !== null || selectedPipeChainage !== null,
     setTypes(next) {
       types = next;
-      const groups = [...new Set(next.map((t) => t.group))];
-      // 첫 항목은 빈칸 — 진입·리셋 상태에서 군·종류를 강제로 고르게 두지 않는다.
+      const groups = new Map(next.map((t) => [t.group, t.group_name] as const));
+      // 첫 항목은 빈칸 — 진입·리셋 상태에서 군·종류를 강제로 고르게 두지 않는다. 이름은 정의(48) 먼저.
       groupSelect.replaceChildren(
         new Option("— 선택 —", ""),
-        ...groups.map((group) => new Option(GROUP_LABELS[group] ?? group, group)),
+        ...[...groups].map(([g, name]) => new Option(name ?? GROUP_LABELS[g] ?? g, g)),
       );
       groupSelect.value = "";
       syncTypeOptions();
diff --git a/B05_Profile/B05_Profile_UI_Structures_Panel_Commit.ts b/B05_Profile/B05_Profile_UI_Structures_Panel_Commit.ts
index 86196870c..e24155203 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Panel_Commit.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Panel_Commit.ts
@@ -18,6 +18,7 @@ import type { FacilityAttributes, FacilityOptionsForm } from "./B05_Profile_UI_D
 import type { StationFields } from "./B05_Profile_UI_Structures_Fields";
 import { splitPavementRange } from "./B05_Profile_UI_Structures_Pavement";
 import { mergeStructureOptions } from "./B05_Profile_UI_Structures_Summary";
+import type { GroupBoxes } from "./B05_Profile_UI_Structures_Groups";
 import {
   readGroupItems,
   readSummaryItem,
@@ -75,13 +76,13 @@ export interface StructuresCommitContext {
   summary: () => SummaryItem | null;
   setSummary: (value: SummaryItem | null) => void;
   /** 옵션 그룹 보조 컨테이너마다 고른 항목(PLAN 46-3) — 저장은 `group_items` 칸. */
-  groupItems: () => GroupItems;
-  setGroupItems: (value: GroupItems) => void;
+  /** 옵션 그룹 상자 — 집계 항목(46-3) · 형상 칸 값(48-3). */
+  groupBoxes: GroupBoxes;
 }
 
 /** 저장할 그룹 연결 — 고른 것이 있을 때만 칸을 실음(빈 묶음 = 칸 없음). */
 function groupField(ctx: StructuresCommitContext): { group_items?: GroupItems } {
-  const items = ctx.groupItems();
+  const items = ctx.groupBoxes.get();
   return Object.keys(items).length ? { group_items: items } : {};
 }
 
@@ -105,7 +106,8 @@ export function loadForm(ctx: StructuresCommitContext, target: StructureInstance
     ctx.memoField.value = target.memo ?? "";
     ctx.renderOptionFields(target.options);
     ctx.setSummary(readSummaryItem(target.summary_item));
-    ctx.setGroupItems(readGroupItems(target.group_items));
+    ctx.groupBoxes.set(readGroupItems(target.group_items));
+    ctx.groupBoxes.setShapes(target.options);
     // 구간 직접 입력 시절에 저장된 항목 호환 — 길이·전길이 옵션이 없으면 저장된
     // 시작~종료·기준점에서 역산해 채워 범위 표시·재저장이 이어지게 한다(2026-08-19).
     if (target.start_m != null && target.end_m != null && target.end_m > target.start_m) {
@@ -134,7 +136,8 @@ export function loadForm(ctx: StructuresCommitContext, target: StructureInstance
     ctx.memoField.value = "";
     ctx.renderOptionFields();
     ctx.setSummary(null);
-    ctx.setGroupItems({});
+    ctx.groupBoxes.set({});
+    ctx.groupBoxes.setShapes({});
     ctx.syncFacilityForm();
   }
   [ctx.anchorFields, ctx.startFields, ctx.endFields].forEach((fields) => fields.clearInvalid());
@@ -182,7 +185,8 @@ export function loadPipeForm(ctx: StructuresCommitContext, pipe: PipeFacilityIte
   ctx.memoField.value = "";
   ctx.syncFacilityForm(pipe.options ?? {}, pipe.design_flow_m3s ?? null);
   ctx.setSummary(readSummaryItem(pipe.summary_item));
-  ctx.setGroupItems(readGroupItems(pipe.group_items));
+  ctx.groupBoxes.set(readGroupItems(pipe.group_items));
+  ctx.groupBoxes.setShapes(pipe.options);
   [ctx.anchorFields, ctx.startFields, ctx.endFields].forEach((fields) => fields.clearInvalid());
   ctx.syncPlacementFields();
   ctx.syncButtons();
@@ -191,9 +195,11 @@ export function loadPipeForm(ctx: StructuresCommitContext, pipe: PipeFacilityIte
 }
 
 export function readOptions(ctx: StructuresCommitContext): Record<string, string | number> {
-  // 서브폼이 담당하는 타입(독립 기슭막이)은 서브폼이 값을 읽는다.
-  if (ctx.facilityFormKind(ctx.currentType())) return ctx.facilityOptions.readOptions();
-  const values: Record<string, string | number> = {};
+  // 서브폼이 담당하는 타입(독립 기슭막이)은 서브폼이 값을 읽는다. 그룹 형상 칸(48-3)은 둘 다 얹음.
+  const shapes = ctx.groupBoxes.shapes();
+  if (ctx.facilityFormKind(ctx.currentType()))
+    return { ...ctx.facilityOptions.readOptions(), ...shapes };
+  const values: Record<string, string | number> = { ...shapes };
   ctx.optionInputs.forEach((input) => {
     // 빈 칸은 아예 넣지 않는다 — 빈 숫자를 0으로 저장하면 "0으로 확정"과 구분이 안 된다.
     if (input.isEmpty()) return;
@@ -241,7 +247,7 @@ export async function commit(ctx: StructuresCommitContext, live = false): Promis
     }
     // 배수관 등 계곡 통과 시설은 점형 — 기준 측점 하나뿐이다(2026-08-17 지시 2).
     const attributes: FacilityAttributes = { facility: type.type_id as PipeFacility };
-    const options = ctx.facilityOptions.readOptions();
+    const options = readOptions(ctx);
     if (Object.keys(options).length) attributes.options = options;
     // 집계 항목 — 미지정(null)도 그대로 실어 옛 지정을 풀 수 있게 한다.
     attributes.summary_item = ctx.summary();
@@ -363,7 +369,7 @@ export async function commit(ctx: StructuresCommitContext, live = false): Promis
         options: mergeStructureOptions(
           previous,
           type.type_id,
-          ctx.optionInputs.map((entry) => entry.key),
+          [...ctx.optionInputs.map((entry) => entry.key), ...ctx.groupBoxes.shapeKeys()],
           records[0].options,
         ),
       };
diff --git a/B05_Profile/B05_Profile_UI_Structures_Panel_Options.ts b/B05_Profile/B05_Profile_UI_Structures_Panel_Options.ts
index f557893d3..97032d397 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Panel_Options.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Panel_Options.ts
@@ -11,7 +11,21 @@
 import { isB05Option, type StructureType } from "./B05_Profile_Api_Structures";
 import type { PipeFacility } from "../B04_PreProcess/B04_PreProcess_Api_Fetch";
 import { field, optionControl } from "./B05_Profile_UI_Structures_Fields";
-import { isOptionVisible } from "./B05_Profile_UI_Structures_Summary";
+import {
+  columnsOf,
+  gridPlace,
+  orderedOptions,
+  ruleDefaults,
+  ruleStates,
+  staleValues,
+} from "./B05_Profile_UI_Structures_Define";
+import { FORM_OPTION_KEYS } from "./B05_Profile_UI_Drainage_Facility_Merge";
+import { STRUCTURE_SPECS } from "../A00_Common/design/design_structure_pipe";
+import { specKeys } from "../A00_Common/design/design_structure_spec";
+
+/** 구조물 명세 컨테이너로 그리는 종류인지 — 그때 종류 단위 「구조물 조합」 줄은 가림(PLAN 52-1). */
+export const hasSpecContainers = (type: StructureType): boolean =>
+  !!STRUCTURE_SPECS[type.type_id]?.containers.length;
 
 /** 패널이 쥔 값 중 옵션 그리기에 필요한 것들. 이름은 분리 전 지역변수와 같다. */
 export interface OptionRenderContext {
@@ -46,39 +60,48 @@ export function renderOptionFields(
   optionInputs.length = 0;
   optionRow.replaceChildren();
   // 서브폼이 담당하는 타입(계곡 통과 시설·독립 기슭막이)은 여기서 그리지 않는다.
+  // 차례 · 안 씀 · 숨김은 정의대로(48-3 · `_Structures_Define`).
   const shown =
     type && !ctx.facilityFormKind(type)
-      ? type.options.filter((o) => (ctx.includeDetail || isB05Option(o)) && isOptionVisible(o))
+      ? orderedOptions(type).filter((o) => ctx.includeDetail || isB05Option(o))
       : [];
-  if (!shown.length) {
+  optionRow.style.gridTemplateColumns = "";
+  if (!type || !shown.length) {
     optionRow.hidden = true;
     ctx.syncOptionLock();
     return;
   }
   optionRow.hidden = false;
+  const columns = columnsOf(type);
+  if (columns !== 2) optionRow.style.gridTemplateColumns = `repeat(${columns}, minmax(0, 1fr))`;
+  // 규칙(48-4)이 가린 칸은 `optionInputs` 에서 뺌 — 필수 검사 · 저장이 안 봄(옛 값은 병합이 지킴)
+  const all: Array<{ entry: (typeof optionInputs)[number]; wrap: HTMLElement }> = [];
   shown.forEach((option) => {
     // 받은 값만 칸에 — 새 구조물은 부르는 쪽(패널)이 등록부 기본값을 `values` 로 실어 줌(PLAN 46-7).
+    // 보기는 정의 전부로 세워 옛 값을 잃지 않고, 숨김 · 규칙 선택지는 `applyRules` 가 좁힘.
     const input = optionControl(option, values[option.key]);
     const label = `${option.unit ? `${option.label} (${option.unit})` : option.label}${option.not_in_table ? " · 표에 안 쓰임" : ""}`;
-    // `enabled:false` 는 칸을 남기고 잠그기만 한다 — 값은 기본값이 그대로 저장된다
-    // (고를 수 없는 칸이라 제안이 아니라 프로그램 값).
-    const locked = option.enabled === false;
-    if (locked && !input.value) input.value = String(option.default ?? "");
-    if (locked) {
-      input.disabled = true;
-      input.classList.add("is-locked");
-      input.title = "지금은 고를 수 없는 항목입니다.";
-    }
     const wrap = field(label, input, option.default_basis);
     wrap.dataset.optionKeys = option.key; // 옵션 그룹 상자가 이 표식으로 칸을 옮김(PLAN 46-3)
+    // 배치 격자(48-3) — 정의 `배치` 의 줄 · 칸 · 너비 · 없으면 흐름대로
+    const place = gridPlace(type.spots?.[option.key], columns);
+    wrap.style.gridRow = place?.row ?? "";
+    wrap.style.gridColumn = place?.column ?? "";
     optionRow.append(wrap);
-    input.addEventListener("change", () => ctx.liveCommit());
-    optionInputs.push({
-      key: option.key,
-      required: !locked && !!option.required,
-      input,
-      read: () => (option.input === "number" ? Number(input.value) || 0 : input.value),
-      isEmpty: () => input.value.trim() === "",
+    // 상위 값이 바뀌면 하위 기본값 · 선택지 · 보이기를 먼저 맞추고 반영(48-4)
+    input.addEventListener("change", () => {
+      applyRules(option.key);
+      ctx.liveCommit();
+    });
+    all.push({
+      wrap,
+      entry: {
+        key: option.key,
+        required: !!option.required,
+        input,
+        read: () => (option.input === "number" ? Number(input.value) || 0 : input.value),
+        isEmpty: () => input.value.trim() === "",
+      },
     });
     // 전면 기울기는 품셈 표준경사 표(0.20~0.50) 밖 값도 받는다 — 실무 도면이 S0.7·S0.8 을
     // 쓴다(2026-09-09 실무 DWG 확인). **막지 않고 알리기만** 한다: 막으면 실물이 안 들어간다.
@@ -110,6 +133,80 @@ export function renderOptionFields(
       input.addEventListener("change", () => refresh(true));
     }
   });
+  /** 규칙 걸기 — `parent` 가 바뀐 칸이면 그 칸에 매인 기본값부터 넣음. */
+  function applyRules(parent: string | null): void {
+    const now = (): Record<string, string> =>
+      Object.fromEntries(all.map(({ entry }) => [entry.key, entry.input.value]));
+    if (parent) {
+      for (const [key, value] of Object.entries(ruleDefaults(type!, parent, now()))) {
+        const hit = all.find(({ entry }) => entry.key === key);
+        if (hit) hit.entry.input.value = String(value);
+      }
+    }
+    const next = ruleStates(type!, now());
+    optionInputs.length = 0;
+    for (const { entry, wrap } of all) {
+      const state = next.get(entry.key);
+      const off = state?.visible === false;
+      wrap.classList.toggle("is-rule-hidden", off); // 그룹 상자로 옮겨 가도 같은 표식
+      if (!off) optionInputs.push(entry);
+      if (state && entry.input.tagName.toLowerCase() === "select")
+        syncChoices(entry.input as HTMLSelectElement, state.choices);
+    }
+  }
+  applyRules(null);
   ctx.syncOptionLock();
   ctx.syncRangeDisplay();
 }
+
+/** 고르기 칸 보기를 규칙 선택지로 — 빈 보기는 남기고, 지금 값이 목록 밖이면 그 값만 남겨 보임. */
+function syncChoices(element: HTMLSelectElement, choices: string[]): void {
+  const now = [...element.children].slice(1).map((o) => (o as HTMLOptionElement).value);
+  const keep = element.value && !choices.includes(element.value) ? [element.value] : [];
+  const want = [...choices, ...keep];
+  if (now.length === want.length && now.every((v, i) => v === want[i])) return;
+  const value = element.value;
+  const blank = element.children[0];
+  element.replaceChildren(blank, ...want.map((c) => new Option(c, c)));
+  element.value = value;
+}
+
+/** 「지난 정의 값」 상자(48-3) — 지금 정의에 없는 키의 값을 읽기만 칸으로 보임(오류 없음 · 저장은
+ *  병합이 옛 값 그대로 지킴). 아는 키 = 정의 옵션 전부(안 씀 포함) + 시설 폼이 적는 칸. */
+export function paintStale(
+  box: HTMLElement,
+  type: StructureType | null,
+  values: Record<string, string | number> | undefined,
+  facility: PipeFacility | null,
+  /** 그룹 형상 키(`{그룹 id}__{칸}`) — 정의된 그룹 몫이라 지난 값이 아님. */
+  shapeKeys: string[] = [],
+): void {
+  // 명세 종류(52) — 명세가 뺀 옛 키(retired)는 지난 정의 값 · 선택 컨테이너 키(머리)는 앎
+  const spec = type ? STRUCTURE_SPECS[type.type_id] : undefined;
+  const own = spec ? specKeys(spec) : { keys: [], prefixes: [] };
+  const known = [
+    ...shapeKeys,
+    ...(type?.options ?? []).map((o) => o.key),
+    ...(facility ? (FORM_OPTION_KEYS[facility] ?? []) : []),
+    ...own.keys,
+  ].filter((key) => !spec?.retired.includes(key));
+  const stale = type
+    ? staleValues(values, known).filter(([key]) => !own.prefixes.some((p) => key.startsWith(p)))
+    : [];
+  box.replaceChildren();
+  box.hidden = !stale.length;
+  if (!stale.length) return;
+  const legend = document.createElement("legend");
+  legend.textContent = "지난 정의 값";
+  const body = document.createElement("div");
+  body.className = "b05-structure__grid";
+  for (const [key, value] of stale) {
+    const input = document.createElement("input");
+    input.type = "text";
+    input.readOnly = true;
+    input.value = String(value);
+    input.title = "지금 정의에 없는 칸 — 읽기만 · 계산에 안 쓰임";
+    body.append(field(key, input));
+  }
+  box.append(legend, body);
+}
diff --git a/B05_Profile/B05_Profile_UI_Structures_Summary.ts b/B05_Profile/B05_Profile_UI_Structures_Summary.ts
index 9503cd1af..9e29b082b 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Summary.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Summary.ts
@@ -8,9 +8,9 @@
  * import 없음 — 시험이 이 파일만 옮겨 돌림.
  * ========================================================================== */
 
-/** 옵션 보이기 — 서버가 채운 `visible`(21-8)이 false 일 때만 숨김. 없으면 보임. */
-export function isOptionVisible(option: { visible?: boolean }): boolean {
-  return option.visible !== false;
+/** 옵션 보이기 — 서버가 채운 `visible`(21-8)이 false 이거나 정의가 「안 씀」(`enabled:false` · 48)일 때 숨김. */
+export function isOptionVisible(option: { visible?: boolean; enabled?: boolean }): boolean {
+  return option.visible !== false && option.enabled !== false;
 }
 
 /** 저장할 옵션 — 같은 종류를 고치는 중이면 폼이 안 그린 옛 칸을 이어 붙임.
diff --git a/B05_Profile/B05_Profile_UI_Style_Structures.css b/B05_Profile/B05_Profile_UI_Style_Structures.css
index 57e713798..bb609526d 100644
--- a/B05_Profile/B05_Profile_UI_Style_Structures.css
+++ b/B05_Profile/B05_Profile_UI_Style_Structures.css
@@ -515,3 +515,32 @@
 .b05-structure__optgroup > .b05-structure__grid.is-locked {
   opacity: 0.5;
 }
+
+/* 구조물 정의 규칙(PLAN 48-4)이 가린 칸 — 그룹 상자로 옮겨 가도 같은 표식 */
+.b05-structure-section .is-rule-hidden {
+  display: none;
+}
+
+/* 「지난 정의 값」 읽기만 상자(PLAN 48-3) — 지금 정의에 없는 키의 값 */
+.b05-structure__stale input[readonly] {
+  opacity: 0.7;
+}
+
+/* 구조물 명세 컨테이너(PLAN 52-1) — 상자 차례 · 긴 잇기 이름이 상자를 밀어 넓히지 않게(fieldset 최소 폭) */
+.b05-structure__spec {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.b05-structure__spec[hidden] {
+  display: none;
+}
+
+.b05-structure__spec .b05-structure__group {
+  min-width: 0;
+}
+
+.b05-structure__spec-add {
+  align-self: flex-start;
+}
diff --git a/B06_Section/B06_Section_Engine_Culvert.py b/B06_Section/B06_Section_Engine_Culvert.py
index ce97262f9..87fb59003 100644
--- a/B06_Section/B06_Section_Engine_Culvert.py
+++ b/B06_Section/B06_Section_Engine_Culvert.py
@@ -327,7 +327,8 @@ def _wing_spec(values: dict[str, Any], defaults: dict[str, Any], side: str) -> d
     height = _number(
         values.get(f"{prefix}_height_m"), _number(defaults.get(f"{prefix}_height_m"), 0.0)
     )
-    installed = str(install or "").strip() != "없음"
+    # BOX암거 유입·유출 구조(표 02) — 없음 · 날개벽 · 흙막이 · 옛 값 있음 = 날개벽. 날개벽만 세움.
+    installed = str(install or "").strip() not in ("없음", "흙막이")
     extend = (length or 0.0) * math.cos(math.radians(angle or 0.0)) if installed else 0.0
     return {
         "installed": installed,
diff --git a/M01_MasterData/M01_MasterData_Store_Cache.py b/M01_MasterData/M01_MasterData_Store_Cache.py
index cca474f97..ac1be8ad8 100644
--- a/M01_MasterData/M01_MasterData_Store_Cache.py
+++ b/M01_MasterData/M01_MasterData_Store_Cache.py
@@ -221,19 +221,21 @@ def check_saved(files: dict, changed: list[str], book: dict, narrowed=None) -> l
 
 
 def _labor_files() -> list[tuple[str, Path]]:
-    """모든 층(마스터 · 회사 · 개인)의 일위대가 문서 `labor/<열>.json` — (어디, 파일)."""
+    """모든 층(마스터 · 회사 · 개인)의 일위대가 `labor/<열>.json` · 단가승격 `promote/<키>.json`
+    · 사전조합 `precombo/<키>.json`(51-11) — (어디, 파일)."""
     from M02_MasterTemplete import M02_Template_Layers as layers  # M02 가 M01 을 부름 — 늦게
 
-    root = layers.storage_root()
-    found = [("마스터", p) for p in sorted((layers.system_dir() / "labor").glob("*.json"))]
-    found += [(f"회사 {p.parts[-4]}", p) for p in sorted(root.glob("*/templates/labor/*.json"))]
-    personal = sorted(root.glob("*/*/templates/labor/*.json"))
-    return found + [(f"개인 {p.parts[-5]}/{p.parts[-4]}", p) for p in personal]
+    return [
+        (f"{what} {where}", path)
+        for kind, what in (("labor", "일위대가"), ("promote", "단가승격"), ("precombo", "사전조합"))
+        for where, path in layers.layer_files(kind)
+    ]
 
 
 def labor_errors(whole) -> list[str]:
-    """일위대가 문서가 담은 로직이 마스터에 없음(39-1d) — 로직 지우기를 막음 · 어디서 쓰는지 알림.
-    전부터 깨진 것은 `save` 가 고치기 전 검사와 견주어 뺌."""
+    """일위대가 · 단가승격 · 사전조합 문서가 담은 로직이 마스터에 없음(39-1d · 50-3) —
+    로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은
+    `save` 가 고치기 전 검사와 견주어 뺌."""
     out = []
     for where, path in _labor_files():
         try:
@@ -243,10 +245,12 @@ def labor_errors(whole) -> list[str]:
         name = (doc.get("일위대가번") if isinstance(doc, dict) else None) or path.stem
         for one in (doc.get("담은로직") if isinstance(doc, dict) else None) or []:
             key = str(one.get("로직") or "") if isinstance(one, dict) else ""
+            if not key:
+                continue
             try:
                 whole.logic(key)
             except cm.mf.FormulaError:
-                out.append(f"일위대가 {where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
+                out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
     return out
 
 
diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py
index c5ab2df45..13762011a 100644
--- a/M01_MasterData/M01_MasterData_Store_Make.py
+++ b/M01_MasterData/M01_MasterData_Store_Make.py
@@ -104,30 +104,88 @@ def sections(book: str, division: str = "", chapter: str = "", q: str = "", limi
 
 
 # ── 로직 원문(출처 글 → 품셈 본문 절) ──────────────────────────────────
-_NUMBER = re.compile(r"(?<![\d-])\d+(?:-\d+)+(?![\d-])")
+_NUMBER = re.compile(r"(?<![\d-])(\d+(?:-\d+)+)(?![\d-])(?:\s+(주[①-⑳]?|\d{1,2})(?![\d-]))?")
+_ESCAPE = re.compile(r"\\([.\-*_()#\[\]>~`])")  # 마크다운 이스케이프 `\.` `\-` …
+_COMMENT = re.compile(r"<!--.*?-->")  # 글 안 주석(글자층 표시) — 글자만 남김
+_CIRCLED = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳"
+
+
+def _plain(text: str) -> str:
+    """원문 md 기호 벗김 — 주석 · 이스케이프 · 인용 머리 `> `."""
+    text = _ESCAPE.sub(r"\1", _COMMENT.sub("", text)).strip()
+    return text[1:].strip() if text.startswith(">") else text
 
 
 def _blocks(lines: list[str]) -> list[dict]:
-    """md 줄 → 화면 조각 — 제목 {h} · 표 {table} · 글 {p} · 주석 줄은 뺌."""
+    """md 줄 → 화면 조각 — 제목 {h} · 표 {table} · 글 {p} · 주석 줄은 뺌 ·
+    빈 줄 · 주석이 표를 끊음(붙은 표 둘을 한 표로 안 합침) · `<br>` = 줄바꿈."""
     out: list[dict] = []
+    joinable = False
     for line in lines:
-        text = line.strip()
+        text = re.sub(r"<br\s*/?>", "\n", line.strip())
         if not text or text.startswith("<!--"):
+            joinable = False
             continue
+        if not text.startswith(("#", "|")):
+            text = _plain(text)
+            if not text:
+                joinable = False
+                continue
         if text.startswith("#"):
             out.append({"h": len(text) - len(text.lstrip("#")), "text": text.lstrip("#").strip()})
         elif text.startswith("|"):
-            cells = [c.strip() for c in text.strip("|").split("|")]
+            cells = [_plain(c) for c in text.strip("|").split("|")]
             if all(re.fullmatch(r":?-{3,}:?", c) for c in cells):
                 continue  # 머리 · 몸 가름 줄
-            if not out or "table" not in out[-1]:
+            if not joinable:
                 out.append({"table": []})
             out[-1]["table"].append(cells)
+            joinable = True
+            continue
         else:
             out.append({"p": text})
+        joinable = False
     return out
 
 
+def _mark(blocks: list[dict], item: str) -> bool:
+    """출처 항 · 주 번호(「1」 · 「주③」 · 「주」)에 드는 조각에 hit 표시 — 못 찾으면 False(절 통째만)."""
+    texts = [b.get("p") or b.get("text") or "" for b in blocks]
+    if item.startswith("주"):
+        note = next((i for i, t in enumerate(texts) if t.startswith("[주]")), None)
+        if note is None:
+            return False
+        start, stop = note, len(blocks)
+        if len(item) > 1:  # 「주③」 — [주] 아래 ③ 줄 하나(다음 ① ~ ⑳ 줄 앞까지)
+            start = next(
+                (i for i in range(note + 1, len(texts)) if texts[i].startswith(item[1])), None
+            )
+            if start is None:
+                return False
+            stop = next(
+                (i for i in range(start + 1, len(texts)) if texts[i][:1] in _CIRCLED), len(blocks)
+            )
+    else:  # 「1」 — 「1. …」 제목 · 줄 ~ 다음 제목 · 「2. …」 앞(줄이면 [주] 앞도)
+        head = re.compile(rf"{item}[.)]\s")
+        start = next((i for i, t in enumerate(texts) if head.match(t)), None)
+        if start is None:
+            return False
+        under = "h" in blocks[start]
+        stop = next(
+            (
+                i
+                for i in range(start + 1, len(blocks))
+                if "h" in blocks[i]
+                or (not under and re.match(r"\d+[.)]\s|\[주\]", texts[i]))
+                or (under and re.match(r"\d+[.)]\s", texts[i]) and "p" in blocks[i])
+            ),
+            len(blocks),
+        )
+    for b in blocks[start:stop]:
+        b["hit"] = True
+    return True
+
+
 def _section(book: str, division: str, number: str) -> dict | None:
     """번호 절을 품셈 본문에서 찾음 — 없으면 끝 마디를 하나씩 떼며 위 절로(두 마디까지)."""
     parts = number.split("-")
@@ -172,8 +230,14 @@ def source(src: str) -> dict:
         if book == "건설품셈"
         else ""
     )
-    found = [_section(book, division, n) for n in dict.fromkeys(_NUMBER.findall(src))]
-    return {"source": src, "found": [x for x in found if x]}
+    found = []
+    for number, item in dict.fromkeys(_NUMBER.findall(src)):
+        one = _section(book, division, number)
+        if one:
+            if item and _mark(one["blocks"], item):
+                one["item"] = item
+            found.append(one)
+    return {"source": src, "found": found}
 
 
 # ── 표 조건 값 ─────────────────────────────────────────────────────────
diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Side.css b/M01_MasterData/M01_MasterData_UI_LogicLab_Side.css
index 38b5f9359..2cccf101c 100644
--- a/M01_MasterData/M01_MasterData_UI_LogicLab_Side.css
+++ b/M01_MasterData/M01_MasterData_UI_LogicLab_Side.css
@@ -14,7 +14,9 @@
   background: none;
 }
 
+/* 원문 꼴 한 벌(M01 · M02 같음) — 둘레 글자 크기(M01 14)를 안 따르고 본문 크기 */
 .m01lab-src {
+  font-size: var(--text-body);
   display: flex;
   flex-direction: column;
   gap: var(--spacing-8);
@@ -26,8 +28,6 @@
   flex-direction: column;
   gap: var(--spacing-8);
   min-width: 0;
-  max-height: 80vh;
-  overflow: auto;
 }
 
 .m01lab-src__head {
@@ -51,6 +51,13 @@
   font-weight: 600;
 }
 
+/* 칸 안 줄바꿈(원문 <br>)만 살리고 저절로 접지 않음 */
 .m01lab-src__table td {
-  white-space: nowrap;
+  white-space: pre;
+}
+
+/* 출처가 가리킨 항 · 주 — 옅은 바탕 + 왼쪽 막대 */
+.m01lab-src__hit {
+  background: color-mix(in srgb, var(--color-accent) 14%, transparent);
+  box-shadow: -3px 0 0 var(--color-accent);
 }
diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Source.ts b/M01_MasterData/M01_MasterData_UI_LogicLab_Source.ts
index e1d722d61..2de0b8895 100644
--- a/M01_MasterData/M01_MasterData_UI_LogicLab_Source.ts
+++ b/M01_MasterData/M01_MasterData_UI_LogicLab_Source.ts
@@ -26,15 +26,24 @@ interface Block {
   text?: string;
   p?: string;
   table?: string[][];
+  /** 출처가 가리킨 항 · 주 — 강조 */
+  hit?: boolean;
 }
 interface Found {
   number: string;
   matched: string;
   file: string;
   blocks: Block[];
+  item?: string;
 }
 
 function blockNode(b: Block): HTMLElement {
+  const node = rawNode(b);
+  if (b.hit) node.classList.add("m01lab-src__hit");
+  return node;
+}
+
+function rawNode(b: Block): HTMLElement {
   if (b.table)
     return el("div", {
       className: "m01-logic__scroll",
@@ -89,11 +98,20 @@ export function createSourceView(): SourceView {
           ...found.flatMap((f) => [
             el("p", {
               className: "m01-logic__muted m01lab-src__file",
-              text: f.matched === f.number ? f.file : `${f.file} · ${ts("Near", f.number)}`,
+              text: [
+                f.file,
+                f.matched === f.number ? "" : ts("Near", f.number),
+                f.item ? (/^\d+$/.test(f.item) ? `${f.item}항` : f.item) : "",
+              ]
+                .filter(Boolean)
+                .join(" · "),
             }),
             ...f.blocks.map(blockNode),
           ]),
         );
+        requestAnimationFrame(() =>
+          body.querySelector(".m01lab-src__hit")?.scrollIntoView({ block: "center" }),
+        );
       });
   };
 
diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts b/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts
index f27f458d8..98b79eb28 100644
--- a/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts
+++ b/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts
@@ -203,7 +203,7 @@ export function buildCalc(host: HTMLElement, ctx: CalcContext): void {
 }
 
 /** `money` = 결과가 돈(원) — 그때만 결과 값도 정수 · 수량·비율 결과는 소수 그대로 */
-function answerView(answer: CalcAnswer, draft: boolean, money: boolean): HTMLElement[] {
+export function answerView(answer: CalcAnswer, draft: boolean, money: boolean): HTMLElement[] {
   const note = draft ? [el("p", { className: "m01-logic__muted", text: tx("Calc_Draft") })] : [];
   if (!answer.ok) {
     return [
diff --git a/M02_MasterTemplete/DataFlow/M02_DF_UnitPick.ts b/M02_MasterTemplete/DataFlow/M02_DF_UnitPick.ts
index 2883c6835..ed0cd9dd0 100644
--- a/M02_MasterTemplete/DataFlow/M02_DF_UnitPick.ts
+++ b/M02_MasterTemplete/DataFlow/M02_DF_UnitPick.ts
@@ -106,7 +106,6 @@ export function createUnitPick(opts: UnitPickOptions): HTMLElement {
   const open = createButton({
     label: opts.value || NO_UNIT,
     variant: "ghost",
-    size: "sm",
     disabled: opts.readOnly,
     onClick: () => toggle(),
   });
diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py
index df2b05f5c..56ad2f407 100644
--- a/M02_MasterTemplete/M02_Item_Prices.py
+++ b/M02_MasterTemplete/M02_Item_Prices.py
@@ -244,10 +244,15 @@ def load_prices(prices: dict[str, Any]) -> Any:
 # ── 계산(25-2e) ─────────────────────────────────────────────────────
 
 
+def _logic_keys(labor: dict[str, Any]) -> list[str]:
+    """담은 로직 키 — 참조 줄(로직 없음 · 50-3)은 뺌."""
+    return [key for key in mcb.logic_keys(labor.get("줄") or {}) if key]
+
+
 def missing_inputs(snapshot: Any, labor: dict[str, Any], values: dict[str, Any]) -> list[dict]:
     """담은 로직마다 값이 없는(null · 안 적음) 입력 — `{로직, 입력}`."""
     out = []
-    for key in mcb.logic_keys(labor.get("줄") or {}):
+    for key in _logic_keys(labor):
         try:
             row = snapshot.logic(key)
         except mf.FormulaError:
@@ -277,7 +282,7 @@ def calc(
     blocked = {gap["로직"] for gap in gaps}
     sums = dict.fromkeys(mf.COST_ITEMS, Decimal(0))
     lines, stuck = [], []
-    for at, key in enumerate(mcb.logic_keys(labor.get("줄") or {}), start=1):
+    for at, key in enumerate(_logic_keys(labor), start=1):
         head: dict[str, Any] = {"차례": at, "로직": key}
         if key in blocked:
             names = [gap["입력"] for gap in gaps if gap["로직"] == key]
@@ -306,10 +311,37 @@ def calc(
                 "계": got["계"],
             }
         )
+    for line in _ref_lines(snapshot, labor, len(lines)):  # 참조 줄(50-3) — 굳힌 사본으로
+        if line["ok"]:
+            for name in mf.COST_ITEMS:
+                sums[name] += line[name]
+        else:
+            stuck.append(line["참조"]["키"])
+        lines.append(line)
     out = {"줄": lines, **sums, "계": sum(sums.values()), "빠진입력": gaps, "멈춤": stuck}
     return to_json({**out, **_reflected(snapshot, labor, lines, area)})
 
 
+def _ref_lines(snapshot: Any, labor: dict[str, Any], start: int) -> list[dict]:
+    """참조 줄 — 기준 = 굳힌 사본(`참조사본`)을 복사본 단가로 펼친 1 단위 값
+    (입력값은 승격 때 고정)."""
+    from M02_MasterTemplete import M02_Labor_Ref as refs
+
+    copies = labor.get("참조사본") or {}
+    expand = refs.Expand(snapshot, lambda ref: copies.get(refs.ref_id(ref)))
+    out = []
+    for at, one in enumerate((labor.get("줄") or {}).get("담은로직") or [], start=start + 1):
+        if not (isinstance(one, dict) and isinstance(one.get("참조"), dict)):
+            continue
+        got = expand(one["참조"])
+        head = {"차례": at, "참조": one["참조"], "이름": got.get("이름"), "분모": got.get("단위")}
+        if got.get("기준") is None:
+            out.append({**head, "ok": False, "까닭": got.get("까닭")})
+            continue
+        out.append({**head, "ok": True, "갈래": "돈", **got["기준"]})
+    return out
+
+
 def _reflected(snapshot: Any, labor: dict[str, Any], lines: list[dict], area: Any) -> dict:
     """줄마다 수량 · 반영 + 자재 + 기준합 · 반영합 — 기준은 위 줄 그대로 · 알약은 가져온 때 것."""
     from M02_MasterTemplete import M02_Labor_Doc as labor_doc
@@ -318,8 +350,12 @@ def _reflected(snapshot: Any, labor: dict[str, Any], lines: list[dict], area: An
     pill_of = {code: pill for pill in labor.get("알약") or [] for code in pill.get("로직") or []}
     base = []
     for line in lines:
-        pill = pill_of.get(line["로직"]) or {}
         money = {k: line[k] for k in (*mf.COST_ITEMS, "계")} if line.get("갈래") == "돈" else None
+        if "참조" in line:  # 알약 키 = ref_id · 배 1(50-3)
+            head = {"참조": line["참조"], "알약": labor_doc.line_id(line), "배": 1}
+            base.append({**head, "분모": line.get("분모"), "기준": money})
+            continue
+        pill = pill_of.get(line["로직"]) or {}
         head = {"로직": line["로직"], "알약": pill.get("키"), "배": pill.get("배") or 1}
         base.append({**head, "분모": pill.get("단위"), "기준": money})
     mats = []
diff --git a/M02_MasterTemplete/M02_Item_Source.py b/M02_MasterTemplete/M02_Item_Source.py
index 73fc41052..ccd9c7af0 100644
--- a/M02_MasterTemplete/M02_Item_Source.py
+++ b/M02_MasterTemplete/M02_Item_Source.py
@@ -3,7 +3,8 @@
 모으는 것 = `{파일 이름: 내용}`:
     `집계.json` SS 줄 + 열 정의 · `도면.json` SD · `면적.json` SA ·
     `일위대가.json` = 층 `labor/<열id>.json` 문서(39-1c · 없으면 옛 UA 조합 줄)
-    + 담은 로직 줄(M01 시스템) + 알약(가져온 때 그대로) ·
+    + 담은 로직 줄(M01 시스템) + 알약(가져온 때 그대로) +
+    참조사본(단가승격 · 사전조합을 값으로 굳힘) ·
     `단가.json` 계산에 닿는 마스터 줄 전부(담은 로직 + 일위대가 자재 MT)
 `원본판` = 모은 내용의 해시 — 지금 층 · 마스터에서 다시 모은 판과 대어 「마스터가 바뀜」 을 앎.
 프로젝트가 고치는 값(`입력값.json` · `고른자재.json`)은 원본이 아니라 여기서 안 모음.
@@ -89,10 +90,13 @@ def labor_rows(ua_key: str) -> dict[str, Any] | None:
 
 def labor_doc_rows(doc: dict[str, Any]) -> dict[str, Any]:
     """일위대가 문서(39-1a) + 담은 로직 줄 + 알약(`M02_Labor_Doc.pills` · 가져온 때 그대로 —
-    복사본 계산이 마스터를 안 읽게)."""
+    복사본 계산이 마스터를 안 읽게) + 참조사본 `{ref_id: 문서}`(50-3 · 원본이 바뀌어도 그대로)."""
     from M02_MasterTemplete import M02_Labor_Doc as labor_doc
+    from M02_MasterTemplete import M02_Labor_Ref as refs
 
-    return {**logic_rows(doc), "알약": labor_doc.pills(doc)}
+    rows = {**logic_rows(doc), "알약": labor_doc.pills(doc)}
+    copies = refs.frozen(doc)
+    return {**rows, "참조사본": copies} if copies else rows
 
 
 def logic_rows(row: dict[str, Any]) -> dict[str, Any]:
@@ -142,7 +146,10 @@ def build_source(item: dict[str, Any]) -> dict[str, Any]:
         labor = labor_rows(str(row["일위대가"])) if row.get("일위대가") else None
     if labor is not None:
         files[LABOR_FILE] = labor
+    from M02_MasterTemplete import M02_Labor_Ref as refs
+
     logic_keys = [str(one.get("키")) for one in (labor or {}).get("로직", [])]
+    logic_keys += refs.frozen_logics((labor or {}).get("참조사본") or {})  # 굳힌 단가승격 로직
     materials = [str(m.get("코드")) for m in ((labor or {}).get("줄") or {}).get("자재") or []]
     wanted = logic_keys + [code for code in materials if code]
     files[PRICE_FILE] = prices.to_json(prices.collect(logic_keys, materials)) if wanted else {}
diff --git a/M02_MasterTemplete/M02_Labor_Doc.py b/M02_MasterTemplete/M02_Labor_Doc.py
index 51189cd41..d89f26d66 100644
--- a/M02_MasterTemplete/M02_Labor_Doc.py
+++ b/M02_MasterTemplete/M02_Labor_Doc.py
@@ -1,12 +1,15 @@
 """M02 일위대가 문서 `labor/<열id>.json` — 정리 · 검사 · 계산 · 알약(PLAN 39-1a · 설계_정함 1장).
 
-문서 = `{종류, 판, 열, 일위대가번, 단위, 본뜬, 담은로직: [{로직, 별칭, 메모, 입력값, 수량}],
+문서 = `{종류, 판, 열, 일위대가번, 단위, 본뜬, 담은로직: [{로직, 별칭, 메모, 입력값, 수량}
+| {참조: {층, 주인, 키}, 별칭, 메모, 수량}],
 자재: [{코드, 이름, 규격, 단위, 수량}], 계산값}` — 이름은 구조물 열 이름(따로 안 둠).
 수량 = `null`(면적산출 알약 칸 값 · 로직 알약 「이름|단위」 · 자재 알약 「자재|MT키」) | `{손: 수}`
 (손이 칸보다 앞섬) · 같은 로직 두 번 금지 · 입력값 = 그 로직 입력 이름만(빈 값 = 자동값).
 금액: 기준 = 결과단위 그대로(서버 단독 · M01 엔진) · 반영 = 기준 × 수량 ÷ 배 · 돈 아닌 로직은
 반영 없음 · 자재 기준 단가 = `master_material.element` 기본값 · 자재 줄에 값 열 다섯(`가격`) ·
 기준단가가 된 칸 이름(`기준칸`)도 실음(43-3).
+참조 줄(단가승격 · 사전조합 · 50-3) = 기준이 가리킨 문서 1 단위 값(펼침 `M02_Labor_Ref.Expand`) ·
+분모 = 그 문서 단위 · 배 1 · 알약 키 = `ref_id` · 같은 참조 두 번 금지 · 위 층만.
 짝(CLAUDE.md 5장 ①): 수량 · 반영 · 합 `settle` ↔ `M02_MasterTemplete_Labor_Calc.ts` —
 거울 시험 `resources/tester/test_m02_labor_calc_mirror.py`.
 """
@@ -19,6 +22,7 @@ from typing import Any
 
 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_Labor_Ref as refs
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 
 mf = m01.cm.mf
@@ -67,11 +71,27 @@ def clean(doc: Any) -> dict[str, Any]:
     if not isinstance(doc, dict):
         raise _bad("일위대가 문서가 묶음 아님")
     whole = m01.loaded()[1]
-    lines, seen = [], set()
+    lines, seen, here = [], set(), None
     for at, one in enumerate(doc.get("담은로직") or [], start=1):
         where = f"단가산출 로직 {at}째"
         if not isinstance(one, dict):
             raise _bad(f"{where} · 묶음 아님")
+        if one.get("참조") is not None and not one.get("로직"):
+            here = here or refs.here()
+            ref = refs.check_ref(one["참조"], where, here)
+            if refs.ref_id(ref) in seen:
+                raise _bad(f"{where} · 같은 참조를 두 번 담음 「{ref['키']}」")
+            seen.add(refs.ref_id(ref))
+            memo, alias = one.get("메모"), _alias(one.get("별칭"), where)
+            lines.append(
+                {
+                    "참조": ref,
+                    "별칭": alias,
+                    "메모": str(memo) if memo else None,
+                    "수량": _qty(one.get("수량"), where),
+                }
+            )
+            continue
         code = str(one.get("로직") or "")
         try:
             logic = whole.logic(code)
@@ -84,16 +104,11 @@ def clean(doc: Any) -> dict[str, Any]:
         given = one.get("입력값") or {}
         if not isinstance(given, dict):
             raise _bad(f"{where} · 입력값이 묶음 아님")
-        memo, alias = one.get("메모"), one.get("별칭")
-        if alias is not None and not isinstance(alias, str):
-            raise _bad(f"{where} · 별칭은 글")
-        alias = (alias or "").strip()
-        if len(alias) > ALIAS_MAX:
-            raise _bad(f"{where} · 별칭은 {ALIAS_MAX}자까지")
+        memo, alias = one.get("메모"), _alias(one.get("별칭"), where)
         lines.append(
             {
                 "로직": code,
-                "별칭": alias or None,
+                "별칭": alias,
                 "메모": str(memo) if memo else None,
                 "입력값": {k: v for k, v in given.items() if k in names and v not in (None, "")},
                 "수량": _qty(one.get("수량"), where),
@@ -133,6 +148,15 @@ def clean(doc: Any) -> dict[str, Any]:
     return out
 
 
+def _alias(alias: Any, where: str) -> str | None:
+    if alias is not None and not isinstance(alias, str):
+        raise _bad(f"{where} · 별칭은 글")
+    alias = (alias or "").strip()
+    if len(alias) > ALIAS_MAX:
+        raise _bad(f"{where} · 별칭은 {ALIAS_MAX}자까지")
+    return alias or None
+
+
 def from_combo(key: str) -> dict[str, Any]:
     """옛 일위대가 조합(마스터 UA = 실무문서 · 회사 UC · 개인 UP) → 일위대가 문서 몸 —
     담은로직 · 단위 복사 · 입력값 {} · 수량 null · 자재 [] · `본뜬` = 그 조합(층 · 주인 · 키).
@@ -161,8 +185,10 @@ def material_key(code: str) -> str:
 
 
 def pills(doc: dict) -> list[dict[str, Any]]:
-    """면적산출 알약 — 로직 물량 알약(`combo_pills` 그대로) + 자재 알약 「자재|MT키」."""
+    """면적산출 알약 — 로직 물량 알약(`combo_pills` 그대로) + 참조 알약(`refs.pill`) +
+    자재 알약 「자재|MT키」."""
     logic = combo_store.combo_pills({"담은로직": doc.get("담은로직") or []})["물량"]
+    logic += [refs.pill(one["참조"]) for one in doc.get("담은로직") or [] if _is_ref(one)]
     mats = [
         {
             "키": material_key(m["코드"]),
@@ -230,16 +256,25 @@ def _pick(hand: Any, key: Any, given: dict[str, Decimal]) -> tuple[Decimal | Non
     return None, "없음"
 
 
+def _is_ref(one: Any) -> bool:
+    return isinstance(one, dict) and isinstance(one.get("참조"), dict)
+
+
+def line_id(one: dict) -> Any:
+    """줄 가름 — 로직 키 · 참조 줄은 `ref_id`(짝 `Labor_Calc.ts` `lineId`)."""
+    return refs.ref_id(one["참조"]) if _is_ref(one) else one.get("로직")
+
+
 def settle(result: dict, doc: dict, given: dict[str, Any]) -> dict[str, Any]:
     """기준이 선 계산 답에 수량 · 반영 · 합을 채움 — 수량만 바뀌면 이것만 다시
     (짝: `Labor_Calc.ts` `settle` · 자재 = 재료비)."""
     have = {str(k): v for k, raw in given.items() if (v := _number(raw)) is not None}
-    hands = {one.get("로직"): one.get("수량") for one in doc.get("담은로직") or []}
+    hands = {line_id(one): one.get("수량") for one in doc.get("담은로직") or []}
     mhands = {one.get("코드"): one.get("수량") for one in doc.get("자재") or []}
     zero = dict.fromkeys((*COSTS, "계"), Decimal(0))
     lines, mats, bases, reflects = [], [], [], []
     for line in result.get("줄") or []:
-        qty, source = _pick(hands.get(line.get("로직")), line.get("알약"), have)
+        qty, source = _pick(hands.get(line_id(line)), line.get("알약"), have)
         base = _money(line.get("기준"))
         done = reflect(base, qty, _number(line.get("배")) or Decimal(1)) if base else None
         bases.append(base)
@@ -277,6 +312,7 @@ def calc(doc: dict, given: dict[str, Any] | None = None) -> dict[str, Any]:
     """`doc` = 정리한 문서 · `given` = {알약 키: 값}(없으면 지금 층 면적산출 파일에서) —
     줄마다 기준(서버 단독 · M01 엔진) → `settle`. 못 도는 줄은 까닭만(통째로 멈추지 않음)."""
     whole = m01.loaded()[1]
+    expand = refs.Expand(whole)
     by_logic = {
         code: pill
         for pill in combo_store.combo_pills({"담은로직": doc.get("담은로직") or []})["물량"]
@@ -284,6 +320,9 @@ def calc(doc: dict, given: dict[str, Any] | None = None) -> dict[str, Any]:
     }
     lines = []
     for one in doc.get("담은로직") or []:
+        if _is_ref(one):
+            lines.append(ref_line(one["참조"], expand(one["참조"])))
+            continue
         code = one["로직"]
         pill = by_logic.get(code) or {}
         line = {
@@ -292,17 +331,7 @@ def calc(doc: dict, given: dict[str, Any] | None = None) -> dict[str, Any]:
             "분모": pill.get("단위"),
             "배": pill.get("배") or 1,
         }
-        try:
-            logic = whole.logic(code)
-            auto = {k: v for k, v in m01.mau.values(whole, logic).items() if v is not None}
-            got = mf.run(whole, code, {**auto, **m01._dec(one.get("입력값") or {})})
-        except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
-            lines.append({**line, "기준": None, "까닭": str(e) or type(e).__name__})
-            continue
-        if "결과" in got:  # 돈 아닌 로직 — 반영 없음
-            lines.append({**line, "결과": got["결과"], "기준": None, "까닭": None})
-            continue
-        lines.append({**line, "기준": {k: got[k] for k in (*COSTS, "계")}, "까닭": None})
+        lines.append({**line, **run_line(whole, code, one.get("입력값"))})
     mats = [
         {
             "코드": one["코드"],
@@ -315,6 +344,30 @@ def calc(doc: dict, given: dict[str, Any] | None = None) -> dict[str, Any]:
     return settle(_json({"줄": lines, "자재": mats}), doc, have)
 
 
+def run_line(whole: Any, code: str, given: Any) -> dict[str, Any]:
+    """로직 한 줄 기준(서버 단독 · M01 엔진 · 빈 입력 = 자동값) — `{기준, 까닭}` ·
+    돈 아닌 로직은 `{결과, 기준: None}`(반영 없음)."""
+    try:
+        logic = whole.logic(code)
+        auto = {k: v for k, v in m01.mau.values(whole, logic).items() if v is not None}
+        got = mf.run(whole, code, {**auto, **m01._dec(given or {})})
+    except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
+        return {"기준": None, "까닭": str(e) or type(e).__name__}
+    if "결과" in got:
+        return {"결과": got["결과"], "기준": None, "까닭": None}
+    # 「줄」 = 그 로직 재료 · 노무 · 경비 줄(줄 누름 상세 · 50-4)
+    return {"기준": {k: got[k] for k in (*COSTS, "계")}, "줄": got["줄"], "까닭": None}
+
+
+def ref_line(ref: dict, got: dict[str, Any]) -> dict[str, Any]:
+    """참조 줄 계산 답 — 분모 = 가리킨 문서 단위 · 배 1 · `안` = 사전조합 안 줄(한 층)."""
+    line = {"참조": ref, "이름": got.get("이름"), "알약": refs.ref_id(ref), "분모": got.get("단위")}
+    line.update({"배": 1, "기준": got.get("기준"), "까닭": got.get("까닭")})
+    if "줄" in got:  # 단가승격 = 원 로직 키 · 표(줄 누름 상세 · 50-3 ④)
+        line.update({"원로직": got.get("로직"), "줄": got["줄"]})
+    return {**line, "안": got["안"]} if "안" in got else line
+
+
 def _json(value: Any) -> Any:
     """Decimal → JSON 수(정수면 int)."""
     if isinstance(value, Decimal):
diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py
new file mode 100644
index 000000000..a1c43145e
--- /dev/null
+++ b/M02_MasterTemplete/M02_Labor_Ref.py
@@ -0,0 +1,483 @@
+"""M02 일위대가 조합 서고 — 단가승격 · 사전조합 · 참조(PLAN 50-3 · 조사 갈래 A).
+
+자리 = 층 양식 길 새 종류 둘(`M02_Template_Layers.LIBRARY_KINDS`) — 파일 이름 = 키:
+    promote   `{층}/promote/SP-######.json` 단가승격
+              `{종류:"단가승격", 키, 이름, 단위, 배, 본뜬, 담은로직:[{로직, 입력값}]}` —
+              줄 하나 · 입력값은 승격 때 고정 · 값 = 로직 기준 ÷ 배(1 단위 값 · `배` 는 저장 때)
+    precombo  `{층}/precombo/SC-######.json` 사전조합
+              `{종류:"사전조합", 키, 이름, 단위, 본뜬, 담은로직:[{참조, 수량:{손}, 메모}
+              | {로직, 입력값, 메모, 수량:{손}}]}` — 승격 · 사전조합 · 단가산출 로직(51-11) ·
+              수량은 손(기본 1) · 값 = Σ 안 줄 1 단위 값 × 수량(로직 줄 = 기준 ÷ 배)
+참조 = `{층, 주인, 키}`(마스터 주인 null · 회사 `C` · 개인 `C/U`) — 종류는 키 머리(SP · SC) ·
+위 층만 가리킴(개인 → 그 개인 · 그 회사 · 마스터 / 회사 → 그 회사 · 마스터 / 마스터 → 마스터) ·
+같은 참조 두 번 · 순환(422)은 저장 때 막음 · 계산 때도 깊이 상한(`DEPTH`)에서 멈추고 까닭.
+지우기 = 쓰는 곳(모든 층 일위대가 · 사전조합)이 있으면 409 · 층 사이 복사 = 대상 층이 못 읽는
+참조는 그 문서도 같이 복사(새 키 · `본뜬`) · 프로젝트 = 참조사본으로 굳힘(`frozen`).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete import M02_Template_Layers as layers
+
+PREFIX = {"promote": "SP", "precombo": "SC"}
+TITLE = {"promote": "단가승격", "precombo": "사전조합"}
+DEPTH = 8  # 참조 깊이 상한(저장 · 계산 둘 다)
+REF_HEAD = "참조|"
+_KEY = re.compile(r"^(SP|SC)-(\d{6})$")
+_OWNER = {"company": re.compile(r"^\d+$"), "personal": re.compile(r"^\d+/\d+$")}
+
+Ref = dict[str, Any]
+Here = tuple[str, str | None]
+
+
+def _bad(text: str, status: int = 400) -> store.StoreError:
+    return store.StoreError(status, text)
+
+
+def kind_of(key: str) -> str:
+    return "promote" if str(key).startswith("SP") else "precombo"
+
+
+def ref_id(ref: Ref) -> str:
+    """참조 한 줄의 이름표 — 알약 키 · 줄 가름(짝 `Labor_Calc.ts` `lineId`)."""
+    return f"{REF_HEAD}{ref.get('층')}|{ref.get('주인') or ''}|{ref.get('키')}"
+
+
+# ── 자리 ──────────────────────────────────────────────────────────────
+def where(folder: str | Path) -> Here:
+    """층 폴더 → (층, 주인) — 저장소 밖 · 프로젝트는 ("project", None)."""
+    path = Path(folder).resolve()
+    if path in (Path(store.FOLDER).resolve(), layers.system_dir().resolve()):
+        return "system", None
+    try:
+        parts = path.relative_to(layers.storage_root()).parts
+    except ValueError:
+        return "project", None
+    if len(parts) == 2 and parts[1] == layers.TEMPLATES_DIRNAME:
+        return "company", parts[0]
+    if len(parts) == 3 and parts[2] == layers.TEMPLATES_DIRNAME:
+        return "personal", f"{parts[0]}/{parts[1]}"
+    return "project", None
+
+
+def here() -> Here:
+    return where(store.root())
+
+
+def folder_of(layer: str, owner: str | None) -> Path:
+    if layer == "system":
+        return Path(store.FOLDER)
+    if layer == "company":
+        return layers.company_dir(owner or "")
+    company, user = str(owner).split("/", 1)
+    return layers.personal_dir(company, user)
+
+
+def ref_path(ref: Ref) -> Path:
+    return folder_of(ref["층"], ref.get("주인")) / kind_of(ref["키"]) / f"{ref['키']}.json"
+
+
+def read_ref(ref: Ref) -> dict[str, Any] | None:
+    try:
+        got = json.loads(ref_path(ref).read_bytes())
+    except (OSError, ValueError):
+        return None
+    return got if isinstance(got, dict) else None
+
+
+def readable(at: Here, ref: Ref) -> bool:
+    """`at` 층이 `ref` 를 가리켜도 되나 — 위 층만(프로젝트는 아무것도 · 굳힌 사본만 씀)."""
+    layer, owner = at
+    if layer == "project":
+        return False
+    if ref["층"] == "system":
+        return True
+    if ref["층"] == "company":
+        return layer in ("company", "personal") and str(owner).split("/")[0] == ref["주인"]
+    return layer == "personal" and owner == ref["주인"]
+
+
+def check_ref(raw: Any, at: str, here_: Here) -> Ref:
+    """참조 꼴 · 위 층만 · 있는 문서 — 아니면 400."""
+    if not isinstance(raw, dict):
+        raise _bad(f"{at} · 참조는 {{층, 주인, 키}}")
+    layer, owner, key = raw.get("층"), raw.get("주인"), str(raw.get("키") or "")
+    if layer == "system":
+        owner = None
+    elif layer not in _OWNER or not _OWNER[layer].match(str(owner or "")):
+        raise _bad(f"{at} · 참조 층 · 주인 꼴이 틀림")
+    if not _KEY.match(key):
+        raise _bad(f"{at} · 참조 키는 SP-###### · SC-######")
+    ref = {"층": layer, "주인": None if owner is None else str(owner), "키": key}
+    if not readable(here_, ref):
+        raise _bad(f"{at} · 위 층만 가리킴 — 「{key}」({layer} {owner or ''})")
+    if read_ref(ref) is None:
+        raise _bad(f"{at} · 없는 참조 「{key}」")
+    return ref
+
+
+# ── 서고 문서 정리 ─────────────────────────────────────────────────────
+def check_key(kind: str, name: str) -> None:
+    found = _KEY.match(name)
+    if not found or found.group(1) != PREFIX[kind]:
+        raise _bad(f"{TITLE[kind]} 키는 {PREFIX[kind]}-######")
+
+
+def clean_doc(kind: str, doc: Any) -> dict[str, Any]:
+    """서고 문서를 서버가 받는 꼴로 — `doc["키"]` = 파일 이름(부르는 쪽이 넣음)."""
+    from M01_MasterData import M01_MasterData_Store_Combo as combo_store
+    from M02_MasterTemplete import M02_Labor_Doc as labor
+
+    if not isinstance(doc, dict):
+        raise _bad("서고 문서가 묶음 아님")
+    key = str(doc.get("키") or "")
+    check_key(kind, key)
+    name, unit = str(doc.get("이름") or "").strip(), str(doc.get("단위") or "").strip()
+    out: dict[str, Any] = {"종류": TITLE[kind], "키": key}
+    if kind == "promote":
+        lines = doc.get("담은로직") or []
+        if len(lines) != 1 or not isinstance(lines[0], dict) or not lines[0].get("로직"):
+            raise _bad("단가승격은 단가산출 로직 한 줄")
+        line = labor.clean({"담은로직": lines})["담은로직"][0]
+        pill = (combo_store.combo_pills({"담은로직": [line]})["물량"] or [{}])[0]
+        out.update(
+            이름=name or pill.get("이름") or line["로직"],
+            단위=unit or pill.get("단위") or None,
+            배=pill.get("배") or 1,  # ponytail: 저장 때 적음 · 마스터 결과단위가 바뀌면 다시 저장
+            담은로직=[{"로직": line["로직"], "입력값": line["입력값"]}],
+            **origin(line["로직"]),
+        )
+    else:
+        if not name:
+            raise _bad("사전조합 이름이 빔")
+        out.update(이름=name, 단위=unit or None, 담은로직=_combo_lines(doc, key))
+        out.update({k: str(doc.get(k) or "").strip() for k in ("구분", "상세구분")})
+    out["본뜬"] = doc["본뜬"] if isinstance(doc.get("본뜬"), dict) else None
+    return out
+
+
+def origin(code: str) -> dict[str, Any]:
+    """단가승격 칸 — 원 로직의 구분 · 상세구분 + 연결 {로직 키, 출처 글}(51-12 · 없으면 빈 글)."""
+    from M01_MasterData import M01_MasterData_Store as m01
+
+    try:
+        got = m01.loaded()[1].logic(code)
+    except m01.cm.mf.FormulaError:
+        got = {}
+    return {
+        "구분": got.get("구분") or "",
+        "상세구분": got.get("상세구분") or "",
+        "연결": {"로직": code, "출처": got.get("출처") or ""},
+    }
+
+
+def filled(kind: str, doc: Any) -> Any:
+    """옛 서고 문서(51-12 앞) 읽을 때 칸 채움 — 승격 = 원 로직 것 · 사전조합 = 빈 글(화면 몫)."""
+    if not isinstance(doc, dict) or kind not in PREFIX or "구분" in doc:
+        return doc
+    if kind == "precombo":
+        return {**doc, "구분": "", "상세구분": ""}
+    line = (doc.get("담은로직") or [{}])[0]
+    code = str(line.get("로직") or "") if isinstance(line, dict) else ""
+    return {**doc, **origin(code)}
+
+
+def _combo_lines(doc: dict, key: str) -> list[dict[str, Any]]:
+    """참조 줄 `{참조, 수량, 메모}` · 로직 줄 `{로직, 입력값, 메모, 수량}`(51-11) — 검사는
+    일위대가와 같은 길(`labor.clean` · 같은 로직 · 같은 참조 두 번 · 입력값) · 수량 기본 {손: 1}."""
+    from M02_MasterTemplete import M02_Labor_Doc as labor
+
+    lines = []
+    for one in labor.clean({"담은로직": doc.get("담은로직") or []})["담은로직"]:
+        head = {"참조": one["참조"]} if "참조" in one else {"로직": one["로직"]}
+        if "로직" in one:
+            head["입력값"] = one["입력값"]
+        lines.append({**head, "수량": one["수량"] or {"손": 1}, "메모": one["메모"]})
+    at_ = here()
+    me = {"층": at_[0], "주인": at_[1], "키": key}
+    for one in lines:
+        if "참조" not in one:
+            continue
+        if ref_id(one["참조"]) == ref_id(me):
+            raise _bad(f"순환 — 자기 자신을 담음 「{key}」", 422)
+        _no_loop(one["참조"], [me, one["참조"]])
+    return lines
+
+
+def _no_loop(ref: Ref, trail: list[Ref]) -> None:
+    """저장 때 순환 · 깊이 — 아래로 따라가 처음 문서를 다시 만나면 422 「A → B → A」."""
+    if len(trail) > DEPTH:
+        raise _bad(f"참조가 {DEPTH}단을 넘음 — " + " → ".join(r["키"] for r in trail), 422)
+    for one in (read_ref(ref) or {}).get("담은로직") or []:
+        child = one.get("참조") if isinstance(one, dict) else None
+        if not isinstance(child, dict) or not child.get("키"):
+            continue
+        if ref_id(child) == ref_id(trail[0]):
+            raise _bad("순환 — " + " → ".join(r["키"] for r in [*trail, child]), 422)
+        _no_loop(child, [*trail, child])
+
+
+def next_key(kind: str) -> str:
+    """지금 층 그 종류의 다음 키(가장 큰 번호 + 1)."""
+    folder = store.root() / kind
+    have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))]
+    return f"{PREFIX[kind]}-{max(have, default=0) + 1:06d}"
+
+
+def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
+    """지금 층에 새 키로 씀 → `store.write` 정보(+ 키) — 그새 남이 같은 키를 잡으면 다음 키."""
+    for _ in range(5):
+        key = next_key(kind)
+        try:
+            return store.write(kind, key, "", {**doc, "키": key})
+        except store.StoreError as e:
+            if e.status != 409 or not isinstance(e.detail, dict):
+                raise
+    raise _bad("새 키를 못 잡음 — 다시 누름", 409)
+
+
+def summary(folder: Path, kind: str, key: str, expand: Expand | None = None) -> dict[str, Any]:
+    """층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면
+    1 단위 기준 계(`기준금액` · 51-4)."""
+    try:
+        doc = filled(kind, json.loads((Path(folder) / kind / f"{key}.json").read_bytes()))
+    except (OSError, ValueError):
+        return {}
+    keep = ("구분", "상세구분", "연결")
+    out = {"제목": doc.get("이름"), "단위": doc.get("단위"), **{k: doc.get(k) for k in keep}}
+    if expand is not None:
+        layer, owner = where(folder)
+        base = expand({"층": layer, "주인": owner, "키": key}).get("기준") or {}
+        out["기준금액"] = float(base["계"]) if "계" in base else None
+    return out
+
+
+def summaries(folder: Path, rows: list[dict[str, Any]]) -> None:
+    """층 목록의 서고 줄마다 `summary`(값 포함) — 한 번 셈 캐시를 함께 씀."""
+    from M01_MasterData import M01_MasterData_Store as m01
+
+    expand = Expand(m01.loaded()[1])
+    for row in rows:
+        if row["종류"] in layers.LIBRARY_KINDS:
+            row.update(summary(folder, row["종류"], row["이름"], expand))
+
+
+# ── 쓰는 곳 · 지우기 ──────────────────────────────────────────────────
+def users(ref: Ref) -> list[str]:
+    """`ref` 를 담은 일위대가 · 사전조합 — 「어디 이름」 목록(모든 층 훑음 · 프로젝트 뺌)."""
+    rid, out = ref_id(ref), []
+    for kind, what in (("labor", "일위대가"), ("precombo", "사전조합")):
+        for at, path in layers.layer_files(kind):
+            try:
+                doc = json.loads(path.read_bytes())
+            except (OSError, ValueError):
+                continue
+            lines = doc.get("담은로직") if isinstance(doc, dict) else None
+            if any(
+                isinstance(one, dict)
+                and isinstance(one.get("참조"), dict)
+                and ref_id(one["참조"]) == rid
+                for one in lines or []
+            ):
+                name = doc.get("일위대가번") or doc.get("이름") or path.stem
+                out.append(f"{what} {at} 「{name}」")
+    return out
+
+
+def refuse_used(folder: Path, kind: str, key: str) -> None:
+    """쓰는 곳이 있으면 409 + 이름(서고 종류만)."""
+    if kind not in PREFIX:
+        return
+    layer, owner = where(folder)
+    found = users({"층": layer, "주인": owner, "키": key})
+    if found:
+        raise _bad(f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found), 409)
+
+
+# ── 층 사이 복사 ──────────────────────────────────────────────────────
+def carry(doc: dict[str, Any], source: Here) -> dict[str, Any]:
+    """복사(원본 층 `source` → 지금 층) — 지금 층이 못 읽는 참조는 그 문서를 지금 층에 새 키로
+    같이 복사(`본뜬` = 원래 참조) · 참조를 새 키로 바꿈. 원본 층 읽기 권한은 부르는 쪽 몫."""
+    target, done = here(), {}
+
+    def move(ref: Ref, depth: int) -> Ref:
+        if readable(target, ref):
+            return ref
+        if ref_id(ref) in done:
+            return done[ref_id(ref)]
+        if depth > DEPTH or not readable(source, ref):
+            raise _bad(f"복사할 수 없는 참조 「{ref.get('키')}」")
+        got = read_ref(ref)
+        if got is None:
+            raise _bad(f"없는 참조 「{ref['키']}」")
+        body = {**got, "담은로직": _moved(got.get("담은로직"), move, depth + 1), "본뜬": ref}
+        made = create(kind_of(ref["키"]), body)
+        done[ref_id(ref)] = {"층": target[0], "주인": target[1], "키": made["이름"]}
+        return done[ref_id(ref)]
+
+    return {**doc, "담은로직": _moved(doc.get("담은로직"), move, 1)}
+
+
+def _moved(lines: Any, move: Callable[[Ref, int], Ref], depth: int) -> list[Any]:
+    return [
+        {**one, "참조": move(one["참조"], depth)}
+        if isinstance(one, dict) and isinstance(one.get("참조"), dict)
+        else one
+        for one in lines or []
+    ]
+
+
+# ── 펼침(계산) ────────────────────────────────────────────────────────
+class Expand:
+    """참조 → `{이름, 단위, 기준(1 단위), 까닭, 안?}` — 한 번 셈 안에서 키별 캐시 ·
+    깊이 상한 · 순환은 까닭(통째로 멈추지 않음). `read` = 참조 → 문서(프로젝트는 굳힌 사본)."""
+
+    def __init__(self, whole: Any, read: Callable[[Ref], dict | None] = read_ref) -> None:
+        self.whole, self.read, self.memo = whole, read, {}
+
+    def __call__(self, ref: Ref, trail: tuple[str, ...] = ()) -> dict[str, Any]:
+        rid = ref_id(ref)
+        if rid in trail:
+            keys = [t.rsplit("|", 1)[-1] for t in (*trail, rid)]
+            return self._stop(ref, "순환 — " + " → ".join(keys))
+        if len(trail) >= DEPTH:
+            return self._stop(ref, f"참조가 {DEPTH}단을 넘음")
+        if rid not in self.memo:
+            doc = self.read(ref)
+            if not isinstance(doc, dict):
+                return self._stop(ref, f"없는 참조 「{ref['키']}」")
+            if kind_of(ref["키"]) == "promote":
+                self.memo[rid] = self._promote(doc)
+            else:
+                self.memo[rid] = self._combo(doc, (*trail, rid))
+        return self.memo[rid]
+
+    @staticmethod
+    def _stop(ref: Ref, why: str) -> dict[str, Any]:
+        return {"이름": ref["키"], "단위": None, "기준": None, "까닭": why}
+
+    def _promote(self, doc: dict) -> dict[str, Any]:
+        from M02_MasterTemplete import M02_Labor_Doc as labor
+
+        line = (doc.get("담은로직") or [{}])[0]
+        got = labor.run_line(self.whole, str(line.get("로직") or ""), line.get("입력값"))
+        times = labor._number(doc.get("배")) or Decimal(1)
+        base = got.get("기준")
+        why = got.get("까닭") or (None if base else "돈 아닌 로직")
+        return {
+            "이름": doc.get("이름"),
+            "단위": doc.get("단위"),
+            "로직": line.get("로직"),
+            "기준": {k: Decimal(str(v)) / times for k, v in base.items()} if base else None,
+            "까닭": why,
+            # 원 로직 줄(줄 누름 하위 행 · 51-2) — 1 단위로 나눔(하위 합 = 기준)
+            "줄": [
+                {
+                    **x,
+                    "수량": Decimal(str(x["수량"])) / times,
+                    "금액": Decimal(str(x["금액"])) / times,
+                    "비목": {k: Decimal(str(v)) / times for k, v in (x.get("비목") or {}).items()},
+                }
+                for x in got.get("줄") or []
+            ],
+        }
+
+    def _logic(self, one: dict, pill: dict | None) -> dict[str, Any]:
+        """사전조합 안 로직 줄 — 일위대가 로직 줄과 같은 `run_line` · 배는 물량 알약 것."""
+        from M02_MasterTemplete import M02_Labor_Doc as labor
+
+        pill = pill or {}
+        got = labor.run_line(self.whole, one["로직"], one.get("입력값"))
+        times = labor._number(pill.get("배")) or Decimal(1)
+        base = got.get("기준")
+        return {
+            "이름": pill.get("이름") or one["로직"],
+            "단위": pill.get("단위"),
+            "기준": {k: Decimal(str(v)) / times for k, v in base.items()} if base else None,
+            "까닭": got.get("까닭") or (None if base else "돈 아닌 로직"),
+        }
+
+    def _combo(self, doc: dict, trail: tuple[str, ...]) -> dict[str, Any]:
+        from M01_MasterData import M01_MasterData_Store_Combo as combo_store
+        from M02_MasterTemplete import M02_Labor_Doc as labor
+
+        lines = [one for one in doc.get("담은로직") or [] if isinstance(one, dict)]
+        by_logic = {
+            code: pill
+            for pill in combo_store.combo_pills({"담은로직": lines})["물량"]
+            for code in pill["로직"]
+        }
+        inner, rows, why = [], [], None
+        for one in lines:
+            ref = one.get("참조")
+            if isinstance(ref, dict):
+                head, sub = {"참조": ref}, self(ref, trail)
+            elif one.get("로직"):  # 로직 줄(51-11) = 1 단위 값(기준 ÷ 배 · 승격과 같음)
+                head, sub = {"로직": one["로직"]}, self._logic(one, by_logic.get(one["로직"]))
+            else:
+                continue
+            qty = labor._number((one.get("수량") or {}).get("손"))
+            qty = Decimal(1) if qty is None else qty
+            keep = ("이름", "단위", "기준", "까닭")
+            inner.append({**head, "수량": qty, **{k: sub.get(k) for k in keep}})
+            if sub.get("기준") is None:
+                why = why or f"「{sub.get('이름')}」 {sub.get('까닭')}"
+                continue
+            rows.append({k: v * qty for k, v in sub["기준"].items()})
+        return {
+            "이름": doc.get("이름"),
+            "단위": doc.get("단위"),
+            "기준": None if why else labor._sum(rows),
+            "까닭": why,
+            "안": inner,
+        }
+
+
+def pill(ref: Ref, read: Callable[[Ref], dict | None] = read_ref) -> dict[str, Any]:
+    """참조 줄 면적산출 알약 — 키 = `ref_id` · 이름 · 단위 = 가리킨 문서 것."""
+    doc = read(ref) or {}
+    return {
+        "키": ref_id(ref),
+        "이름": doc.get("이름") or ref["키"],
+        "단위": doc.get("단위") or "",
+        "로직": [],
+        "참조": ref,
+    }
+
+
+# ── 프로젝트 굳힘 ─────────────────────────────────────────────────────
+def frozen(doc: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    """일위대가 문서가 닿는 참조 문서 전부 `{ref_id: 문서}` — 가져올 때 값으로 굳힘
+    (원본이 바뀌어도 프로젝트는 그대로)."""
+    out: dict[str, dict[str, Any]] = {}
+
+    def walk(lines: Any, depth: int) -> None:
+        for one in lines or []:
+            ref = one.get("참조") if isinstance(one, dict) else None
+            if not isinstance(ref, dict) or ref_id(ref) in out or depth > DEPTH:
+                continue
+            got = read_ref(ref)
+            if got is not None:
+                out[ref_id(ref)] = got
+                walk(got.get("담은로직"), depth + 1)
+
+    walk(doc.get("담은로직"), 1)
+    return out
+
+
+def frozen_logics(copies: dict[str, Any]) -> list[str]:
+    """굳힌 단가승격 · 사전조합이 담은 로직 키 — 프로젝트 단가 묶음에 넣음."""
+    return [
+        str(line["로직"])
+        for doc in copies.values()
+        for line in doc.get("담은로직") or []
+        if isinstance(line, dict) and line.get("로직")
+    ]
diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py
index 233b1ae30..481ee952f 100644
--- a/M02_MasterTemplete/M02_Labor_Router.py
+++ b/M02_MasterTemplete/M02_Labor_Router.py
@@ -1,19 +1,22 @@
 """M02 일위대가 계산 · 알약 길(PLAN 39-1a · 설계_정함 1장) — `/api/m02/layers/{층}/labor/{열}/…`.
 
 문서 읽기 · 쓰기는 양식 길(`GET/PUT /api/m02/layers/{층}/templates/labor/{열}`) 그대로 ·
-여기는 저장하지 않는 셈만. 층 권한 = `Router_Items._root`(읽기 권한 · `M02_Layer_Access` 한 벌).
+여기는 저장하지 않는 셈만 + 서고(단가승격 · 사전조합 · 50-3) 새로 · 복사(키는 서버가 줌 · 고침 ·
+지우기는 양식 길 그대로). 층 권한 = `Router_Items._root`(`M02_Layer_Access` 한 벌).
 ⚠ 등록은 `main.py`(로그인만).
 """
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
 
 from common_util.common_util_auth import verify_session
 from M02_MasterTemplete import M02_Labor_Doc as labor
+from M02_MasterTemplete import M02_Labor_Ref as refs
+from M02_MasterTemplete import M02_Layer_Access as access
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _call, _root
 
@@ -62,3 +65,39 @@ def labor_pills(
 ) -> dict:
     """면적산출 알약 — 로직 물량 알약 「이름|단위」 + 자재 알약 「자재|MT키」(저장본)."""
     return _call(_root(session, layer, owner), _pills, column)
+
+
+class LibraryBody(BaseModel):
+    """새로 = `문서` · 복사 = `본뜬` {층, 주인, 키}(원본 읽기 권한 · 못 읽는 참조는 같이 복사)."""
+
+    문서: dict[str, Any] | None = None
+    본뜬: dict[str, Any] | None = None
+
+
+def _copy(kind: str, doc: dict[str, Any], source: refs.Here, ref: dict) -> dict[str, Any]:
+    return refs.create(kind, refs.carry({**doc, "본뜬": ref}, source))
+
+
+@router.post("/layers/{layer}/library/{kind}")
+def new_library(
+    layer: Layer,
+    kind: Literal["promote", "precombo"],
+    body: LibraryBody,
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+) -> dict:
+    """서고 새로 · 복사 — 키는 서버가 그 층 다음 번호(SP · SC) · 답 `이름` = 새 키."""
+    folder = _root(session, layer, owner, write=True)
+    if body.본뜬 is None:
+        return _call(folder, refs.create, kind, body.문서 or {})
+    src = body.본뜬
+    if src.get("층") not in ("system", "company", "personal"):
+        raise HTTPException(status_code=400, detail="본뜬 층이 틀림")
+    got = access.grant(session, src["층"], src.get("주인"))  # 원본 읽기 권한
+    ref = {"층": got.layer, "주인": got.owner, "키": str(src.get("키") or "")}
+    if refs.kind_of(ref["키"]) != kind:
+        raise HTTPException(status_code=400, detail="본뜬 종류가 틀림")
+    doc = refs.read_ref(ref) if refs._KEY.match(ref["키"]) else None
+    if doc is None:
+        raise HTTPException(status_code=404, detail=f"없는 {refs.TITLE[kind]} 「{ref['키']}」")
+    return _call(folder, _copy, kind, doc, (got.layer, got.owner), ref)
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
index e0569ac5c..a76619d33 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
@@ -9,8 +9,9 @@ import { API_BASE_URL } from "@config/config_frontend";
 export type Layer = "system" | "company" | "personal" | "project";
 /** 서버 종류 — 화면의 「표 양식」 = table · 「도면 양식」 = drawing · 「구조물 도면」 = structure ·
  * 「면적산출」 = area(구조물집계표 열마다 한 통합문서) ·
- * 「일위대가」 = labor(열마다 문서 · 39장) */
-export type Kind = "table" | "drawing" | "structure" | "area" | "labor";
+ * 「일위대가」 = labor(열마다 문서 · 39장) ·
+ * 「단가승격」 = promote · 「사전조합」 = precombo(일위대가 조합 서고 · 50-3 · 키가 이름) */
+export type Kind = "table" | "drawing" | "structure" | "area" | "labor" | "promote" | "precombo";
 
 export interface TemplateInfo {
   종류: Kind;
@@ -125,6 +126,19 @@ export const deleteLayerTemplate = (
     method: "DELETE",
   });
 
+/** 서고 새로 · 복사(50-3) — 새로 = `문서` · 복사 = `본뜬` {층, 주인, 키} · 키는 서버가 줌(답 `이름`) */
+export type LibraryBody =
+  { 문서: Record<string, unknown> } | { 본뜬: { 층: Layer; 주인: string | null; 키: string } };
+export const newLibrary = (
+  layer: Layer,
+  kind: "promote" | "precombo",
+  body: LibraryBody,
+): Promise<TemplateInfo> =>
+  call(owned(layer, `/layers/${layer}/library/${kind}`), {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
 /* --- 구조물 도면(종류 structure · 이름 = 구조물집계표 열 id) ---
  * 읽기 · 저장 · 지우기는 위 readTemplate · saveTemplate · deleteTemplate 에 "structure" */
 
diff --git a/M02_MasterTemplete/M02_MasterTemplete_AreaToDrawing.ts b/M02_MasterTemplete/M02_MasterTemplete_AreaToDrawing.ts
index f686ed1e3..da16b9918 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_AreaToDrawing.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_AreaToDrawing.ts
@@ -19,7 +19,13 @@ import {
   showToast,
 } from "@ui/ui_template_elements";
 import { openModal } from "@ui/ui_template_modal";
-import { getActiveOwner, type Layer, type StructureDoc } from "./M02_MasterTemplete_Api_Fetch";
+import {
+  getActiveOwner,
+  readTemplate,
+  type Layer,
+  type StructureDoc,
+} from "./M02_MasterTemplete_Api_Fetch";
+import type { LinkOptions } from "../A00_Common/spreadsheet/spreadsheet";
 import type { Selection } from "./M02_MasterTemplete_UI_Main";
 
 /** 표 칸 하나(CAD `TableCell` 꼴에서 쓰는 것만) */
@@ -71,6 +77,8 @@ const TEXT = {
   noPlace: "이 도면 화면은 표 놓기를 아직 못 함",
   stale: "면적산출 값이 바뀐 표 {n}개",
   update: "업데이트",
+  tag: "{id} 도면",
+  tip: "도면 표 {id} 로 보낸 범위 {range} · 글자 {size}",
   updated: "표 {n}개를 지금 면적 값으로 바꿈 — [저장]하면 남음",
 } as const;
 
@@ -112,6 +120,22 @@ const sameValues = (a: Record<string, string> = {}, b: Record<string, string> =
   return ka.length === Object.keys(b).length && ka.every((k) => a[k] === b[k]);
 };
 
+/** 면적 시트에 겹쳐 보일 「도면으로 보낸 범위」 — 같은 열 도면 `연결표` 에서(받기 실패 = 없음 · 조용히) */
+export async function sentRanges(at: Selection): Promise<NonNullable<LinkOptions["표시범위"]>> {
+  try {
+    const got = await readTemplate(at.layer, "structure", at.name, at.projectId);
+    const rows = (got.문서 as StructureDoc | undefined)?.연결표 ?? [];
+    return rows.map((row) => ({
+      시트: row.시트,
+      범위: row.범위,
+      이름: fill(TEXT.tag, "id", row.연결),
+      설명: fill(fill(fill(TEXT.tip, "id", row.연결), "range", row.범위), "size", row.글자크기),
+    }));
+  } catch {
+    return [];
+  }
+}
+
 export interface AreaToDrawingOptions {
   /** 같은 페이지에서 그 열 도면 상세를 엶(`UI_Main.open`) */
   open: (sel: Selection) => Promise<void>;
diff --git a/M02_MasterTemplete/M02_MasterTemplete_CardHelp.ts b/M02_MasterTemplete/M02_MasterTemplete_CardHelp.ts
index 5cb0d4159..1547bfc40 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_CardHelp.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_CardHelp.ts
@@ -95,3 +95,24 @@ export const CARD_HELP: Record<"structure" | "labor" | "area", CardHelp> = {
     ],
   },
 };
+
+/** 상세에만 있는 단추 줄(49-7) — 카드 도움말 글 한 벌 뒤에 더함 */
+const DETAIL_ONLY: Record<keyof typeof CARD_HELP, [string, string][]> = {
+  structure: [["파일 불러오기", "DXF · DWG 파일을 도면으로 불러옴(상세 머리 📂)"]],
+  labor: [],
+  area: [["도면으로 보내기", "고른 범위를 도면 표로 보냄(상세 머리)"]],
+};
+const BACK: [string, string] = ["돌아가기", "구조물집계표로 · 그 열을 고른 채"];
+
+/** 상세 머리 [?] 글 — 카드 글 그대로 + 상세에만 있는 줄 */
+export const detailHelp = (kind: keyof typeof CARD_HELP): CardHelp => ({
+  ...CARD_HELP[kind],
+  features: [...CARD_HELP[kind].features, ...DETAIL_ONLY[kind], BACK],
+});
+
+/** 도움말 상자 제목 — 카드 제목과 같은 글 */
+export const HELP_TITLE: Record<keyof typeof CARD_HELP, string> = {
+  structure: "도면 정보",
+  labor: "일위대가",
+  area: "면적산출",
+};
diff --git a/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts b/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts
index fec69381a..e87486094 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts
@@ -159,8 +159,11 @@ const pairs = (rows: [string, string][]): HTMLElement =>
     children: rows.flatMap(([key, what]) => [el("dt", { text: key }), el("dd", { text: what })]),
   });
 
-/** ? — 카드 제목 바로 옆 · 누르면 도움말 상자(카드 오른쪽 위 · 보이고 숨김) · 상자는 본문 앞에 끼움 */
-export function helpButton(shell: CardShell, title: string, help: CardHelp): HTMLElement {
+/** ? 단추 + 도움말 상자 한 쌍(카드 · 상세 머리 공용 · 49-7) — 놓는 자리는 부른 쪽이 정함 */
+export function helpParts(
+  title: string,
+  help: CardHelp,
+): { button: HTMLElement; box: HTMLElement } {
   const button = createButton({ label: CARD_TEXT.help, variant: "ghost", size: "sm" });
   button.title = button.ariaLabel = CARD_TEXT.helpTip.replace("{value}", title);
   button.classList.add("m02-struct__help");
@@ -188,6 +191,12 @@ export function helpButton(shell: CardShell, title: string, help: CardHelp): HTM
     event.stopPropagation(); // 누름 ≠ 접기
     box.hidden = !box.hidden;
   });
+  return { button, box };
+}
+
+/** ? — 카드 제목 바로 옆 · 누르면 도움말 상자(카드 오른쪽 위 · 보이고 숨김) · 상자는 본문 앞에 끼움 */
+export function helpButton(shell: CardShell, title: string, help: CardHelp): HTMLElement {
+  const { button, box } = helpParts(title, help);
   shell.title.after(button);
   shell.root.insertBefore(box, shell.body);
   return button;
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Items.py b/M02_MasterTemplete/M02_MasterTemplete_Items.py
index 4edfb4f89..44851ff8d 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Items.py
+++ b/M02_MasterTemplete/M02_MasterTemplete_Items.py
@@ -176,7 +176,7 @@ def copy_item(
             have = store.read(kind, new_id)["문서"]
             body = {k: v for k, v in got.items() if k != "계산값"}
             body = {**body, "열": new_id, number: have.get(number)}
-            body = store._server(kind, body)
+            body = store._server(kind, body, source)
             with store._LOCK:
                 atomic_write_json(store._path(kind, new_id), body)
         store._refresh_labor(new_id)  # 면적이 일위대가 뒤에 서므로 칸 값으로 다시
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor.css b/M02_MasterTemplete/M02_MasterTemplete_Labor.css
index d80e0e147..bf59b0c4f 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor.css
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor.css
@@ -90,6 +90,14 @@
   white-space: nowrap;
 }
 
+/* 순서 칸 2행(51-14) — 위 [위로] [아래로] / 아래 [옵션]·[수정] [삭제] · 줄 사이도 단추 묶음 간격 */
+.m02-labrow__tools {
+  display: inline-flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: var(--btn-group-gap);
+}
+
 /* 옵션 값 줄(44-6) — 이름 ~ 합계에 걸친 한 줄 말줄임(max-width 0 = 표 폭을 안 늘림) · 위 줄과 한 덩이 */
 .m02-labrow .m02-labrow__optrow td {
   padding-top: 0;
@@ -130,6 +138,26 @@
   box-shadow: inset 3px 0 0 var(--color-primary);
 }
 
+/* 구분 칸(50-4) — 넉 자 · 흐린 글 */
+.m02-labrow__kind {
+  white-space: nowrap;
+  color: var(--color-text-secondary);
+}
+
+/* 줄 접고 폄 표(51-2) · 고른 줄 하위 행 — 이름 들여쓰기 · 흐린 바탕 · 위 줄보다 촘촘(51-7) */
+.m02-labrow .m02-labrow__sub td {
+  padding: var(--spacing-4) var(--spacing-8);
+  background: var(--color-bg);
+  font-size: var(--text-caption);
+  line-height: 1.3;
+}
+
+.m02-labrow .m02-labrow__sub .m02-labrow__subname {
+  padding-left: var(--spacing-24);
+  color: var(--color-text-secondary);
+  font-size: var(--text-body-sm);
+}
+
 /* 별칭 칸(44-6) — 칸 안 글상자 · 누르면 바로 고침 */
 .m02-labrow__alias {
   min-width: 7rem;
@@ -159,6 +187,11 @@
   color: var(--color-primary);
 }
 
+/* 참조 줄 모달(51-14) — 일위조합 [수정] = 사전조합 상세 */
+.m02-labref {
+  width: min(72rem, calc(100vw - 32px));
+}
+
 /* 입력 모달 */
 .m02-labin {
   width: min(40rem, calc(100vw - 32px));
@@ -259,6 +292,12 @@
     max-width: none;
   }
 
+  .m02-labrow .m02-labrow__kind {
+    grid-column: 1 / -1;
+    order: 1;
+    font-size: var(--text-caption);
+  }
+
   .m02-labrow .m02-labrow__no,
   .m02-labrow .m02-labrow__unit:not([data-label]),
   .m02-labrow .m02-labrow__code,
@@ -322,6 +361,7 @@
 
   /* 옵션 값 줄 — 한 줄 통째 */
   .m02-labrow__optrow .m02-labrow__no,
+  .m02-labrow__sum .m02-labrow__kind,
   .m02-labrow__sum .m02-labrow__alias {
     display: none;
   }
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts
index 5e7b50172..c896cb70a 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts
@@ -11,8 +11,9 @@ import {
   type LogicSummary,
   type SubBrief,
 } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
-import type { LaborCalc } from "./M02_MasterTemplete_Labor_Calc";
+import type { LaborCalc, LaborRef } from "./M02_MasterTemplete_Labor_Calc";
 import {
+  call,
   getActiveLayer,
   getActiveOwner,
   type ItemLogic,
@@ -118,9 +119,11 @@ export const fetchLibLogicSubs = (): Promise<SubBrief[]> =>
 
 /** 손 입력 수량 — `null` 이면 면적산출 알약 연결(칸)을 따름 · 손이 칸보다 앞섬 */
 export type LaborQty = { 손: number } | null;
-/** 담은 로직 한 줄 — 입력값 = 그 로직 입력 이름만(빈 값 = 자동값) */
+/** 담은 로직 한 줄 — 입력값 = 그 로직 입력 이름만(빈 값 = 자동값) ·
+ * 참조 줄(단가승격 · 사전조합 · 50-3) = `참조` 있고 `로직` 빈 글 · 줄 가름은 `lineId` */
 export interface LaborRow {
   로직: string;
+  참조?: LaborRef;
   /** 사용자가 지은 이름(44-6 · 빈 것 = null) */
   별칭?: string | null;
   메모: string | null;
@@ -154,11 +157,13 @@ export function normalizeLabor(doc: unknown, column: string): LaborDoc {
     열: d.열 ?? column,
     단위: d.단위 ?? null,
     담은로직: (d.담은로직 ?? []).map((r) => ({
-      로직: r.로직,
+      로직: r.로직 ?? "",
+      ...(r.참조 ? { 참조: r.참조 } : {}),
       별칭: r.별칭 ?? null,
       메모: r.메모 ?? null,
       입력값: r.입력값 ?? {},
       수량: r.수량 ?? null,
+      ...(r.참조 ? { 참조: r.참조 } : {}),
     })),
     자재: (d.자재 ?? []).map((m) => ({
       코드: m.코드,
@@ -223,6 +228,27 @@ export const calcLabor = (
     ...(수량 ? { 수량 } : {}),
   });
 
+/** 서고 한 줄(50-3) — 키 = SP-· SC-###### · 제목 · 단위 = 문서 것 */
+export interface LibraryRow {
+  이름: string;
+  제목?: string | null;
+  단위?: string | null;
+  /** 단가승격 = 원 로직 것 · 사전조합 = 사용자가 고름(51-12) */
+  구분?: string | null;
+  상세구분?: string | null;
+}
+/** 서고 목록 — 그 층(주인) 단가승격 `promote` · 사전조합 `precombo` 문서 */
+export const fetchLibrary = async (
+  ref: Omit<LaborRef, "키">,
+  kind: "promote" | "precombo",
+): Promise<LibraryRow[]> => {
+  const q = ref.주인 && ref.층 !== "system" ? `?owner=${enc(ref.주인)}` : "";
+  const got = await call<{ 양식: (LibraryRow & { 종류: string })[] }>(
+    `/layers/${ref.층}/templates${q}`,
+  );
+  return got.양식.filter((r) => r.종류 === kind);
+};
+
 /** 담은 로직 입력 목록 + 자동값(입력 모달 · `M02_Labor_Inputs`) */
 export const fetchLogicInputs = (
   keys: string[],
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts
index dd9da6fe9..54e3b3e2e 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts
@@ -3,7 +3,10 @@
  * 짝(CLAUDE.md 5장 ①): `M02_Labor_Doc.py` `settle` 과 같은 규칙 —
  * 거울 시험 `resources/tester/test_m02_labor_calc_mirror.py`.
  * 기준(결과단위 그대로)은 서버 calc 길이 셈 · 여기는 받은 기준에
- * 수량(손이 칸보다 앞섬 · 칸 = 알약 키 값) · 반영 = 기준 × 수량 ÷ 배 · 자재 = 재료비만. */
+ * 수량(손이 칸보다 앞섬 · 칸 = 알약 키 값) · 반영 = 기준 × 수량 ÷ 배 · 자재 = 재료비만.
+ * 참조 줄(단가승격 · 사전조합 · 50-3)은 `lineId` = 「참조|층|주인|키」(짝 `M02_Labor_Ref.ref_id`). */
+
+import type { CalcLine as LogicLine } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
 
 export const MONEY_KEYS = ["노무비", "재료비", "경비", "계"] as const;
 export type Money = Record<(typeof MONEY_KEYS)[number], number>;
@@ -11,8 +14,17 @@ export type QtySource = "손" | "칸" | "없음";
 /** 문서의 수량 칸 — null = 면적산출 알약 · {손} = 손 입력 */
 export type Qty = { 손: number } | null;
 
+/** 참조 — 단가승격(SP) · 사전조합(SC) 문서(50-3) */
+export interface LaborRef {
+  층: string;
+  주인: string | null;
+  키: string;
+}
+
 export interface CalcLine {
+  /** 참조 줄은 서버 답에 없음(빈 글로 다룸) */
   로직: string;
+  참조?: LaborRef;
   알약?: string | null;
   분모?: string | null;
   배: number;
@@ -22,6 +34,21 @@ export interface CalcLine {
   반영?: Money | null;
   까닭?: string | null;
   결과?: unknown;
+  /** 그 로직 재료 · 노무 · 경비 줄(M01 시험계산 표와 같은 모양 · 50-4) */
+  줄?: LogicLine[];
+  /** 참조 줄 — 가리킨 문서 이름 · 단가승격의 원 로직 키 · 사전조합 안 줄(한 층 · 50-3 ④ ·
+   * 참조 줄 = `참조` · 로직 줄(51-11) = `로직`) */
+  이름?: string | null;
+  원로직?: string | null;
+  안?: {
+    참조?: LaborRef;
+    로직?: string;
+    수량: number;
+    이름?: string | null;
+    단위?: string | null;
+    기준: Money | null;
+    까닭?: string | null;
+  }[];
 }
 
 export interface CalcMaterial {
@@ -47,7 +74,7 @@ export interface LaborCalc {
 
 /** 수량만 보는 문서 조각 — 담은 로직 · 자재의 손 값 */
 export interface LaborQtyDoc {
-  담은로직?: { 로직: string; 수량?: Qty }[];
+  담은로직?: { 로직?: string; 참조?: LaborRef; 수량?: Qty }[];
   자재?: { 코드: string; 수량?: Qty }[];
 }
 
@@ -57,6 +84,12 @@ function num(raw: unknown): number | null {
   return String(raw).trim() !== "" && Number.isFinite(n) ? n : null;
 }
 
+/** 줄 가름 — 로직 키 · 참조 줄은 「참조|층|주인|키」(짝 `M02_Labor_Doc.line_id`) */
+export function lineId(one: { 로직?: string; 참조?: LaborRef }): string | undefined {
+  if (one.참조) return `참조|${one.참조.층}|${one.참조.주인 ?? ""}|${one.참조.키}`;
+  return one.로직;
+}
+
 function zero(): Money {
   return { 노무비: 0, 재료비: 0, 경비: 0, 계: 0 };
 }
@@ -91,7 +124,7 @@ export function settle(
     const v = num(raw);
     if (v !== null) have[k] = v;
   }
-  const hands = new Map((doc.담은로직 ?? []).map((one) => [one.로직, one.수량 ?? null]));
+  const hands = new Map((doc.담은로직 ?? []).map((one) => [lineId(one), one.수량 ?? null]));
   const mhands = new Map((doc.자재 ?? []).map((one) => [one.코드, one.수량 ?? null]));
   const base = zero();
   const done = zero();
@@ -99,7 +132,7 @@ export function settle(
     if (m) for (const k of MONEY_KEYS) sum[k] += m[k];
   };
   const 줄 = result.줄.map((line) => {
-    const [qty, source] = pick(hands.get(line.로직), line.알약, have);
+    const [qty, source] = pick(hands.get(lineId(line)), line.알약, have);
     const own = line.기준 ? reflect(line.기준, qty, num(line.배) || 1) : null;
     add(base, line.기준);
     add(done, own);
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts
index 24b45bd61..236f211c6 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts
@@ -2,32 +2,46 @@
  * M02_MasterTemplete_Labor_Detail.ts
  * 일위대가 상세(39-3) — 구조물 열마다 하나(`labor/<열>.json`) · UI_Main 종류 `labor` 가 이 부품을 붙임
  * (양식 길 읽기 · [저장] · [다시 읽기]는 UI_Main). 차례 = 정보(단위 · 본뜬) → 담은 로직 → 자재목록 → 다이어그램.
- *  · 담은 로직 줄 누름 = 고름(하이라이트 · 다시 그려도 유지 · 47-5) · [옵션] = 입력 모달(`Labor_Input`) ·
+ *  · 담은 로직 줄 누름 = 고름(하이라이트 · 다시 그려도 유지 · 47-5) + 그 줄 바로 아래 하위 행(51-2 · `Labor_Rows`) ·
+ *    같은 줄 다시 누르면 닫힘 · [옵션] = 입력 모달(`Labor_Input`) · 참조 줄 [옵션] · [수정] = 서고 원본 모달(51-14 · `Labor_RefEdit`) ·
  *    [확인] = 화면 캐시만 · 저장은 [저장]
  *  · 금액 = 서버 calc(기준 ③ · 최신 응답만 · 저장 안 함) · 고칠 때마다 뒤에서 다시 셈
  *  · 같은 로직 두 번 · 같은 자재 두 번 막음 · 빈 일위대가도 저장 됨
  *  · 오른쪽 「원문」 접는 패널(47-4 · 상세만 · 공용 `ui_template_side_panels`) = 고른 줄 로직의 출처 원문
+ *  · 서고 모드(50-3 · `mode`) = 단가승격 · 사전조합 — 이름 칸 · 단가산출 로직 표 · 원문만(자재 · 면적 · 다이어그램 없음) ·
+ *    정보 칸 구분 · 상세구분(51-12 · 승격 = 읽기만 + 연결 · 사전조합 = 고름) ·
+ *    승격은 로직 한 줄(입력값 고정 · 더하기 · 순서 · 수량 없음) · 사전조합 = 일위대가 상세와 같은 [로직 추가] · 표 · 동작(51-11) · 수량 손 입력(기본 1)
  * ========================================================================== */
 
-import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
+import {
+  createButton,
+  createInputField,
+  createSelectField,
+  el,
+  showToast,
+} from "@ui/ui_template_elements";
 import { createSidePanels } from "@ui/ui_template_side_panels";
 import { ROUTES } from "@config/config_frontend";
 import { navigateTo } from "../A00_Common/router";
 import { setPendingLogicKey } from "../M01_MasterData/M01_MasterData_UI_Side";
 import { createSourceView } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Source";
+import type { SubBrief } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
 import type { Workbook } from "../A00_Common/spreadsheet/spreadsheet";
 import { recalcWorkbook } from "../A00_Common/spreadsheet/spreadsheet_recalc";
 import {
+  getActiveLayer,
+  getActiveOwner,
   readTemplate,
   saveTemplate,
   type ItemLogic,
   type Layer,
 } from "./M02_MasterTemplete_Api_Fetch";
 import { linkAreaCell } from "./M02_MasterTemplete_AreaCellPick";
-import { settle } from "./M02_MasterTemplete_Labor_Calc";
+import { lineId, settle, type LaborRef } from "./M02_MasterTemplete_Labor_Calc";
 import {
   areaLinks,
   calcLabor,
+  fetchLibLogicSubs,
   fetchLogicInputs,
   normalizeLabor,
   type LaborCalc,
@@ -42,6 +56,7 @@ import {
 } from "./M02_MasterTemplete_Labor_Diagram";
 import { openLaborInput, type GoArea } from "./M02_MasterTemplete_Labor_Input";
 import { openQtyModal } from "./M02_MasterTemplete_Labor_QtyModal";
+import { openRefEdit } from "./M02_MasterTemplete_Labor_RefEdit";
 import { openLogicPicker } from "./M02_MasterTemplete_Labor_Pick";
 import { logicTable, matTable, qtyShort } from "./M02_MasterTemplete_Labor_Rows";
 import { tc } from "./M02_MasterTemplete_Labor_Text";
@@ -62,8 +77,10 @@ export interface LaborDetailOptions {
   /** 「면적산출에서 잇기」 — 그 열 면적산출 상세로(옮겨 가면 참 · 취소 = 거짓 · 없으면 단추 없음) */
   goArea: GoArea | null;
   /** 구조물 조합 카드 갈래(43-4) — 단가산출 로직 표 + 자재목록만 · 위로 · 아래로 · 로직 추가 ·
-   * 정보(단위 · 본뜬) · 다이어그램 없음 · 옵션 · 삭제 · 자재 추가 · 줄 · 수량 모달은 상세와 같음 */
+   * 자재 추가 · 정보(단위 · 본뜬) · 다이어그램 없음 · 옵션 · 삭제 · 줄 · 수량 모달은 상세와 같음 */
   card?: boolean;
+  /** 일위대가 조합 서고(50-3) — 단가승격 · 사전조합 문서(`column` = 키) */
+  mode?: "promote" | "precombo";
 }
 
 export interface LaborDetailHandle {
@@ -82,6 +99,8 @@ export function mountLaborDetail(
   const cur = normalizeLabor(doc, opt.column);
   const saved = JSON.stringify(cur);
   const edit = !opt.readOnly;
+  const lib = opt.mode ?? null;
+  const promote = lib === "promote";
   const logics = new Map<string, ItemLogic>();
   let calc: LaborCalc | null = null;
   let fail: string | null = null;
@@ -131,13 +150,13 @@ export function mountLaborDetail(
     if (sourceHost.firstChild !== source.root) sourceHost.replaceChildren(source.root);
   }
 
-  const lineOf = (key: string) => calc?.줄.find((l) => l.로직 === key);
+  const lineOf = (key: string) => calc?.줄.find((l) => lineId(l) === key);
   const matOf = (code: string) => calc?.자재.find((m) => m.코드 === code);
 
   const drawDg = (): void => {
-    if (opt.card || !dgBox.open) return; // 카드 갈래엔 다이어그램 없음
+    if (opt.card || lib || !dgBox.open) return; // 카드 갈래 · 서고 모드엔 다이어그램 없음
     const data = buildLaborDiagram({
-      rows: cur.담은로직,
+      rows: cur.담은로직.filter((r) => !r.참조), // ponytail: 참조 줄은 다이어그램에 안 그림 — 그릴 때 카드 꼴 더함
       logics: [...logics.values()],
       calc,
       mats: cur.자재.length,
@@ -156,23 +175,26 @@ export function mountLaborDetail(
   };
   dgBox.addEventListener("toggle", drawDg);
 
-  const draw = (): void => {
+  const drawLogic = (): void =>
     logicHost.replaceChildren(
       logicTable(
         { rows: cur.담은로직, logics, calc, fail, cells: cells(), selected: picked },
         // 읽기만이면 순서 · 삭제 없음([옵션] = 보기 모달은 둠)
-        edit
+        edit && !promote
           ? {
               open: pick,
               option: openRow,
+              ref: openRef,
               qty: openQty,
               ...(opt.card ? {} : { move }),
               remove: removeRow,
               alias: setAlias,
             }
-          : { open: pick, option: openRow },
+          : { open: pick, option: openRow, ref: openRef },
       ),
     );
+  const draw = (): void => {
+    drawLogic();
     matHost.replaceChildren(
       matTable(
         { mats: cur.자재, calc, fail, cells: cells() },
@@ -261,6 +283,7 @@ export function mountLaborDetail(
       readOnly: !edit,
       sheet: { doc: area?.doc ?? null, layer: opt.layer, column: opt.column, pill },
       goArea: opt.goArea,
+      ...(lib ? { handOnly: true } : {}),
       done: (r) => {
         if (r.kind === "keep") return;
         if (r.kind === "hand") target.수량 = { 손: r.손 };
@@ -277,7 +300,7 @@ export function mountLaborDetail(
 
   /** 아직 안 받은 로직 입력 목록만 받음 */
   const loadLogics = async (): Promise<void> => {
-    const want = cur.담은로직.map((r) => r.로직).filter((k) => !logics.has(k));
+    const want = cur.담은로직.map((r) => r.로직).filter((k) => k && !logics.has(k)); // 참조 줄 = 로직 없음
     if (!want.length) return;
     try {
       const got = await fetchLogicInputs(want);
@@ -293,15 +316,16 @@ export function mountLaborDetail(
     [cur.담은로직[i], cur.담은로직[j]] = [cur.담은로직[j], cur.담은로직[i]];
     changed();
   }
-  /** 줄 고름(47-5) — 하이라이트(표만 · 다이어그램 안 다시 그림) + 원문 패널(47-4) · 화면 캐시 안 바뀜 */
+  /** 줄 고름(47-5) — 하이라이트 + 하위 행(51-2 · 표만 다시 그림 · 다이어그램 안 다시 그림) + 원문 패널(47-4) ·
+   * 고른 줄 다시 누름 = 닫음 · 화면 캐시 안 바뀜 */
   function pick(i: number): void {
-    picked = cur.담은로직[i].로직;
-    for (const tr of logicHost.querySelectorAll<HTMLElement>("[data-labor-logic],[data-labor-opt]"))
-      tr.classList.toggle("is-selected", (tr.dataset.laborLogic ?? tr.dataset.laborOpt) === picked);
+    const key = lineId(cur.담은로직[i]) ?? "";
+    picked = picked === key ? null : key;
+    drawLogic();
     showSource();
   }
   function removeRow(i: number): void {
-    if (cur.담은로직[i].로직 === picked) picked = null;
+    if (lineId(cur.담은로직[i]) === picked) picked = null;
     cur.담은로직.splice(i, 1);
     changed();
   }
@@ -334,12 +358,25 @@ export function mountLaborDetail(
     });
   }
 
+  /** 참조 줄 [옵션] · [수정](51-14) — 서고 원본 모달 · 자기 층 서고만 고침(위 층 = 읽기만 · 서버도 막음) ·
+   * 닫으면 다시 셈(원본이 바뀌었을 수 있음) */
+  function openRef(i: number): void {
+    const ref = cur.담은로직[i].참조;
+    if (!ref) return;
+    void openRefEdit({
+      ref,
+      title: `${ref.키} ${lineOf(lineId({ 참조: ref }) ?? "")?.이름 ?? ""}`.trim(),
+      readOnly: !edit || ref.층 !== opt.layer,
+      closed: () => alive && recalc(),
+    });
+  }
+
   /** 수량산출 칸 누름 — 로직 줄 */
   function openQty(i: number): void {
     const row = cur.담은로직[i];
-    const line = lineOf(row.로직);
+    const line = lineOf(lineId(row) ?? "");
     openQtyFor(
-      `${row.로직} ${logics.get(row.로직)?.이름 ?? ""}`.trim(),
+      `${row.참조?.키 ?? row.로직} ${(row.참조 ? line?.이름 : logics.get(row.로직)?.이름) ?? ""}`.trim(),
       row,
       line,
       line?.분모 ?? "",
@@ -352,16 +389,35 @@ export function mountLaborDetail(
     openQtyFor(`${mat.코드} ${mat.이름 ?? ""}`.trim(), mat, matOf(mat.코드), mat.단위 ?? "");
   }
 
+  /** 서고 탭(50-3 ④) — 참조 줄 더함(같은 참조 두 번 막음 · 위 층만은 서버도 막음) */
+  const library = {
+    layer: opt.layer,
+    owner: opt.layer === getActiveLayer() ? getActiveOwner() : null,
+    pick: (ref: LaborRef, name: string) => {
+      const id = lineId({ 참조: ref });
+      if (cur.담은로직.some((r) => lineId(r) === id))
+        return showToast(tc("Labor_AlreadyRef").replace("{value}", `${ref.키} ${name}`), "error");
+      const 수량 = lib === "precombo" ? { 손: 1 } : null; // 사전조합 줄 기본 1(51-6)
+      cur.담은로직.push({ 로직: "", 참조: ref, 별칭: null, 메모: null, 입력값: {}, 수량 });
+      changed();
+    },
+  };
   const addLogic = createButton({
     label: tc("AddLogic"),
     variant: "filled",
     onClick: () =>
-      openLogicPicker((x) => {
-        if (cur.담은로직.some((r) => r.로직 === x.키))
-          return showToast(tc("Labor_Already").replace("{value}", `${x.키} ${x.이름}`), "error");
-        cur.담은로직.push({ 로직: x.키, 별칭: null, 메모: null, 입력값: {}, 수량: null });
-        void loadLogics().then(() => changed());
-      }),
+      openLogicPicker(
+        (x) => {
+          if (cur.담은로직.some((r) => r.로직 === x.키))
+            return showToast(tc("Labor_Already").replace("{value}", `${x.키} ${x.이름}`), "error");
+          // 사전조합 = 면적산출 없음 → 손 1(51-11)
+          const 수량 = lib === "precombo" ? { 손: 1 } : null;
+          cur.담은로직.push({ 로직: x.키, 별칭: null, 메모: null, 입력값: {}, 수량 });
+          void loadLogics().then(() => changed());
+        },
+        // 사전조합도 같은 창 · 같은 목록(51-11 · 자기 자신 · 순환은 [저장] 때 서버 422)
+        library,
+      ),
   });
   const addMat = createButton({
     label: tc("Labor_AddMat"),
@@ -415,6 +471,77 @@ export function mountLaborDetail(
       ],
     });
 
+  // 서고 모드 이름 칸(문서 `이름` · 목록에 보이는 이름)
+  const nameField = createInputField({ type: "text", label: tc("Lib_Name") });
+  nameField.root.dataset.laborField = "이름";
+  nameField.input.value = String((cur as { 이름?: unknown }).이름 ?? "");
+  nameField.input.readOnly = !edit;
+  nameField.input.addEventListener("input", () => {
+    (cur as { 이름?: string }).이름 = nameField.input.value.trim();
+    opt.onChanged(dirty());
+  });
+
+  /** 서고 구분 · 상세구분(51-12) — 승격 = 원 로직 것 읽기만 + 연결(원 로직 키 · 출처) ·
+   * 사전조합 = 로직 구분 목록(logic-lib/subs)에서 고름(구분 바꾸면 상세구분 = 그 첫 줄) */
+  const meta = cur as { 구분?: string | null; 상세구분?: string | null; 연결?: unknown };
+  const readField = (label: string, field: string, value: string): HTMLElement => {
+    const f = createInputField({ type: "text", label });
+    f.root.dataset.laborField = field;
+    f.input.value = value;
+    f.input.readOnly = true;
+    return f.root;
+  };
+  const libMeta = (): HTMLElement[] => {
+    if (promote) {
+      const link = (meta.연결 ?? {}) as { 로직?: string; 출처?: string };
+      return [
+        readField(tc("Sub"), "구분", meta.구분 ?? ""),
+        readField(tc("Detail"), "상세구분", meta.상세구분 ?? ""),
+        readField(tc("Lib_Link"), "연결", [link.로직, link.출처].filter(Boolean).join(" · ")),
+      ];
+    }
+    const sub = createSelectField({ options: [], label: tc("Sub"), disabled: !edit });
+    const detail = createSelectField({ options: [], label: tc("Detail"), disabled: !edit });
+    sub.root.dataset.laborField = "구분";
+    detail.root.dataset.laborField = "상세구분";
+    let subs: SubBrief[] = [];
+    // 목록에 없는 지금 값(빈 것 = 「—」 · 옛 문서)도 선택지로 둠
+    const opts = (names: string[], now: string | null | undefined) =>
+      [...new Set([now ?? "", ...names])]
+        .filter((v, i) => v || i === 0)
+        .map((v) => ({ value: v, text: v || "—" }));
+    const fill = (): void => {
+      sub.setOptions(
+        opts(
+          subs.map((s) => s.name),
+          meta.구분,
+        ),
+        meta.구분 ?? "",
+      );
+      const details = subs.find((s) => s.name === meta.구분)?.details ?? [];
+      detail.setOptions(opts(details, meta.상세구분), meta.상세구분 ?? "");
+    };
+    sub.select.addEventListener("change", () => {
+      meta.구분 = sub.select.value;
+      meta.상세구분 = subs.find((s) => s.name === meta.구분)?.details[0] ?? null;
+      fill();
+      opt.onChanged(dirty());
+    });
+    detail.select.addEventListener("change", () => {
+      meta.상세구분 = detail.select.value;
+      opt.onChanged(dirty());
+    });
+    fill();
+    void fetchLibLogicSubs().then(
+      (got) => {
+        subs = got;
+        fill();
+      },
+      () => undefined,
+    );
+    return [sub.root, detail.root];
+  };
+
   const editor = (body: HTMLElement): HTMLElement =>
     side ? el("div", { className: "ui-side-panels-row", children: [body, side.root] }) : body;
   host.replaceChildren(
@@ -429,13 +556,21 @@ export function mountLaborDetail(
                 el("section", {
                   className: "m01lab__box m01-logic__section",
                   children: [
-                    el("div", { className: "m01lab__info", children: [unit.root, origin.root] }),
+                    el("div", {
+                      className: "m01lab__info",
+                      children: [
+                        ...(lib ? [nameField.root, ...libMeta()] : []),
+                        unit.root,
+                        origin.root,
+                      ],
+                    }),
                   ],
                 }),
               ]),
-          section(tc("Logics_Title"), opt.card ? null : addLogic, logicHost),
-          section(tc("Labor_Mats"), addMat, matHost),
-          ...(opt.card ? [] : [dgBox]),
+          // 승격 = 로직 한 줄(새로 만들 때 고름) · 사전조합 = 같은 [로직 추가](51-11)
+          section(tc("Logics_Title"), opt.card || promote ? null : addLogic, logicHost),
+          ...(lib ? [] : [section(tc("Labor_Mats"), opt.card ? null : addMat, matHost)]),
+          ...(opt.card || lib ? [] : [dgBox]),
         ],
       }),
     ),
@@ -444,19 +579,28 @@ export function mountLaborDetail(
   // 로직 입력 목록 · 면적산출 이은 칸(없으면 빈 것 — 새 구조물)을 받은 뒤 첫 계산
   void Promise.all([
     loadLogics(),
-    readTemplate(opt.layer, "area", opt.column, null).then(
-      (got) => {
-        area = { doc: got.문서 as Workbook, 판: got.판 ?? "" };
-        links = areaLinks(got.문서);
-      },
-      () => undefined,
-    ),
+    lib // 서고 모드엔 면적산출 없음
+      ? undefined
+      : readTemplate(opt.layer, "area", opt.column, null).then(
+          (got) => {
+            area = { doc: got.문서 as Workbook, 판: got.판 ?? "" };
+            links = areaLinks(got.문서);
+          },
+          () => undefined,
+        ),
   ]).then(() => {
     if (alive) recalc();
   });
 
   return {
-    getDoc: () => cur,
+    // 서고 모드 = 문서 종류 그대로 · 열 · 자재 없음
+    getDoc: () => {
+      if (!lib) return cur;
+      const out: Record<string, unknown> = { ...cur, 종류: promote ? "단가승격" : "사전조합" };
+      delete out.열;
+      delete out.자재;
+      return out as unknown as LaborDoc;
+    },
     saveArea: async () => {
       if (!area || !areaDirty) return false;
       const info = await saveTemplate(opt.layer, "area", opt.column, null, area.판, area.doc);
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Input.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Input.ts
index 019b3541a..f60fe5c0d 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Input.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Input.ts
@@ -19,14 +19,19 @@ const fill = (text: string, value: string): string => text.replace("{value}", va
 /** 면적산출 상세로 감 — 옮겨 갔으면 참(물음에서 취소 = 거짓) */
 export type GoArea = () => Promise<boolean>;
 
-function footer(readOnly: boolean, ok: () => void, close: () => void): HTMLElement {
+function footer(
+  readOnly: boolean,
+  ok: () => void,
+  close: () => void,
+  okLabel = tc("In_Ok"),
+): HTMLElement {
   return el("div", {
     className: "m02-labin__foot",
     children: readOnly
       ? [createButton({ label: tc("In_Close"), variant: "ghost", onClick: close })]
       : [
           createButton({ label: tc("In_Cancel"), variant: "ghost", onClick: close }),
-          createButton({ label: tc("In_Ok"), variant: "filled", onClick: ok }),
+          createButton({ label: okLabel, variant: "filled", onClick: ok }),
         ],
   });
 }
@@ -45,6 +50,10 @@ export interface LaborInputOptions {
   memo: string | null;
   readOnly: boolean;
   done: (next: LaborInputResult) => void;
+  /** 머리 한 줄 알림(51-14 · 서고 원본 고침) */
+  notice?: string;
+  /** 확인 단추 글(기본 「확인」) */
+  okLabel?: string;
 }
 
 /** 담은 로직 줄 입력 모달 */
@@ -100,6 +109,15 @@ export function openLaborInput(opt: LaborInputOptions): void {
         el("div", {
           className: "m02-inputval",
           children: [
+            ...(opt.notice
+              ? [
+                  el("p", {
+                    className: "m02-labin__muted",
+                    text: opt.notice,
+                    attrs: { "data-labor-notice": "" },
+                  }),
+                ]
+              : []),
             ...(lost.length
               ? [
                   el("p", {
@@ -120,7 +138,7 @@ export function openLaborInput(opt: LaborInputOptions): void {
             }),
           ],
         }),
-        footer(opt.readOnly, ok, close),
+        footer(opt.readOnly, ok, close, opt.okLabel),
       );
     },
   });
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts
index ee9acecd0..ebf61477e 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts
@@ -1,21 +1,24 @@
 /* =============================================================================
  * M02_MasterTemplete_Labor_Pick.ts
- * [로직 더하기] 창 — 구분 → 상세구분 → 찾기로 사용자가 로직을 하나씩 고름(자동 추천 없음)
+ * [로직 더하기] 창 — 한 목록에 구분(단가산출 · 단가승격 · 일위조합) 칸 · 치는 대로 걸러짐(찾기 단추 없음) ·
+ * 단가승격 · 일위조합 줄은 층 단추(위 층만 · 짝 `M02_Labor_Ref.readable`) 층의 서고 · 고르면 참조 {층 · 주인 · 키} ·
+ * 프로젝트 · 카드엔 서고 줄 없음
  * ========================================================================== */
 
-import {
-  createButton,
-  createInputField,
-  createSelectField,
-  el,
-  showToast,
-} from "@ui/ui_template_elements";
+import { createButton, createSelectField, el, showToast } from "@ui/ui_template_elements";
+import { createFindList } from "@ui/ui_template_find_list";
 import { t as L } from "@ui/ui_template_locale";
 import type { LogicSummary, SubBrief } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
+import { fetchSessionUser } from "../A06_Login/A06_Login_Api_Fetch";
+import type { Layer } from "./M02_MasterTemplete_Api_Fetch";
 import {
   fetchLibLogics as fetchLogics,
   fetchLibLogicSubs as fetchLogicSubs,
+  fetchLibrary,
+  type LibraryRow,
 } from "./M02_MasterTemplete_Labor_Api";
+import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
+import { ownOwner } from "./M02_MasterTemplete_Layer";
 import { tc } from "./M02_MasterTemplete_Labor_Text";
 import "../M01_MasterData/M01_MasterData_UI_Logic_Style.css"; // 창 겉틀
 import "./M02_MasterTemplete_Labor.css";
@@ -23,58 +26,181 @@ import "./M02_MasterTemplete_Labor.css";
 const opts = (values: string[]): { value: string; text: string }[] =>
   [L("M01_All"), ...values].map((v, i) => ({ value: i ? v : "", text: v }));
 
-export function openLogicPicker(done: (logic: LogicSummary) => void): void {
+type Scope = Omit<LaborRef, "키">;
+/** 서고 탭 — 일위대가가 있는 층 · 주인(null = 자기 층) · 고르면 참조 */
+export interface LibraryPick {
+  layer: Layer;
+  owner: string | null;
+  pick: (ref: LaborRef, name: string) => void;
+}
+
+/** 고를 수 있는 층 — 위 층만(마스터 → 마스터 · 회사 → 그 회사 · 마스터 · 개인 → 그 개인 · 그 회사 · 마스터) */
+async function upper(layer: Layer, owner: string | null): Promise<Scope[]> {
+  if (layer === "project") return [];
+  const own =
+    layer === "system"
+      ? null
+      : (owner ?? ownOwner(layer, await fetchSessionUser().catch(() => null)));
+  const out: Scope[] = [{ 층: "system", 주인: null }];
+  if (own) out.push({ 층: "company", 주인: own.split("/")[0] });
+  if (own && layer === "personal") out.push({ 층: "personal", 주인: own });
+  return out;
+}
+const LAYER_TEXT = {
+  system: "Lib_System",
+  company: "Lib_Company",
+  personal: "Lib_Personal",
+} as const;
+
+export function openLogicPicker(done: (logic: LogicSummary) => void, lib?: LibraryPick): void {
   const subs: SubBrief[] = [];
   let all: LogicSummary[] = [];
   const sub = createSelectField({ options: opts([]), compact: true, label: tc("Sub") });
   const detail = createSelectField({ options: opts([]), compact: true, label: tc("Detail") });
   detail.select.disabled = true;
-  const searchField = createInputField({ type: "search", placeholder: tc("Pick_Search") });
-  const list = el("div", { className: "m01-logic__pick-list" });
-  const hint = el("p", { className: "m01-logic__muted", text: tc("Pick_Hint") });
   const close = (): void => backdrop.remove();
 
+  /* 한 목록 — 구분(단가산출 · 단가승격 · 일위조합) 칸 · 층 단추는 서고 줄(승격 · 조합)의 층 */
+  const layerBar = el("div", { className: "ui-btn-group", attrs: { "data-pick-layers": "" } });
+  let scopes: Scope[] = [];
+  let scope: Scope | null = null;
+  let libRows: { kind: "Kind_Promote" | "Kind_Combo"; row: LibraryRow }[] = [];
+  let loading = false;
+  let seq = 0;
+  /* 공용 찾기 목록 — 구분 · 상세구분 2열 · 이름 왼쪽 맞춤 · ↑ ↓ Enter */
+  const finder = createFindList({
+    placeholder: tc("Pick_Search"),
+    filters: [sub.root, detail.root],
+    extra: [layerBar],
+  });
+
   const find = (): void => {
-    const q = searchField.input.value.trim().toLowerCase();
+    const q = finder.search.value.trim().toLowerCase();
     const found = all.filter(
       (x) =>
         (!sub.select.value || x.구분 === sub.select.value) &&
         (!detail.select.value || x.상세구분 === detail.select.value) &&
         (!q || `${x.키} ${x.이름}`.toLowerCase().includes(q)),
     );
-    hint.textContent = found.length ? `${found.length} / ${all.length}` : tc("Pick_None");
-    list.replaceChildren(
-      ...found.slice(0, 100).map((x) => {
-        const row = el("button", {
-          className: "m01-logic__pick-row m01-logic__pick-row--button",
-          attrs: { type: "button", "data-pick": x.키 },
-          children: [
-            el("div", {
-              className: "m01-logic__stack",
-              children: [
-                el("strong", { text: x.이름 }),
-                el("span", {
-                  className: "m01-logic__muted",
-                  text: `${x.키} · ${x.구분} ${x.상세구분}`.trim(),
-                }),
-              ],
-            }),
-            el("span", { text: `${x.결과단위}${x.blocked ? ` · ${tc("Pick_Blocked")}` : ""}` }),
-          ],
-        });
-        row.addEventListener("click", () => {
+    const libFound = libRows.filter(
+      (x) =>
+        (!sub.select.value || x.row.구분 === sub.select.value) &&
+        (!detail.select.value || x.row.상세구분 === detail.select.value) &&
+        (!q || `${x.row.이름} ${x.row.제목 ?? ""}`.toLowerCase().includes(q)),
+    );
+    const total = all.length + libRows.length;
+    const shown = found.length + libFound.length;
+    finder.hint.textContent = loading
+      ? tc("Loading")
+      : shown
+        ? `${shown} / ${total}`
+        : tc("Pick_None");
+    finder.setRows([
+      ...found.slice(0, 100).map((x) => ({
+        key: x.키,
+        tag: tc("Kind_Logic"),
+        name: x.이름,
+        sub: `${x.키} · ${x.구분} ${x.상세구분}`.trim(),
+        unit: `${x.결과단위}${x.blocked ? ` · ${tc("Pick_Blocked")}` : ""}`,
+        onPick: () => {
           close();
           done(x);
-        });
-        return row;
+        },
+      })),
+      ...libFound.map((x) => {
+        const at = scope as Scope;
+        return {
+          key: x.row.이름,
+          tag: tc(x.kind),
+          name: x.row.제목 || x.row.이름,
+          sub: [x.row.이름, `${x.row.구분 ?? ""} ${x.row.상세구분 ?? ""}`.trim()]
+            .filter(Boolean)
+            .join(" · "),
+          unit: x.row.단위 ?? "",
+          onPick: () => {
+            close();
+            lib?.pick({ ...at, 키: x.row.이름 }, x.row.제목 || x.row.이름);
+          },
+        };
       }),
+    ]);
+  };
+  const loadLib = async (): Promise<void> => {
+    if (!lib || !scope) return;
+    const mine = ++seq;
+    const at = scope;
+    loading = true;
+    find();
+    try {
+      const [promote, combo] = await Promise.all([
+        fetchLibrary(at, "promote"),
+        fetchLibrary(at, "precombo"),
+      ]);
+      if (mine !== seq) return;
+      libRows = [
+        ...promote.map((row) => ({ kind: "Kind_Promote" as const, row })),
+        ...combo.map((row) => ({ kind: "Kind_Combo" as const, row })),
+      ];
+    } catch (error) {
+      if (mine !== seq) return;
+      libRows = [];
+      showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error");
+    }
+    loading = false;
+    drawSubs();
+    find();
+  };
+  const drawLayers = (): void =>
+    layerBar.replaceChildren(
+      ...scopes.map((x) =>
+        createButton({
+          label: tc(LAYER_TEXT[x.층 as keyof typeof LAYER_TEXT]),
+          variant: x === scope ? "filled" : "ghost",
+          onClick: () => {
+            scope = x;
+            drawLayers();
+            void loadLib();
+          },
+        }),
+      ),
     );
+  /** 구분 → 상세구분 — 로직 구분에 서고 줄(승격 · 조합) 것을 더함 · 같은 값은 한 칸 */
+  const subMap = (): Map<string, Set<string>> => {
+    const m = new Map(subs.map((s) => [s.name, new Set(s.details)]));
+    for (const { row } of libRows) {
+      if (!row.구분) continue;
+      if (!m.has(row.구분)) m.set(row.구분, new Set());
+      if (row.상세구분) m.get(row.구분)!.add(row.상세구분);
+    }
+    return m;
+  };
+  const drawDetails = (keep: string): void => {
+    const d = [...(subMap().get(sub.select.value) ?? [])];
+    detail.setOptions(opts(d), d.includes(keep) ? keep : "");
+    detail.select.disabled = d.length === 0;
+  };
+  const drawSubs = (): void => {
+    const keep = detail.select.value;
+    sub.setOptions(opts([...subMap().keys()]), sub.select.value);
+    drawDetails(keep);
   };
   sub.select.addEventListener("change", () => {
-    const d = subs.find((s) => s.name === sub.select.value)?.details ?? [];
-    detail.setOptions(opts(d), "");
-    detail.select.disabled = d.length === 0;
+    drawDetails("");
+    find();
   });
+  detail.select.addEventListener("change", find);
+  finder.search.addEventListener("input", find);
+
+  layerBar.style.display = "none";
+  if (lib)
+    void upper(lib.layer, lib.owner).then((got) => {
+      scopes = got;
+      scope = got[got.length - 1] ?? null; // 기본 = 가장 가까운 층
+      if (!got.length) return;
+      layerBar.style.display = "";
+      drawLayers();
+      void loadLib();
+    });
 
   const dialog = el("div", {
     className: "m01-logic__pick m01-combo",
@@ -87,31 +213,21 @@ export function openLogicPicker(done: (logic: LogicSummary) => void): void {
           createButton({ label: tc("Pick_Close"), variant: "ghost", onClick: close }),
         ],
       }),
-      el("div", {
-        className: "m01-logic__filters",
-        children: [
-          sub.root,
-          detail.root,
-          searchField.root,
-          createButton({ label: tc("Pick_Find"), variant: "filled", onClick: find }),
-        ],
-      }),
-      hint,
-      list,
+      finder.root,
     ],
   });
   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);
-  searchField.input.addEventListener("keydown", (ev) => ev.key === "Enter" && find());
-  searchField.input.focus();
+  finder.search.focus();
 
   void Promise.all([fetchLogicSubs(), fetchLogics()])
     .then(([s, l]) => {
       subs.push(...s);
       all = l;
-      sub.setOptions(opts(s.map((x) => x.name)), "");
+      drawSubs();
+      find();
     })
     .catch((error) =>
       showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error"),
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_QtyModal.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_QtyModal.ts
index 3e466130f..8bd58dc80 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_QtyModal.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_QtyModal.ts
@@ -42,6 +42,8 @@ export interface QtyModalOptions {
   sheet: { doc: Workbook | null; layer: Layer; column: string; pill: string | null };
   /** [면적산출 상세로] — 없으면 단추 없음 */
   goArea: GoArea | null;
+  /** 손 입력만(서고 사전조합 줄 · 51-6) — 면적산출 시트 없음 */
+  handOnly?: boolean;
   done: (result: QtyResult) => void;
 }
 
@@ -104,7 +106,9 @@ export function openQtyModal(opt: QtyModalOptions): void {
         className: "m02-cellpick__sheet",
         attrs: { "data-labor-qty-sheet": "" },
       });
-      if (opt.sheet.pill) {
+      if (opt.handOnly) {
+        // 시트 없음
+      } else if (opt.sheet.pill) {
         sheet = mountAreaSheet(host, {
           doc: opt.sheet.doc,
           layer: opt.sheet.layer,
@@ -153,8 +157,9 @@ export function openQtyModal(opt: QtyModalOptions): void {
           ],
         }),
         state,
-        el("p", { className: "m02-cellpick__hint", text: tc("Labor_SheetHint") }),
-        host,
+        ...(opt.handOnly
+          ? []
+          : [el("p", { className: "m02-cellpick__hint", text: tc("Labor_SheetHint") }), host]),
         el("div", {
           className: "m02-labin__foot",
           children: opt.readOnly
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_RefEdit.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_RefEdit.ts
new file mode 100644
index 000000000..4ecb9e78f
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_RefEdit.ts
@@ -0,0 +1,134 @@
+/* =============================================================================
+ * M02_MasterTemplete_Labor_RefEdit.ts
+ * 일위대가 참조 줄 모달(51-14) — 서고 원본(50-3)을 그 자리에서 고침 · [저장] = 서고 저장 길(`saveTemplate`) ·
+ * 그 문서를 쓰는 모든 구조물에 따라감(머리 한 줄 알림) · 그 층을 못 고치면 읽기만.
+ *  · 단가승격 [옵션] = 승격 문서 로직 한 줄의 넣을 값 모달(`Labor_Input`)
+ *  · 일위조합 [수정] = 사전조합 상세(서고 모드 표 · 안 줄 [옵션] · 수량 · 위로 · 아래로 · 삭제 · 추가)
+ * 닫으면(저장 · 취소 모두) `closed` — 부르는 쪽이 구조물 일위대가 표를 다시 셈.
+ * ========================================================================== */
+
+import { createButton, el, showConfirmDialog, showToast } from "@ui/ui_template_elements";
+import { openModal } from "@ui/ui_template_modal";
+import { readTemplate, saveTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch";
+import { fetchLogicInputs, type LaborRow } from "./M02_MasterTemplete_Labor_Api";
+import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
+import { openLaborInput } from "./M02_MasterTemplete_Labor_Input";
+import { tc } from "./M02_MasterTemplete_Labor_Text";
+import { keepKnown } from "./M02_Labor_Values_Model";
+
+export interface RefEditOptions {
+  ref: LaborRef;
+  /** 「SP-000001 메쌓기」 */
+  title: string;
+  readOnly: boolean;
+  closed: () => void;
+}
+
+const fail = (error: unknown, key: "Load_Failed" | "Lib_SaveFailed"): void =>
+  showToast(error instanceof Error ? error.message : tc(key), "error");
+
+export async function openRefEdit(opt: RefEditOptions): Promise<void> {
+  const kind = opt.ref.키.startsWith("SP-") ? "promote" : "precombo";
+  const layer = opt.ref.층 as Layer;
+  let doc: { 담은로직?: LaborRow[] };
+  let 판: string;
+  try {
+    const got = await readTemplate(layer, kind, opt.ref.키, null);
+    doc = got.문서 as typeof doc;
+    판 = got.판 ?? "";
+  } catch (error) {
+    return fail(error, "Load_Failed");
+  }
+  const save = (body: unknown): Promise<unknown> =>
+    saveTemplate(layer, kind, opt.ref.키, null, 판, body).then(() =>
+      showToast(tc("Saved"), "success"),
+    );
+  const notice = opt.readOnly ? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}` : tc("Ref_Shared");
+
+  if (kind === "promote") {
+    const row = doc.담은로직?.[0];
+    if (!row) return fail(null, "Load_Failed");
+    const logic = row.로직
+      ? ((await fetchLogicInputs([row.로직]).catch(() => null))?.로직[0] ?? null)
+      : null;
+    return openLaborInput({
+      title: opt.title,
+      logic,
+      values: row.입력값,
+      memo: row.메모,
+      readOnly: opt.readOnly,
+      notice,
+      okLabel: tc("Save"),
+      done: (next) => {
+        row.입력값 = logic ? keepKnown(logic.입력, next.입력값).kept : next.입력값;
+        row.메모 = next.메모;
+        void save(doc)
+          .catch((error) => fail(error, "Lib_SaveFailed"))
+          .finally(opt.closed);
+      },
+    });
+  }
+
+  // 사전조합 — 상세와 같은 부품(서로 부르므로 늦게 받음)
+  const { mountLaborDetail } = await import("./M02_MasterTemplete_Labor_Detail");
+  let dirty = false;
+  let handle: ReturnType<typeof mountLaborDetail> | null = null;
+  const finish = (): void => {
+    handle?.destroy();
+    opt.closed();
+  };
+  openModal({
+    title: opt.title,
+    closeLabel: tc("In_Close"),
+    dialogClass: "m02-modal m02-labref",
+    beforeClose: async () => {
+      if (dirty && !(await showConfirmDialog(tc("Ref_Discard")))) return false;
+      finish();
+      return true;
+    },
+    mount: (body, close) => {
+      const host = el("div", { attrs: { "data-labor-ref": opt.ref.키 } });
+      handle = mountLaborDetail(host, doc, {
+        layer,
+        column: opt.ref.키,
+        readOnly: opt.readOnly,
+        onChanged: (d) => (dirty = d && !opt.readOnly),
+        goArea: null,
+        mode: "precombo",
+      });
+      const cancel = createButton({
+        label: tc(opt.readOnly ? "In_Close" : "In_Cancel"),
+        variant: "ghost",
+        onClick: async () => {
+          if (dirty && !(await showConfirmDialog(tc("Ref_Discard")))) return;
+          close();
+          finish();
+        },
+      });
+      const ok = createButton({
+        label: tc("Save"),
+        variant: "filled",
+        onClick: () =>
+          void save(handle?.getDoc()).then(
+            () => {
+              close();
+              finish();
+            },
+            (error) => fail(error, "Lib_SaveFailed"),
+          ),
+      });
+      body.append(
+        el("p", {
+          className: "m02-labin__muted",
+          text: notice,
+          attrs: { "data-labor-notice": "" },
+        }),
+        host,
+        el("div", {
+          className: "m02-labin__foot",
+          children: opt.readOnly ? [cancel] : [cancel, ok],
+        }),
+      );
+    },
+  });
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts
index b6993e8eb..bcdd9122b 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts
@@ -1,13 +1,14 @@
 /* =============================================================================
  * M02_MasterTemplete_Labor_Rows.ts
  * 일위대가 담은 로직 표 · 자재목록 표(39-3) — 상세 · 보기 갈래(면적산출 오른쪽 패널 · 카드)가 같이 씀.
- * 담은 로직 = 차례 · 로직(키 · 이름 + 「빈 값 n」 붉게) · 별칭(44-6) · 수량산출(「12.5(B6)」) ·
+ * 담은 로직 = 차례 · 구분(키 머리에서 읽음 · 50-4) · 로직(키 · 이름 + 「빈 값 n」 붉게) · 별칭(44-6) · 수량산출(「12.5(B6)」) ·
  * 결과 단위 · 금액 칸 넷(노무비 · 재료비 · 경비 · 합계 · 칸마다 위 기준 작게 / 아래 반영) ·
  * 옵션 값(「지역 서울 · 규격 25mm」)은 줄 아래 이름 ~ 합계에 걸친 한 줄 · 맨 아래 합계 줄(전체 합계 강조).
  * 자재목록 = 코드 · 이름 · 규격 · 수량산출 · 단위 · 가격 다섯(기준 칸 강조) · 기준단가 / 반영 금액(43-3).
  * 금액은 calc 답(없으면 「…」).
- * 줄 누름 · 줄 단추(위로 · 아래로 · 옵션 · 삭제 · 묶음 `ui-btn-group`)는 `on` 이 있을 때만(보기 갈래 = 없음) ·
- * 상세는 줄 누름 = 고름(`selected` 줄 하이라이트) · 넣을 값 모달은 [옵션](47-5).
+ * 줄 누름 · 줄 단추는 `on` 이 있을 때만(보기 갈래 = 없음) — 순서 칸 2행(51-14 · 위 [위로] [아래로] / 아래 [옵션] 또는 [수정] · [삭제] ·
+ * 묶음 `ui-btn-group` · 순서 없는 카드 갈래 = 아래 줄만) · 단가승격 줄 = [옵션] · 일위조합 줄 = [수정](`ref` · 서고 원본) ·
+ * 상세는 줄 누름 = 고름(`selected` 줄 하이라이트 · 그 줄 바로 아래 하위 행 · 51-2 · 화살표 없음 51-7) · 넣을 값 모달은 [옵션](47-5).
  * ========================================================================== */
 
 import { createButton, el } from "@ui/ui_template_elements";
@@ -21,6 +22,7 @@ import type {
   LaborMat,
   LaborRow,
 } from "./M02_MasterTemplete_Labor_Api";
+import { lineId } from "./M02_MasterTemplete_Labor_Calc";
 import { tc } from "./M02_MasterTemplete_Labor_Text";
 import "@ui/ui_template_general_layout.css";
 import "./M02_MasterTemplete_Labor.css";
@@ -34,8 +36,16 @@ const HEAD: Record<(typeof COSTS)[number], Parameters<typeof tc>[0]> = {
   계: "Prev_Sum",
 };
 
-/** 옵션 값 줄이 걸치는 칸 수 — 이름 · 별칭 · 수량산출 · 결과 단위 · 금액 넷 */
-const SPAN = 4 + COSTS.length;
+/** 옵션 값 줄이 걸치는 칸 수 — 구분 · 이름 · 별칭 · 수량산출 · 결과 단위 · 금액 넷 */
+const SPAN = 5 + COSTS.length;
+
+/** 구분(50-4 · 저장 안 함) — 줄 모양(참조 키 머리)에서 읽음 · SP- = 단가승격 · SC- = 일위조합(50-3) */
+export const kindOf = (row: Pick<LaborRow, "로직" | "참조">): string => {
+  const key = row.참조?.키 ?? row.로직;
+  return tc(
+    key.startsWith("SP-") ? "Kind_Promote" : key.startsWith("SC-") ? "Kind_Combo" : "Kind_Logic",
+  );
+};
 
 const num = (v: number): string =>
   Number(v.toPrecision(12)).toLocaleString("ko-KR", { maximumFractionDigits: 6 });
@@ -165,6 +175,8 @@ export interface RowHandlers {
   open: (i: number) => void;
   /** [옵션] 단추(47-5 · 넣을 값 모달) — 없으면 단추 없음 */
   option?: (i: number) => void;
+  /** 참조 줄 단추(51-14) — 단가승격 [옵션] · 일위조합 [수정] = 서고 원본 모달 · 없으면 단추 없음 */
+  ref?: (i: number) => void;
   /** 수량산출 칸 누름(손 입력 · 엑셀에서 고르기) — 없으면 줄 누름과 같음 */
   qty?: (i: number) => void;
   move?: (i: number, d: number) => void;
@@ -219,18 +231,81 @@ export interface LogicTableData {
   selected?: string | null;
 }
 
+/** 고른 줄 하위 행(51-2 · 같은 표 · 같은 칸) — 단가산출 · 단가승격 = 그 로직 재료 · 노무 · 경비 줄 ·
+ * 일위조합 = 세부 항목 한 층(51-13 · 참조 줄 · 로직 줄 · 안을 다시 펼치지 않음 · 금액 = 안 줄 기준 × 안 줄 수량) ·
+ * 금액 칸 = 위 기준(위 줄 기준과 같은 바탕) / 아래 반영(× 위 줄 수량 ÷ 배) ·
+ * 하위 합 = 위 줄 금액 · 줄이 없으면 빈 한 줄(「…」 · 까닭 · 「—」) */
+function subRows(line: LaborCalcLine | undefined, wait: boolean, tools: boolean): HTMLElement[] {
+  const times = line?.수량 === null || line?.수량 === undefined ? null : line.수량 / (line.배 || 1);
+  const items = line?.안
+    ? line.안.map((x) => {
+        const key = x.참조?.키 ?? x.로직 ?? "";
+        const label = x.이름 && x.이름 !== key ? `${key} ${x.이름}` : key; // 로직 줄 이름 없으면 키만
+        return {
+          name: `${label}${x.까닭 ? ` · ${x.까닭}` : ""}`,
+          qty: x.수량,
+          unit: x.단위 ?? "",
+          cost: x.기준 ? Object.fromEntries(COSTS.map((c) => [c, x.기준![c] * x.수량])) : null,
+        };
+      })
+    : (line?.줄 ?? []).map((x) => ({
+        name: x.출처 ? `${x.이름} (${x.출처.replace(/[A-Z]{2}\d{6}\./g, "")})` : x.이름,
+        qty: x.수량,
+        unit: x.단위,
+        cost: { ...x.비목, 계: x.금액 } as Record<string, number>,
+      }));
+  const blank = (className: string): HTMLElement => el("td", { className, text: "" });
+  const none = wait ? "…" : (line?.까닭 ?? "—");
+  return (items.length ? items : [null]).map((x) =>
+    el("tr", {
+      className: "m02-labrow__sub",
+      attrs: { "data-labor-sub": "" },
+      children: [
+        blank("m02-labrow__no"),
+        blank("m02-labrow__kind"),
+        el("td", {
+          className: "m02-labrow__name m02-labrow__subname",
+          text: x?.name ?? none,
+          attrs: { title: x?.name ?? none },
+        }),
+        blank("m02-labrow__alias"),
+        el("td", {
+          className: "m02-labrow__qty",
+          text: x ? num(x.qty) : "",
+          attrs: { "data-label": tc("Labor_QtyCol") },
+        }),
+        el("td", { className: "m02-labrow__unit", text: x?.unit ?? "" }),
+        ...COSTS.map((c) => {
+          const base = x?.cost ? Number(x.cost[c] ?? 0) : null;
+          return moneyCell(
+            base,
+            base === null || times === null ? null : base * times,
+            wait,
+            tc(HEAD[c]),
+          );
+        }),
+        ...(tools ? [blank("")] : []),
+      ],
+    }),
+  );
+}
+
 /** 담은 로직 표 — 보기 갈래는 `on` 없이 */
 export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement {
   const wait = !data.calc && !data.fail;
-  const { move, remove, option } = on ?? {};
+  const { move, remove, option, ref } = on ?? {};
   // 옵션 · 삭제만(구조물 조합 카드 · 43-4)이어도 끝 칸 — 순서 단추는 `move` 가 있을 때만
-  const tools = !!(move || remove || option);
+  const tools = !!(move || remove || option || ref);
+  const group = (children: HTMLElement[]): HTMLElement =>
+    el("div", { className: "ui-btn-group", children });
   const lineOf = (key: string): LaborCalcLine | undefined =>
-    data.calc?.줄.find((l) => l.로직 === key);
+    data.calc?.줄.find((l) => lineId(l) === key);
   const trs = data.rows.flatMap((row, i) => {
+    const id = lineId(row) ?? "";
     const logic = data.logics.get(row.로직);
-    const line = lineOf(row.로직);
-    const unit = logic?.결과단위 ?? "";
+    const line = lineOf(id);
+    // 참조 줄 — 키 · 이름 · 단위 = 가리킨 문서 것(calc 답) · 넣을 값 없음(승격 때 고정)
+    const unit = row.참조 ? (line?.분모 ?? "") : (logic?.결과단위 ?? "");
     const values = valueLine(logic?.입력 ?? [], row.입력값);
     const note = values.text;
     const why = line?.까닭 ?? (data.fail && i === 0 ? data.fail : null);
@@ -247,18 +322,21 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
           run();
         },
       });
-    const sel = data.selected === row.로직 ? " is-selected" : "";
+    const sel = data.selected === id ? " is-selected" : "";
     const tr = el("tr", {
       className: (on ? "m02-labrow__row is-open" : "m02-labrow__row") + sel,
-      attrs: { "data-labor-logic": row.로직 },
+      attrs: { "data-labor-logic": id },
       children: [
         el("td", { className: "m02-labrow__no", text: String(i + 1) }),
+        el("td", { className: "m02-labrow__kind", text: kindOf(row) }),
         titled(
           el("td", {
             className: "m02-labrow__name",
             children: [
-              el("span", { className: "m02-labrow__key", text: row.로직 }),
-              el("strong", { text: logic?.이름 ?? row.로직 }),
+              el("span", { className: "m02-labrow__key", text: row.참조?.키 ?? row.로직 }),
+              el("strong", {
+                text: (row.참조 ? line?.이름 : logic?.이름) ?? row.참조?.키 ?? row.로직,
+              }),
               ...(values.empty
                 ? [
                     el("small", {
@@ -289,13 +367,31 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
                 className: "m02-labrow__move",
                 children: [
                   el("div", {
-                    className: "ui-btn-group",
+                    className: "m02-labrow__tools",
                     children: [
                       ...(move
-                        ? [small(tc("Up"), () => move(i, -1)), small(tc("Down"), () => move(i, 1))]
+                        ? [
+                            group([
+                              small(tc("Up"), () => move(i, -1)),
+                              small(tc("Down"), () => move(i, 1)),
+                            ]),
+                          ]
                         : []),
-                      ...(option ? [small(tc("Labor_Option"), () => option(i))] : []),
-                      ...(remove ? [small(tc("Remove"), () => remove(i), "danger")] : []),
+                      group([
+                        ...(row.참조
+                          ? ref
+                            ? [
+                                small(
+                                  tc(row.참조.키.startsWith("SP-") ? "Labor_Option" : "Labor_Edit"),
+                                  () => ref(i),
+                                ),
+                              ]
+                            : []
+                          : option
+                            ? [small(tc("Labor_Option"), () => option(i))]
+                            : []),
+                        ...(remove ? [small(tc("Remove"), () => remove(i), "danger")] : []),
+                      ]),
                     ],
                   }),
                 ],
@@ -305,11 +401,12 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
       ],
     });
     if (on) tr.addEventListener("click", () => on.open(i));
-    if (!note) return [tr];
+    const subs = sel ? subRows(line, wait, tools) : [];
+    if (!note) return [tr, ...subs];
     // 옵션 값 줄(44-6) — 이름 ~ 합계 칸에 걸친 한 줄(말줄임 · 전체 글은 title) · 행 높이 안 커짐
     const opt = el("tr", {
       className: (on ? "m02-labrow__optrow is-open" : "m02-labrow__optrow") + sel,
-      attrs: { "data-labor-opt": row.로직 },
+      attrs: { "data-labor-opt": id },
       children: [
         el("td", { className: "m02-labrow__no", text: "" }),
         el("td", {
@@ -321,7 +418,7 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
       ],
     });
     if (on) opt.addEventListener("click", () => on.open(i));
-    return [tr, opt];
+    return [tr, opt, ...subs];
   });
   const sum = (part: Partial<LaborCost> | undefined, c: (typeof COSTS)[number]): number | null =>
     part?.[c] ?? null;
@@ -331,6 +428,7 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
           className: "m02-labrow__sum",
           children: [
             el("td", { className: "m02-labrow__no", text: "" }),
+            el("td", { className: "m02-labrow__kind", text: "" }),
             el("td", { className: "m02-labrow__name", text: tc("Prev_Sum") }),
             el("td", { className: "m02-labrow__alias", text: "" }),
             el("td", { className: "m02-labrow__qty", text: "" }),
@@ -352,6 +450,7 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement
     : [];
   const heads = [
     tc("Col_Order"),
+    tc("Sub"),
     tc("Col_Name"),
     tc("Col_Alias"),
     tc("Labor_QtyCol"),
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts
index db14ee6bc..64eebefb1 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts
@@ -35,6 +35,14 @@ const TEXT = {
   Down: ["아래로", "Down"],
   Remove: ["삭제", "Delete"],
   Labor_Option: ["옵션", "Options"],
+  Labor_Edit: ["수정", "Edit"],
+  Ref_Shared: [
+    "서고 원본을 고침 — 이 문서를 쓰는 모든 구조물에 따라감",
+    "Edits the library original — every structure using it follows",
+  ],
+  Ref_ReadOnly: ["이 층은 고칠 수 없음 — 읽기만", "Read-only layer"],
+  Lib_SaveFailed: ["저장 못 함", "Save failed"],
+  Ref_Discard: ["저장 안 한 고침을 버리고 닫음?", "Discard unsaved edits?"],
   Labor_Source: ["원문", "Source"],
   Labor_SourceHint: [
     "단가산출 로직 줄을 고르면 그 원문이 보임",
@@ -45,11 +53,6 @@ const TEXT = {
   Open: ["열기", "Open"],
   Pick_Title: ["로직 고르기", "Pick a logic"],
   Pick_Search: ["이름·키로 찾기", "Search by name or key"],
-  Pick_Find: ["찾기", "Find"],
-  Pick_Hint: [
-    "구분 → 상세구분을 고르고 [찾기]를 누름 — 하나씩 직접 고름",
-    "Choose category, detail, then Find — pick one by one",
-  ],
   Pick_None: ["찾은 로직 없음", "No logics found"],
   Pick_Close: ["닫기", "Close"],
   Pick_Blocked: ["막힘", "Blocked"],
@@ -84,6 +87,19 @@ const TEXT = {
   Labor_BasePrice: ["기준 단가", "Base price"],
   Labor_AppliedSum: ["반영 금액", "Applied amount"],
   Labor_Calc_Fail: ["계산 못 함", "Calculation failed"],
+  // 구분(50-4)
+  Kind_Logic: ["단가산출", "Logic"],
+  Kind_Promote: ["단가승격", "Promoted"],
+  Kind_Combo: ["일위조합", "Combination"],
+  Labor_LineDetail: ["상세 — {value}", "Detail — {value}"],
+  Labor_LineApplied: ["반영(수량 곱함)", "Applied (× quantity)"],
+  Labor_LineBase: ["기준", "Base"],
+  Labor_FromLogic: ["원 로직", "Source logic"],
+  Lib_Precombo: ["사전조합", "Pre-combination"],
+  Lib_System: ["마스터", "Master"],
+  Lib_Company: ["회사", "Company"],
+  Lib_Personal: ["개인", "Personal"],
+  Labor_AlreadyRef: ["이미 담은 일위대가 조합 — {value}", "Already added — {value}"],
   Labor_Empty: ["빈 값 {n}", "{n} empty"],
   Labor_Lost: [
     "로직 입력이 바뀌어 저장 때 빠지는 값 — {value}",
@@ -105,6 +121,19 @@ const TEXT = {
   In_Ok: ["확인", "OK"],
   In_Cancel: ["취소", "Cancel"],
   In_Close: ["닫기", "Close"],
+  Lib_Name: ["이름", "Name"],
+  // 서고 목록표(51-4)
+  Lib_Promote: ["단가산출 승격", "Promoted logic"],
+  Lib_PrecomboAll: ["일위대가 사전조합", "Pre-combination"],
+  Lib_Create: ["생성", "Create"],
+  Lib_Copy: ["복사", "Copy"],
+  Lib_Delete: ["삭제", "Delete"],
+  Lib_Key: ["키", "Key"],
+  Lib_Unit: ["단위", "Unit"],
+  Lib_Base: ["기준 금액", "Base amount"],
+  Lib_Date: ["고친 날", "Modified"],
+  // 서고 구분 · 연결(51-12)
+  Lib_Link: ["연결", "Linked logic"],
 } as const satisfies Record<string, readonly [string, string]>;
 
 export type ComboTextKey = keyof typeof TEXT;
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_View.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_View.ts
index 95a6aae82..d5ec07a01 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_View.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_View.ts
@@ -19,7 +19,7 @@ import {
   type LaborCalc,
   type LaborDoc,
 } from "./M02_MasterTemplete_Labor_Api";
-import { settle } from "./M02_MasterTemplete_Labor_Calc";
+import { lineId, settle } from "./M02_MasterTemplete_Labor_Calc";
 import { logicTable, matTable } from "./M02_MasterTemplete_Labor_Rows";
 import { tc } from "./M02_MasterTemplete_Labor_Text";
 import "./M02_MasterTemplete_Labor.css";
@@ -64,12 +64,13 @@ export function createLaborView(onRow?: (row: LaborViewRow) => void): LaborViewH
       onRow ? () => onRow(row) : undefined;
     const logicOpen = (i: number): void => {
       const row = d.담은로직[i];
-      const line = calc?.줄.find((l) => l.로직 === row.로직);
+      const id = lineId(row) ?? "";
+      const line = calc?.줄.find((l) => lineId(l) === id);
       pick({
         kind: "logic",
-        key: row.로직,
+        key: id,
         pill: line?.알약 ?? null,
-        name: logics.get(row.로직)?.이름 ?? row.로직,
+        name: (row.참조 ? line?.이름 : logics.get(row.로직)?.이름) ?? row.참조?.키 ?? row.로직,
         unit: line?.분모 ?? "",
       })?.();
     };
@@ -111,7 +112,7 @@ export function createLaborView(onRow?: (row: LaborViewRow) => void): LaborViewH
       const got = await readTemplate(layer, "labor", column, null);
       if (mine !== seq) return;
       doc = normalizeLabor(got.문서, column);
-      const want = doc.담은로직.map((r) => r.로직).filter((k) => !logics.has(k));
+      const want = doc.담은로직.map((r) => r.로직).filter((k) => k && !logics.has(k));
       const [inputs, area] = await Promise.all([
         fetchLogicInputs(want),
         readTemplate(layer, "area", column, null).then(
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Layer.ts b/M02_MasterTemplete/M02_MasterTemplete_Layer.ts
index 47fd72a35..43a7b6b86 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Layer.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Layer.ts
@@ -16,7 +16,7 @@ import { copyItemToPersonal, fetchStructureCombos } from "./M02_MasterTemplete_A
 export type ManageLayer = "system" | "company" | "personal";
 /** 해시 · 화면의 뿌리 이름 — 서버 층 이름은 `layerOfRoot` */
 export type Root = "master" | "company" | "personal";
-export type OpenTarget = "구조물조합" | "옵션" | "도면";
+export type OpenTarget = "구조물조합" | "옵션" | "도면" | "일위대가조합";
 
 export interface Entry {
   root: Root;
@@ -27,7 +27,7 @@ export interface Entry {
   company: string | null;
 }
 
-const OPENS: OpenTarget[] = ["구조물조합", "옵션", "도면"];
+const OPENS: OpenTarget[] = ["구조물조합", "옵션", "도면", "일위대가조합"];
 
 export const layerOfRoot = (root: Root): ManageLayer => (root === "master" ? "system" : root);
 
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Library_List.ts b/M02_MasterTemplete/M02_MasterTemplete_Library_List.ts
new file mode 100644
index 000000000..4e729405d
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_Library_List.ts
@@ -0,0 +1,282 @@
+/* =============================================================================
+ * M02_MasterTemplete_Library_List.ts
+ * 일위대가 조합 서고 목록표(51-4) — 좌측 항목(단가산출 승격 · 일위대가 사전조합)을 누르면 상세 칸에 뜸.
+ * 표 = 고름 · 키 · 구분 · 상세구분(51-12) · 이름 · 단위 · 기준 금액(서버 1 단위 계) · 고친 날 · 줄 누름 = 그 문서 상세.
+ * 머리 [생성] · [복사](고른 줄) · [삭제](고른 줄 · 쓰는 곳 있으면 서버 409 까닭 그대로).
+ * 꼴 = M01 단가산출 로직 목록 — 찾기 줄(`buildHeadFilters`) · 쪽(`buildPager`) · 표(`m01-master__grid`) 를 M01 에서 import.
+ * ========================================================================== */
+
+import {
+  createButton,
+  createInputField,
+  el,
+  showConfirmDialog,
+  showToast,
+} from "@ui/ui_template_elements";
+import { t as L } from "@ui/ui_template_locale";
+import { openModal } from "@ui/ui_template_modal";
+import { buildPager } from "../M01_MasterData/M01_MasterData_UI_Cells";
+import { buildHeadFilters } from "../M01_MasterData/M01_MasterData_UI_Head";
+import "../M01_MasterData/M01_MasterData_UI_Style.css";
+import {
+  deleteLayerTemplate,
+  deleteTemplate,
+  getActiveOwner,
+  listTemplates,
+  newLibrary,
+  readTemplate,
+  saveTemplate,
+  type Layer,
+  type LibraryBody,
+  type TemplateInfo,
+} from "./M02_MasterTemplete_Api_Fetch";
+import { fetchLibLogicSubs } from "./M02_MasterTemplete_Labor_Api";
+import { openLogicPicker } from "./M02_MasterTemplete_Labor_Pick";
+import { tc } from "./M02_MasterTemplete_Labor_Text";
+import type { PrecomboKind } from "./M02_MasterTemplete_UI_Side_Precombo";
+
+/** 목록 줄 — 서버가 문서 `이름`(제목) · 단위 · 1 단위 기준 계를 실어 보냄 */
+type Row = TemplateInfo & {
+  제목?: string | null;
+  단위?: string | null;
+  기준금액?: number | null;
+  구분?: string | null;
+  상세구분?: string | null;
+};
+
+export interface LibraryListOptions {
+  layer: Layer;
+  kind: PrecomboKind;
+  canEdit: boolean;
+  /** 줄 누름 · 생성 · 복사 뒤 — 그 문서 상세 */
+  open: (key: string, label: string) => void;
+}
+
+const SIZE = 30;
+const why = (error: unknown): string => (error instanceof Error ? error.message : "");
+const money = (v: number | null | undefined): string =>
+  v == null ? "" : v.toLocaleString("ko-KR", { maximumFractionDigits: 2 });
+export const libraryLabel = (row: Row): string => (row.제목 ? `${row.이름} ${row.제목}` : row.이름);
+
+/** `tools` = 상세 머리 단추 자리(페이지 slot) · 돌려준 `destroy` 는 안 씀(칸째 비움) */
+export function mountLibraryList(
+  host: HTMLElement,
+  tools: HTMLElement,
+  opt: LibraryListOptions,
+): { getDoc: () => null; destroy: () => void } {
+  let rows: Row[] = [];
+  let picked: string | null = null;
+  let page = 1;
+  const searchField = createInputField({ type: "search", placeholder: tc("Search") });
+  const body = el("tbody");
+  let pager = buildPager(0, SIZE, 1, () => {});
+  const btnNew = createButton({ label: tc("Lib_Create"), variant: "filled" });
+  const btnCopy = createButton({ label: tc("Lib_Copy"), variant: "ghost" });
+  const btnDel = createButton({ label: tc("Lib_Delete"), variant: "danger" });
+  const paintButtons = (): void => {
+    btnCopy.disabled = btnDel.disabled = !rows.some((r) => r.이름 === picked);
+  };
+
+  const draw = (): void => {
+    const q = searchField.input.value.trim().toLowerCase();
+    const shown = rows.filter((r) => !q || libraryLabel(r).toLowerCase().includes(q));
+    page = Math.min(page, Math.max(1, Math.ceil(shown.length / SIZE)));
+    const next = buildPager(shown.length, SIZE, page, (p) => {
+      page = p;
+      draw();
+    });
+    pager.replaceWith(next);
+    pager = next;
+    body.replaceChildren(
+      ...(shown.length
+        ? shown.slice((page - 1) * SIZE, page * SIZE).map((row) => {
+            const radio = el("input", {
+              attrs: { type: "radio", name: `m02-lib-${opt.kind}`, "aria-label": row.이름 },
+            }) as HTMLInputElement;
+            radio.checked = row.이름 === picked;
+            const pick = el("td", { className: "m02-lib__pick", children: [radio] });
+            pick.addEventListener("click", (event) => {
+              event.stopPropagation(); // 고름 칸은 열지 않음
+              picked = row.이름;
+              radio.checked = true;
+              paintButtons();
+            });
+            const tr = el("tr", {
+              className: "m01-master__table-row",
+              attrs: { "data-lib-key": row.이름 },
+              children: [
+                pick,
+                ...[
+                  row.이름,
+                  row.구분 ?? "",
+                  row.상세구분 ?? "",
+                  row.제목 ?? "",
+                  row.단위 ?? "",
+                  money(row.기준금액),
+                  row.수정일,
+                ].map((v) => el("td", { text: v, attrs: { title: v } })),
+              ],
+            });
+            tr.addEventListener("click", () => opt.open(row.이름, libraryLabel(row)));
+            return tr;
+          })
+        : [
+            el("tr", {
+              children: [el("td", { text: L("M02_NoTemplates"), attrs: { colspan: "8" } })],
+            }),
+          ]),
+    );
+    paintButtons();
+  };
+
+  const load = async (): Promise<void> => {
+    try {
+      rows = (await listTemplates(opt.layer, null)).filter((r) => r.종류 === opt.kind) as Row[];
+    } catch (error) {
+      rows = [];
+      showToast(L("M02_LoadFailed").replace("{value}", why(error)), "error");
+    }
+    draw();
+  };
+
+  const nameDialog = (title: string, start: string, onOk: (name: string) => Promise<void>) => {
+    const name = createInputField({ label: L("M02_Name"), placeholder: L("M02_Name") });
+    name.input.value = start;
+    openModal({
+      title,
+      closeLabel: L("M02_Close"),
+      dialogClass: "m02-modal",
+      mount: (box, close) => {
+        const ok = createButton({ label: L("M02_Create"), variant: "filled" });
+        ok.addEventListener("click", async () => {
+          const text = name.input.value.trim();
+          if (!text) return showToast(L("M02_NameNeeded"), "error");
+          ok.disabled = true; // 연달아 눌러도 한 번만
+          try {
+            await onOk(text);
+            close();
+          } catch (error) {
+            showToast(L("M02_ActionFailed").replace("{value}", why(error)), "error");
+          } finally {
+            ok.disabled = false;
+          }
+        });
+        name.input.addEventListener("keydown", (event) => {
+          if (event.key === "Enter" && !event.isComposing) ok.click();
+        });
+        box.append(name.root, ok);
+      },
+    });
+  };
+
+  /** 새로 — 서버가 그 층 다음 키로 씀 → 그 문서 상세 */
+  const made = (key: string, label: string): void => {
+    showToast(L("M02_Created"), "success");
+    opt.open(key, label);
+  };
+  const create = async (body: LibraryBody, label: string): Promise<void> =>
+    made((await newLibrary(opt.layer, opt.kind, body)).이름, label);
+
+  /** 단가승격 = 단가산출 로직 고르기 → 이름 · 단위 · 구분 · 연결은 로직 것(서버가 채움) ·
+   * 사전조합 = 이름 + 구분 · 상세구분 처음 값 = 로직 구분 목록 첫 줄(51-12 · 상세에서 바꿈) · 빈 묶음 */
+  btnNew.addEventListener("click", () => {
+    if (opt.kind === "promote")
+      return openLogicPicker((x) => {
+        const doc = {
+          이름: x.이름,
+          단위: x.결과단위 || null,
+          담은로직: [{ 로직: x.키, 입력값: {} }],
+        };
+        void create({ 문서: doc }, x.이름).catch((error) =>
+          showToast(L("M02_ActionFailed").replace("{value}", why(error)), "error"),
+        );
+      });
+    nameDialog(L("M02_NewTitle"), "", async (name) => {
+      const first = (await fetchLibLogicSubs())[0];
+      const 문서 = {
+        이름: name,
+        구분: first?.name ?? null,
+        상세구분: first?.details[0] ?? null,
+        단위: null,
+        담은로직: [],
+      };
+      await create({ 문서 }, name);
+    });
+  });
+
+  /** 복사 = 같은 층 새 키(서버 · 본뜬 = 원래 키) → 고른 이름으로 고쳐 씀 */
+  btnCopy.addEventListener("click", () => {
+    const from = rows.find((r) => r.이름 === picked);
+    if (!from) return;
+    nameDialog(L("M02_CopyTitle"), `${from.제목 ?? from.이름} (2)`, async (name) => {
+      const got = await newLibrary(opt.layer, opt.kind, {
+        본뜬: { 층: opt.layer, 주인: getActiveOwner(), 키: from.이름 },
+      });
+      const doc = await readTemplate(opt.layer, opt.kind, got.이름, null);
+      await saveTemplate(opt.layer, opt.kind, got.이름, null, got.판, {
+        ...(doc.문서 as object),
+        이름: name,
+      });
+      made(got.이름, name);
+    });
+  });
+
+  btnDel.addEventListener("click", async () => {
+    await load(); // 판을 최신으로
+    const info = rows.find((r) => r.이름 === picked);
+    if (!info) return;
+    const label = libraryLabel(info);
+    if (!(await showConfirmDialog(L("M02_DeleteConfirm").replace("{value}", label)))) return;
+    try {
+      if (opt.layer === "system") await deleteTemplate(opt.kind, info.이름, info.판);
+      else await deleteLayerTemplate(opt.layer, opt.kind, info.이름, info.판);
+      showToast(L("M02_Deleted"), "success");
+      picked = null;
+      await load();
+    } catch (error) {
+      // 쓰는 곳이 있으면 서버가 막음 — 까닭(쓰는 곳 이름) 그대로
+      showToast(why(error) || L("M02_ActionFailed").replace("{value}", ""), "error");
+    }
+  });
+
+  searchField.input.addEventListener("input", () => {
+    page = 1;
+    draw();
+  });
+  const heads = [
+    "",
+    "Lib_Key",
+    "Sub",
+    "Detail",
+    "Lib_Name",
+    "Lib_Unit",
+    "Lib_Base",
+    "Lib_Date",
+  ] as const;
+  host.replaceChildren(
+    buildHeadFilters([searchField.root, pager]),
+    el("div", {
+      className: "m01-master__grid-wrap",
+      attrs: { "data-lib-list": opt.kind },
+      children: [
+        el("table", {
+          className: "m01-master__grid",
+          children: [
+            el("thead", {
+              children: [
+                el("tr", { children: heads.map((h) => el("th", { text: h ? tc(h) : "" })) }),
+              ],
+            }),
+            body,
+          ],
+        }),
+      ],
+    }),
+  );
+  if (opt.canEdit)
+    tools.replaceChildren(
+      el("span", { className: "m02-main__tools", children: [btnNew, btnCopy, btnDel] }),
+    );
+  void load();
+  return { getDoc: () => null, destroy: () => undefined };
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py b/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py
index ac26926b7..f6f44ca31 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py
+++ b/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py
@@ -25,6 +25,7 @@ from common_util import common_util_spreadsheet as spreadsheet
 from common_util.common_util_auth import verify_session
 from common_util.common_util_storage import resolve_stored_project_path
 from config.config_db import get_db_pool, run_with_connection
+from M02_MasterTemplete import M02_Labor_Ref as refs
 from M02_MasterTemplete import M02_Layer_Access as access
 from M02_MasterTemplete import M02_MasterTemplete_Items as items_store
 from M02_MasterTemplete import M02_MasterTemplete_Router_Items as items_router
@@ -278,6 +279,8 @@ async def list_layer(
         row["출처"] = manifest.get(f"{row['종류']}/{row['이름']}")
         if (row["종류"], row["이름"]) in store.IN_USE:  # 화면이 지우기 확인 창 전에 막음
             row["쓰는곳"] = store.IN_USE[(row["종류"], row["이름"])]
+    # 서고(50-3) — 보이는 이름 · 단위 · 기준 금액(51-4)
+    await asyncio.to_thread(refs.summaries, folder, rows)
     return {"층": layer, "양식": rows}
 
 
@@ -306,6 +309,7 @@ async def read_layer_template(
         raise HTTPException(status_code=404, detail="양식을 찾을 수 없습니다.")
     found["층"] = layer
     found["출처"] = layers.read_manifest(folder).get(f"{kind}/{name}")
+    found["문서"] = refs.filled(kind, found["문서"])  # 옛 서고 문서 구분 · 상세구분(51-12)
     return found
 
 
@@ -324,6 +328,8 @@ async def save_layer_template(
         session, layer, project_id=project_id, user_id=user_id, owner=owner, write=True
     )
     document = body.문서
+    if layer == "project" and kind in layers.LIBRARY_KINDS:
+        raise HTTPException(status_code=400, detail="프로젝트는 서고 문서를 안 둠 — 굳힌 사본만")
     try:
         layers.check_skeleton(kind, document)  # 빈 `{}` · 뼈대 없는 문서는 파일 안 씀
     except ValueError as error:
@@ -406,6 +412,10 @@ async def delete_layer_template(
         layers.check_name(name)
     except ValueError as error:
         raise _bad(error) from error
+    try:  # 서고 문서를 담은 일위대가 · 사전조합이 있으면 409(50-3)
+        await asyncio.to_thread(refs.refuse_used, folder, kind, name)
+    except store.StoreError as error:
+        raise HTTPException(status_code=error.status, detail=error.detail) from error
     if not 판:
         raise HTTPException(status_code=400, detail="지울 양식의 판이 필요합니다.")
     try:
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Store.py
index 95a05a85a..214f2fe6b 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Store.py
+++ b/M02_MasterTemplete/M02_MasterTemplete_Store.py
@@ -153,6 +153,8 @@ def write(kind: str, name: str, version: str, doc: Any, screen: bool = False) ->
     (정본 = 나무 · 머리는 경로에서 다시 만듦 · `tree.keep_paths`)."""
     path = _path(kind, name)
     _check_skeleton(kind, doc)
+    if kind in layers.LIBRARY_KINDS:  # 서고 문서 키 = 파일 이름(50-3)
+        doc = {**doc, "키": name}
     origins = _take_origins(doc) if kind == "table" else {}
     if kind == "table" and name == STRUCTURE_TABLE:
         doc = tree.normalize_table(doc)  # 경로 · 머리 줄 수 · 빈 폴더(표 저장 · 나무 고침 한 줄기)
@@ -186,6 +188,10 @@ def delete(kind: str, name: str, version: str | None = None) -> None:
     path = _path(kind, name)
     if (kind, name) in IN_USE:
         raise StoreError(409, f"쓰는 양식이라 못 지움 「{name}」 — {IN_USE[(kind, name)]}")
+    if kind in layers.LIBRARY_KINDS:
+        from M02_MasterTemplete import M02_Labor_Ref as refs
+
+        refs.refuse_used(root(), kind, name)
     with _LOCK:
         if not path.is_file():
             raise StoreError(404, f"없는 양식 「{name}」")
@@ -387,7 +393,7 @@ def copy_from(
             body = read(kind, source)["문서"]
     body = read(kind, source)["문서"] if body is None else body
     doc = {**body, **{k: target.get(k) for k in ("열", _KEY[kind])}}
-    doc = _server(kind, {k: v for k, v in doc.items() if k != "계산값"})
+    doc = _server(kind, {k: v for k, v in doc.items() if k != "계산값"}, source_root)
     with _LOCK:
         atomic_write_json(_path(kind, column), doc)
         info = _info(kind, _path(kind, column))
@@ -493,14 +499,21 @@ def renumber() -> dict[str, list[str]]:
     return {"옮김": moved, "지움": gone, "바꿈": changed, "새로": made}
 
 
-def _server(kind: str, doc: Any) -> Any:
-    """서버가 적는 값 — 통합문서 계산값(5장 ②) · 일위대가 정리 · 계산값(`M02_Labor_Doc`)."""
+def _server(kind: str, doc: Any, source: Path | None = None) -> Any:
+    """서버가 적는 값 — 통합문서 계산값(5장 ②) · 일위대가 정리 · 계산값(`M02_Labor_Doc`) ·
+    서고 문서 정리(`M02_Labor_Ref` · 50-3) · `source` = 층 사이 복사의 원본 층 폴더(지금 층이
+    못 읽는 참조는 같이 복사)."""
     if kind in SHEETS:
         return _server_values(doc)
-    if kind == "labor":
+    if kind in ("labor", *layers.LIBRARY_KINDS):
         from M02_MasterTemplete import M02_Labor_Doc as labor
+        from M02_MasterTemplete import M02_Labor_Ref as refs
 
-        return labor.server(doc)
+        if source is not None and isinstance(doc, dict) and kind != "promote":
+            doc = refs.carry(doc, refs.where(source))
+        if kind == "labor":
+            return labor.server(doc)
+        return refs.clean_doc(kind, doc)
     return doc
 
 
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Structure.ts b/M02_MasterTemplete/M02_MasterTemplete_Structure.ts
index 11c49c3d3..8bf976944 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Structure.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Structure.ts
@@ -160,7 +160,9 @@ export async function pillsFor(
       ...(p.자재 ? { 자재: p.자재 } : {}),
       고정: true,
     }));
-    return 항목.length ? { links: { 항목, 모드: "입력" } } : none(TEXT.noPills);
+    // 받기 성공 = 목록 확정 — 이 목록에 없는 연결 알약만 ⚠(받기 실패 때는 표시 안 함)
+    const links: LinkOptions = { 항목, 모드: "입력", 확정: true };
+    return 항목.length ? { links } : { ...none(TEXT.noPills), links };
   } catch (error) {
     return none(fill(TEXT.pillsFailed, why(error)));
   }
diff --git a/M02_MasterTemplete/M02_MasterTemplete_TreePanel.css b/M02_MasterTemplete/M02_MasterTemplete_TreePanel.css
index 760776347..a5a67be4d 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_TreePanel.css
+++ b/M02_MasterTemplete/M02_MasterTemplete_TreePanel.css
@@ -22,11 +22,6 @@
   overflow-wrap: anywhere;
 }
 
-/* 찾기 칸 — 상세 위쪽(PLAN 29-2) */
-.m02-tree__search {
-  max-width: 24rem;
-}
-
 /* 층 단추 셋 · 사람 고르기 — 좌측 패널 줄 아래 한 줄(PLAN 29-2) */
 .m02-layers {
   display: flex;
diff --git a/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts b/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts
index 3fa73d61b..f8c2ed41f 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts
@@ -1,7 +1,7 @@
 /* =============================================================================
  * M02_MasterTemplete_TreePanel.ts
- * 관리 화면(마스터 · 회사 · 개인 공용) 「구조물 라이브러리」 한 층의 나무 — 폴더 → … → 항목(깊이 자유) · 찾기.
- * 층 + `owner`(남의 층 · PLAN 27-1c) 한 벌을 그림 — 층 단추는 `_Roots` · 찾기 칸은 부르는 쪽이 상세 위쪽에 · 자료 길은 `api`.
+ * 관리 화면(마스터 · 회사 · 개인 공용) 「구조물 라이브러리」 한 층의 나무 — 폴더 → … → 항목(깊이 자유).
+ * 층 + `owner`(남의 층 · PLAN 27-1c) 한 벌을 그림 — 층 단추는 `_Roots` · 자료 길은 `api`.
  * 항목을 누르면 표에서 그 열이 골라짐(카드 넷은 표가 엶) · 표에서 열을 고르면 `select` 로 나무도 그 항목.
  * 오른쪽 클릭 · 키보드(F2 · Delete)로 폴더 · 항목 더하기 · 이름 바꾸기 · 옮기기 · 지우기 —
  * `POST /api/m02/layers/{층}/tree`(PLAN 26-1). 읽기만 층은 [복사]만. 나무 자료는 `_Model`.
@@ -10,13 +10,7 @@
  * ========================================================================== */
 
 import "./M02_MasterTemplete_TreePanel.css";
-import {
-  createButton,
-  createInputField,
-  el,
-  showConfirmDialog,
-  showToast,
-} from "@ui/ui_template_elements";
+import { createButton, el, showConfirmDialog, showToast } from "@ui/ui_template_elements";
 import { loadingError, showLoading } from "@ui/ui_template_loading";
 import { t as L } from "@ui/ui_template_locale";
 import {
@@ -103,8 +97,6 @@ export interface TreePanelOptions {
 export interface TreePanelHandle {
   /** 나무(좌측 패널에 붙임) */
   root: HTMLElement;
-  /** 찾기 칸 — 부르는 쪽이 상세 위쪽에 붙임(PLAN 29-2) */
-  search: HTMLElement;
   /** 층 단추 줄 오른쪽 도구 — 「N개 고름」(30-2) · 「+」(맨 위 폴더 · 항목 더하기 · 읽기만 층 = 숨김 · 29-6) */
   add: HTMLElement;
   refresh: () => Promise<void>;
@@ -132,7 +124,6 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
   const api = opt.api ?? { fetch: fetchTree, edit: editTree, many: editTreeMany, paste: pasteTree };
   const clipKind = "구조물"; // 복사해 둔 것의 나무 종류 — 같은 종류 나무끼리만 붙임
   let view: TreeView | null = null;
-  let text = "";
   let activeCol: string | null = null;
   let seq = 0;
   let busy = false;
@@ -142,10 +133,8 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
   let picked = new Set<string>();
   let anchor: string | null = null;
 
-  const search = createInputField({ placeholder: L("M02_TreeSearch"), compact: true });
   const body = el("div", { className: "m02-tree__body", attrs: { tabindex: "-1" } });
   const root = el("div", { className: "m02-tree", children: [body] });
-  search.root.classList.add("m02-tree__search");
   // 층 단추 옆 「+」 — 맨 위에 폴더 · 항목 더하기(뿌리 줄 오른쪽 클릭을 갈음)
   const add = createButton({
     label: "+",
@@ -241,10 +230,10 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
     return { ...base, id, ...(opt.canEdit || canCopy ? { menu: () => menuFor(target, id) } : {}) };
   }
 
-  function folderNode(folder: FolderNode, searching: boolean): TreeNode {
+  function folderNode(folder: FolderNode): TreeNode {
     const id = folderIdOf(folder.path);
     const kids = [
-      ...folder.folders.map((one) => folderNode(one, searching)),
+      ...folder.folders.map((one) => folderNode(one)),
       ...folder.items.map((item) =>
         node(
           { kind: "item", item },
@@ -265,7 +254,7 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
         count: countItems(folder),
         folder: true,
         children: kids,
-        open: searching || open.has(id),
+        open: open.has(id),
         run: () => void (open.has(id) ? open.delete(id) : open.add(id)),
       },
       id,
@@ -348,19 +337,12 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
     const focused = (document.activeElement as HTMLElement | null)?.dataset?.node;
     targets.clear();
     if (!view) return body.replaceChildren(hint(L("M02_PickerLoading")));
-    const searching = text.trim() !== "";
-    const tree = buildFolders(view, text);
-    const none = countItems(tree) === 0 && (searching || !tree.folders.length);
+    const tree = buildFolders(view);
+    const none = countItems(tree) === 0 && !tree.folders.length;
     body.replaceChildren(
       // 맨 위 뿌리 줄 없음 — 폴더 · 항목부터(PLAN 29-6 · 뿌리 메뉴 = 빈 자리 오른쪽 클릭 · 「+」)
-      ...renderTree(folderNode(tree, searching).children ?? [], make),
-      ...(none
-        ? [
-            hint(
-              L(searching ? "M02_TreeNoHit" : opt.canEdit ? "M02_TreeEmptyEdit" : "M02_TreeEmpty"),
-            ),
-          ]
-        : []),
+      ...renderTree(folderNode(tree).children ?? [], make),
+      ...(none ? [hint(L(opt.canEdit ? "M02_TreeEmptyEdit" : "M02_TreeEmpty"))] : []),
     );
     if (focused) rowOf(focused)?.focus({ preventScroll: true });
     setPicked(picked, anchor); // 없어진 줄은 고름에서 뺌
@@ -599,11 +581,6 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
       : from.folders.map((one) => findFolder(one, path)).find(Boolean);
 
   /* --- 이음 --- */
-  search.input.addEventListener("input", () => {
-    text = search.input.value;
-    paint();
-  });
-
   // 빈 자리 오른쪽 클릭 = 맨 위 메뉴(폴더 · 항목 더하기 · 붙여넣기)
   body.addEventListener("contextmenu", (event) => {
     if ((event.target as HTMLElement).closest("[data-node]")) return;
@@ -676,7 +653,6 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
   };
   return {
     root,
-    search: search.root,
     add: tools,
     refresh,
     select,
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts
index 77d6b3146..7fe44d24a 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts
@@ -28,7 +28,10 @@ import {
 } from "./M02_MasterTemplete_Structure";
 import { askSettle } from "./M02_MasterTemplete_TreePanel_Dialogs";
 import { buildAreaPanel, type AreaPanel } from "./M02_MasterTemplete_AreaPanel";
-import { createAreaToDrawing } from "./M02_MasterTemplete_AreaToDrawing";
+import { createAreaToDrawing, sentRanges } from "./M02_MasterTemplete_AreaToDrawing";
+import { detailHelp, HELP_TITLE } from "./M02_MasterTemplete_CardHelp";
+import { helpParts } from "./M02_MasterTemplete_CardShell";
+import { isPrecombo } from "./M02_MasterTemplete_UI_Side_Precombo";
 import type { SpreadsheetHandle } from "../A00_Common/spreadsheet/spreadsheet";
 import type { LinkOptions } from "../A00_Common/spreadsheet/spreadsheet_links";
 export interface Selection {
@@ -101,11 +104,9 @@ export function canEdit(layer: Layer, isAdmin: boolean): boolean {
 }
 
 /** 페이지가 끼우는 것 — `top` = 편집 칸 맨 위 막대(회사용 읽기만 안내) · `onColumn` = 집계표에서 고른 열 ·
- * `search` = 「구조물 조합」을 열 때만 상세 위쪽에 보이는 나무 찾기 칸(나무는 좌측 패널 · PLAN 29-2) ·
  * `newItem` = 「구조물 조합」 제목 줄 오른쪽 끝 「새 항목」(쓸 수 있는 층만 · PLAN 30-5 · 공용 `m02-main__new`) */
 export interface MainExtras {
   top?: HTMLElement;
-  search?: HTMLElement;
   newItem?: HTMLElement;
   onColumn?: (column: string | null) => void;
   /** 구조물 조합 표 머리 이름 칸 고침 → 나무 이름 바꾸기(쓸 수 있는 층만 · PLAN 31-1) */
@@ -132,6 +133,7 @@ export function createMain(
   const save = createButton({ label: L("M02_Save"), variant: "filled" });
   // 구조물 도면 · 일위대가 · 면적산출 상세 화면 → 구조물집계표(그 열 고른 채) · 일반 단추(43-5 · 알약 · ghost 아님)
   const back = createButton({ label: L("M02_Back") });
+  const helpSlot = el("span", { className: "m02-main__help" }); // 상세 [?](49-7) — 제목 바로 옆
   const slot = el("div", { className: "m02-main__slot" }); // 도면 양식의 작도 영역 칸이 들어옴
   const notice = el("div", { className: "m02-main__notice", attrs: { hidden: "" } });
   const host = el("div", { className: "m02-main__host" });
@@ -143,9 +145,16 @@ export function createMain(
       el("div", {
         className: "m02-main__head",
         // M01 머리 꼴(39-5) — ← 는 제목 앞 · 제목 18px 왼쪽 · 단추는 오른쪽(slot 이 늘어나 밂)
-        children: [back, title, slot, reload, save, ...(extras.newItem ? [extras.newItem] : [])],
+        children: [
+          back,
+          title,
+          helpSlot,
+          slot,
+          reload,
+          save,
+          ...(extras.newItem ? [extras.newItem] : []),
+        ],
       }),
-      ...(extras.search ? [extras.search] : []),
       notice,
       host,
       extra,
@@ -154,10 +163,9 @@ export function createMain(
   const root = column;
   const isCombo = (at: Selection | null): boolean =>
     !!at && at.kind === "table" && at.name === STRUCTURE_TABLE && at.layer !== "project";
-  // 찾기 칸 · 「새 항목」 · 표 접기(제목)는 「구조물 조합」일 때만
+  // 「새 항목」 · 표 접기(제목)는 「구조물 조합」일 때만
   const showAside = (): void => {
     const combo = isCombo(sel);
-    if (extras.search) extras.search.hidden = !combo;
     if (extras.newItem) extras.newItem.hidden = !combo;
     title.classList.toggle("m02-main__title--fold", combo);
     title.title = combo ? L("M02_TableFold") : "";
@@ -166,7 +174,7 @@ export function createMain(
       title.classList.remove("is-folded");
     }
   };
-  // 「구조물 조합」 표 접기(PLAN 31-2) — 제목을 누르면 표만 접힘 · 펴짐(카드 · 찾기는 그대로)
+  // 「구조물 조합」 표 접기(PLAN 31-2) — 제목을 누르면 표만 접힘 · 펴짐(카드는 그대로)
   title.addEventListener("click", () => {
     if (!isCombo(sel)) return;
     host.hidden = !host.hidden;
@@ -220,6 +228,9 @@ export function createMain(
     reload.hidden = !sel;
     save.hidden = !sel || !canEdit(sel.layer, isAdmin);
     back.hidden = !sel || !(sel.kind in NUMBER_FIELD);
+    const kind = sel && sel.kind in HELP_TITLE ? (sel.kind as keyof typeof HELP_TITLE) : null;
+    const help = kind && helpParts(HELP_TITLE[kind], detailHelp(kind)); // 열 때마다 새로 — 상자는 닫힘
+    helpSlot.replaceChildren(...(help ? [help.button, help.box] : []));
   };
 
   // 면적산출 범위 → 도면 표(41-3) — 몸은 `AreaToDrawing` · 여기는 갈고리만
@@ -263,13 +274,14 @@ export function createMain(
   ): Promise<void> {
     const mine = seq;
     try {
-      const [{ createSpreadsheet }, pills] = await Promise.all([
+      const [{ createSpreadsheet }, pills, sent] = await Promise.all([
         import("../A00_Common/spreadsheet/spreadsheet"),
         pillsFor(kind, at.name),
+        sentRanges(at), // 도면으로 보낸 범위 — 시트 위 점선 테두리
       ]);
       if (mine !== seq) return;
       if (pills.notice) showNotice([pills.notice]);
-      const links: LinkOptions = pills.links;
+      const links: LinkOptions = { ...pills.links, 표시범위: sent };
       const handle: SpreadsheetHandle = createSpreadsheet(
         host,
         doc as Parameters<typeof createSpreadsheet>[1],
@@ -368,19 +380,24 @@ export function createMain(
       editor = { getDoc: () => comboMerge(loaded, shown.getDoc()), destroy: shown.destroy };
       return;
     }
-    if (at.kind === "labor") {
-      // 일위대가 상세(39-3) — 구조물 열마다 하나 · 고침은 이 화면 [저장]으로
+    if (at.kind === "labor" || isPrecombo(at.kind)) {
+      // 일위대가 상세(39-3) — 구조물 열마다 하나 · 고침은 이 화면 [저장]으로 ·
+      // 단가승격 · 사전조합(50-3) = 같은 상세 모드(도면 · 면적 · 자재 없음 · 이름 = 키)
       const { mountLaborDetail } = await import("./M02_MasterTemplete_Labor_Detail");
+      const mode = isPrecombo(at.kind) ? at.kind : undefined;
       const labor = mountLaborDetail(host, doc, {
         layer: at.layer,
         column: at.name,
         readOnly,
         onChanged: (d) => (dirty = d && !readOnly),
-        goArea: async () => {
-          if (!(await confirmLeave())) return false; // 취소 — 입력 모달 그대로
-          void open({ ...at, kind: "area" });
-          return true;
-        },
+        goArea: mode
+          ? null
+          : async () => {
+              if (!(await confirmLeave())) return false; // 취소 — 입력 모달 그대로
+              void open({ ...at, kind: "area" });
+              return true;
+            },
+        ...(mode ? { mode } : {}),
       });
       // [저장] = 엑셀에서 고른 칸 연결(면적 문서) 먼저 · 그다음 일위대가(서버가 새 칸 값으로 계산값)
       editor = {
@@ -437,6 +454,19 @@ export function createMain(
       return empty("");
     }
     title.textContent = isCombo(next) ? L("M02_KindTable") : (next.label ?? next.name); // 26-7a
+    if (isPrecombo(next.kind) && !next.name) {
+      // 서고 목록표(51-4) — 이름 "" · 저장할 것 없음 · 줄 누름 = 그 문서 상세
+      save.hidden = true;
+      const { mountLibraryList } = await import("./M02_MasterTemplete_Library_List");
+      if (mine !== seq) return;
+      editor = mountLibraryList(host, slot, {
+        layer: next.layer,
+        kind: next.kind,
+        canEdit: canEdit(next.layer, isAdmin),
+        open: (name, label) => void open({ ...next, name, label }),
+      });
+      return;
+    }
     const stop = showLoading(host); // 0.3초 넘으면 상세 칸 안에 「불러오는 중」(PLAN 30-6)
     try {
       const got = await readTemplate(next.layer, next.kind, next.name, next.projectId);
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Page.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Page.ts
index e18034463..7eebb2002 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Page.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Page.ts
@@ -1,7 +1,7 @@
 /* =============================================================================
  * M02_MasterTemplete_UI_Page.ts
  * 마스터 템플릿 · 구조물 관리 화면 — 좌측 도킹 패널(양식 목록 · 층 단추 · 고른 층의 나무) /
- * 우측 편집 칸(표·도면 부품 · 「구조물 조합」이면 위쪽에 나무 찾기 칸 · PLAN 29-2)
+ * 우측 편집 칸(표·도면 부품 · 「구조물 조합」이면 나무는 좌측 패널 · PLAN 29-2)
  *
  * 한 화면에 층 셋(마스터 · 회사 · 개인 · PLAN 27-1) — 고른 층 = 진입 해시 `?open=&root=&owner=&company=`
  * (`M02_MasterTemplete_Layer.ts`) · 층 단추 · 「사람 고르기」를 누르면 해시를 바꿔 이 화면을 다시 세움.
@@ -105,13 +105,13 @@ export async function renderM02MasterTemplate(root: HTMLElement): Promise<Mounte
   // 층 단추 셋(PLAN 29-2) — 「구조물 조합」 줄 아래 한 벌
   // 단추 옆 「+」 = 그 나무 맨 위 더하기(뿌리 줄을 갈음 · 29-6)
   // 켜진 단추를 다시 누르면 그 층 목록 화면(30-4 · 집계표)
-  const layerBar = (open: OpenTarget, add: HTMLElement, reselect: () => void): HTMLElement =>
+  const layerBar = (open: OpenTarget, add: HTMLElement | null, reselect: () => void): HTMLElement =>
     createLayerBar({
       user,
       active: { root: entry.root, owner },
       company,
       go: (next, nextOwner) => void go(next, nextOwner, open),
-      add,
+      ...(add ? { add } : {}),
       reselect,
     });
   // 남의 회사 「개인」 — 고른 사람 줄 아래에 그 사람 나무(사람 줄 → 라이브러리 · 29-6)
@@ -130,7 +130,6 @@ export async function renderM02MasterTemplate(root: HTMLElement): Promise<Mounte
     () => side.paint(),
     {
       top: readOnlyBar?.root,
-      search: tree.search,
       // 「새 항목」(30-5) — 제목 줄 오른쪽 끝 · 쓸 수 있는 층만 · 상세 칸에 [새로 만들기] [복사 생성](39-5)
       ...(canEdit(layer, isAdmin) ? { newItem: newItemButton(() => void openNew()) } : {}),
       onColumn: (column) => {
@@ -185,6 +184,8 @@ export async function renderM02MasterTemplate(root: HTMLElement): Promise<Mounte
       layerBar("구조물조합", tree.add, () => void main.openTable(layer)),
       peopleTree("구조물조합", tree.root),
     ],
+    // 일위대가 조합(50-3) — 같은 층 단추 · 누르면 그 층 화면에서 이 컨테이너를 펼침
+    precomboBar: [layerBar("일위대가조합", null, () => undefined)],
   });
 
   const layout = el("div", { className: "ui-workflow-layout m02-master" });
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts
index 5fc86b60a..7ceefa0f5 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts
@@ -1,6 +1,7 @@
 /* =============================================================================
  * M02_MasterTemplete_UI_Side.ts
- * 마스터 템플릿 좌측 패널 — 「구조물 조합」(층 단추 · 나무) · 「도면 양식」(새로 · 본떠 · 지우기).
+ * 마스터 템플릿 좌측 패널 — 「구조물 조합」(층 단추 · 나무) · 「일위대가 조합」(층 단추 · 단가승격 · 사전조합 ·
+ * `UI_Side_Precombo` · 50-3) · 「도면 양식」(새로 · 본떠 · 지우기).
  * 서버 길은 계약 `6_계약.md`.
  * 구조물 도면 · 일위대가 · 면적산출 상세는 좌측 줄이 아니라 항목 카드 [수정]으로(PLAN 45-2).
  * 화면 이름 「구조물 조합」(PLAN 26-7a) — 파일 이름 · 양식 키 · API 길은 「구조물집계표」 그대로.
@@ -31,6 +32,7 @@ import { STRUCTURE_TABLE } from "./M02_MasterTemplete_Structure";
 import { buildOptionsSection } from "./StructOptions/M02_SO_Options";
 import { buildPracticeSection } from "./M02_MasterTemplete_Practice";
 import { canEdit, type Selection } from "./M02_MasterTemplete_UI_Main";
+import { buildPrecomboSection, PRECOMBO_TITLE } from "./M02_MasterTemplete_UI_Side_Precombo";
 
 const KINDS: { kind: Kind; label: () => string }[] = [
   { kind: "table", label: () => L("M02_KindTable") },
@@ -58,6 +60,8 @@ export interface SideOptions {
   showView: (label: string, node: HTMLElement) => (dirty: boolean) => void;
   /** 「구조물 조합」 줄 아래 — 층 단추 · 고른 층의 구조물 라이브러리 나무(PLAN 29-2 · 페이지가 만듦) */
   tree?: HTMLElement[];
+  /** 「일위대가 조합」 줄 아래 층 단추(50-3 · 페이지가 만듦) */
+  precomboBar?: HTMLElement[];
 }
 
 export interface SideHandle {
@@ -66,7 +70,7 @@ export interface SideHandle {
   /** 고름 표시를 지금 열린 것 한 줄로 — 편집 칸이 무엇을 열든(카드 [도면 수정] 등) 부름 */
   paint: () => void;
   /** 진입 해시 `open`(PLAN 27-1d) — 그 컨테이너를 펼침(옵션은 열기까지) · 옵션 · 도면은 시스템 층에만 */
-  reveal: (target: "옵션" | "도면") => void;
+  reveal: (target: "옵션" | "도면" | "일위대가조합") => void;
 }
 
 /** 서버 이름 규칙과 같게 — 화면에서 먼저 막음 */
@@ -130,11 +134,20 @@ export function buildSide(opt: SideOptions): SideHandle {
   openOnExpand(summary, async () => {
     if (!isPicked("table", STRUCTURE_TABLE) && (await opt.confirmLeave())) opt.onOpen(null);
   });
-  // 구조물 옵션 보이기 · 도면 양식은 시스템 층(마스터 템플릿)에만 · 옵션 보이기(그룹)는 시스템 관리자만(PLAN 46)
+  // 일위대가 조합 서고(50-3) — 구조물 조합 바로 아래 · 층마다(마스터 · 회사 · 개인)
+  const precombo = buildPrecomboSection({
+    layer,
+    bar: opt.precomboBar ?? [],
+    confirmLeave: opt.confirmLeave,
+    onOpen: opt.onOpen,
+    openKind: () => (opt.getOpen()?.layer === layer ? (opt.getOpen()?.kind ?? null) : null),
+  });
+  const precomboSec = section(PRECOMBO_TITLE, precombo.body);
+  // 구조물 옵션 정의 · 도면 양식은 시스템 층(마스터 템플릿)에만 · 정의 고쳐 씀은 시스템 관리자만 · 다른 역할은 읽기만(PLAN 48-2)
   const extras =
     layer === "system"
       ? {
-          옵션: canEdit(layer, opt.isAdmin) ? section(options.title, options.body) : null,
+          옵션: section(options.title, options.body),
           도면: section(L("M02_KindDrawing"), bodies.get("drawing")!, ...actionRow("drawing")),
         }
       : null;
@@ -151,6 +164,7 @@ export function buildSide(opt: SideOptions): SideHandle {
     className: "m02-side__lists ui-sidebar-panel",
     children: [
       summary,
+      precomboSec,
       ...(extras ? [extras.옵션, extras.도면].filter((s): s is HTMLElement => !!s) : []),
       ...(practice ? [section(practice.title, practice.body)] : []),
     ],
@@ -205,6 +219,7 @@ export function buildSide(opt: SideOptions): SideHandle {
    * (양식이 열려 있으면 옵션 · 일위대가 조합 고름은 지움) */
   function paint(): void {
     paintList();
+    precombo.paint();
     paintButtons();
     if (opt.getOpen()) options.clear();
     if (opt.getOpen()) practice?.clear();
@@ -228,6 +243,7 @@ export function buildSide(opt: SideOptions): SideHandle {
     if (mine !== seq) return;
     paintList();
     paintButtons();
+    precombo.paint();
   }
 
   /* --- 시스템 층 새로 · 본떠 · 지우기(도면 양식만 — 구조물 도면은 집계표 열이 정함) --- */
@@ -307,8 +323,8 @@ export function buildSide(opt: SideOptions): SideHandle {
     }
   }
 
-  const reveal = (target: "옵션" | "도면"): void => {
-    const sec = extras?.[target];
+  const reveal = (target: "옵션" | "도면" | "일위대가조합"): void => {
+    const sec = target === "일위대가조합" ? precomboSec : extras?.[target];
     if (!sec) return; // 옵션 보이기는 시스템 관리자만
     sec.classList.remove("is-collapsed");
     if (target === "옵션") options.body.querySelector<HTMLElement>("button")?.click();
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Side_Precombo.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Side_Precombo.ts
new file mode 100644
index 000000000..7c198a6df
--- /dev/null
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Side_Precombo.ts
@@ -0,0 +1,68 @@
+/* =============================================================================
+ * M02_MasterTemplete_UI_Side_Precombo.ts
+ * 좌측 「일위대가 조합」 컨테이너(50-3 ③ · 51-4) — 구조물 조합 아래 · 층 단추(페이지가 만듦) ·
+ * 항목 둘 「단가산출 승격」(promote) · 「일위대가 사전조합」(precombo)만.
+ * 항목 누름 = 상세 칸에 그 종류 목록표(`Library_List` · 생성 · 복사 · 삭제는 거기) ·
+ * 표 줄 누름 = 편집 칸(UI_Main 종류 promote · precombo = 일위대가 상세 모드).
+ * ========================================================================== */
+
+import { el } from "@ui/ui_template_elements";
+import type { Kind, Layer } from "./M02_MasterTemplete_Api_Fetch";
+import { tc } from "./M02_MasterTemplete_Labor_Text";
+import type { Selection } from "./M02_MasterTemplete_UI_Main";
+
+export type PrecomboKind = Extract<Kind, "promote" | "precombo">;
+
+const PARTS = [
+  { kind: "promote", label: "Lib_Promote" },
+  { kind: "precombo", label: "Lib_PrecomboAll" },
+] as const;
+export const PRECOMBO_TITLE = "일위대가 조합";
+export const isPrecombo = (kind: Kind): kind is PrecomboKind =>
+  kind === "promote" || kind === "precombo";
+
+export interface PrecomboOptions {
+  layer: Layer;
+  /** 층 단추 줄(페이지가 만듦 · 누르면 그 층 화면 + 이 컨테이너 펼침) */
+  bar: HTMLElement[];
+  confirmLeave: () => Promise<boolean>;
+  onOpen: (sel: Selection | null) => void;
+  /** 이 층에서 지금 열린 종류(목록이든 문서든) — 항목 고름 표시 */
+  openKind: () => Kind | null;
+}
+
+export interface PrecomboHandle {
+  body: HTMLElement;
+  paint: () => void;
+}
+
+export function buildPrecomboSection(opt: PrecomboOptions): PrecomboHandle {
+  const items = PARTS.map((part) => {
+    const b = el("button", {
+      className: "m02-side__item ui-sidebar-row",
+      text: tc(part.label),
+      attrs: { type: "button", "data-precombo": part.kind },
+    });
+    // 이름 "" = 목록표(UI_Main)
+    b.addEventListener("click", async () => {
+      if (!(await opt.confirmLeave())) return;
+      opt.onOpen({
+        layer: opt.layer,
+        projectId: null,
+        kind: part.kind,
+        name: "",
+        label: tc(part.label),
+      });
+    });
+    return b;
+  });
+  const body = el("div", {
+    className: "m02-side__items ui-sidebar-list",
+    children: [...opt.bar, ...items],
+  });
+  const paint = (): void => {
+    const on = opt.openKind();
+    items.forEach((b, i) => b.classList.toggle("is-active", PARTS[i].kind === on));
+  };
+  return { body, paint };
+}
diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css b/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css
index 730b3775d..5fe85ec07 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css
+++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Style.css
@@ -56,6 +56,12 @@
   gap: var(--spacing-4);
 }
 
+/* 일위대가 조합 서고 목록표(51-4) — 표 꼴은 M01 목록(`m01-master__grid`) · 첫 칸 = 고름 */
+.m01-master__grid .m02-lib__pick {
+  width: 2.5rem;
+  text-align: center;
+}
+
 .m02-main {
   display: flex;
   flex-direction: column;
@@ -65,6 +71,7 @@
 }
 
 .m02-main__head {
+  position: relative; /* 상세 [?] 도움말 상자의 기준(49-7) */
   display: flex;
   flex-wrap: wrap;
   align-items: center;
@@ -84,6 +91,20 @@
   white-space: nowrap;
 }
 
+/* 상세 [?] — 단추는 제목 바로 옆 흐름 · 상자는 머리 아래 오른쪽에 뜸 */
+.m02-main__help {
+  display: contents;
+}
+
+.m02-main__head > .m02-main__help > .m02-struct__keys {
+  top: calc(100% + var(--spacing-8));
+  right: 0;
+  width: max-content;
+  max-width: min(36rem, 100%);
+  max-height: 70vh;
+  z-index: 20;
+}
+
 .m02-main__slot {
   display: flex;
   flex: 1 1 auto;
@@ -94,6 +115,7 @@
 /* 제목 줄 오른쪽 끝 도구(일위대가 「새 조합」 · PLAN 30-5) */
 .m02-main__tools {
   display: inline-flex;
+  gap: var(--spacing-8); /* M01 머리 줄(`m01-head`)과 같은 틈 */
   margin-left: auto;
 }
 
@@ -165,10 +187,6 @@
   color: var(--color-text);
 }
 
-.m02-main__head + .m02-tree__search {
-  margin-bottom: var(--spacing-8);
-}
-
 /* 상세 제목 줄 오른쪽 끝 「새 항목」 · 「새 조합」(PLAN 30-5 · 공용) — 늘어나는 칸이 없어도 끝으로 */
 .m02-main__new {
   margin-left: auto;
diff --git a/M02_MasterTemplete/M02_Template_Layers.py b/M02_MasterTemplete/M02_Template_Layers.py
index 8fc899387..3b90b61d6 100644
--- a/M02_MasterTemplete/M02_Template_Layers.py
+++ b/M02_MasterTemplete/M02_Template_Layers.py
@@ -28,7 +28,9 @@ from config import config_system
 LAYERS = ("system", "company", "personal", "project")
 # area = 면적산출 — 통합문서(구조물집계표 열마다 · `A00_Common/spreadsheet/`)
 # labor = 일위대가(구조물 열마다 · `M02_Labor_Doc`)
-KINDS = ("table", "drawing", "structure", "labor", "area")
+# promote = 단가승격(SP-) · precombo = 사전조합(SC-) — 일위대가 조합 서고(`M02_Labor_Ref`)
+LIBRARY_KINDS = ("promote", "precombo")
+KINDS = ("table", "drawing", "structure", "labor", "area", *LIBRARY_KINDS)
 TEMPLATES_DIRNAME = "templates"
 INITIAL_DIRNAME = "_initial"
 MANIFEST_NAME = "manifest.json"
@@ -171,6 +173,8 @@ _SKELETON = {
     "structure": ("도면.entities",),
     "labor": ("담은로직",),
     "area": ("시트",),
+    "promote": ("담은로직",),
+    "precombo": ("담은로직",),
 }
 
 
@@ -230,6 +234,17 @@ def delete_template(
     return True
 
 
+def layer_files(kind: str) -> list[tuple[str, Path]]:
+    """모든 층(마스터 · 회사 · 개인 · 프로젝트 빼고)의 `kind/*.json` — (어디, 파일)."""
+    root = storage_root()
+    found = [("마스터", p) for p in sorted((system_dir() / kind).glob("[!.]*.json"))]
+    found += [
+        (f"회사 {p.parts[-4]}", p) for p in sorted(root.glob(f"*/templates/{kind}/[!.]*.json"))
+    ]
+    personal = sorted(root.glob(f"*/*/templates/{kind}/[!.]*.json"))
+    return found + [(f"개인 {p.parts[-5]}/{p.parts[-4]}", p) for p in personal]
+
+
 # ── manifest ──────────────────────────────────────────
 
 
@@ -283,7 +298,8 @@ def copy_templates(
 ) -> list[str]:
     """`source_dir` 층의 양식을 `target_dir` 로 복사 → 복사한 `종류/이름` 목록.
 
-    `kind`·`name` 으로 좁힘 · `only_missing` 이면 이미 있는 파일은 건너뜀(더하기만).
+    `kind`·`name` 으로 좁힘(안 좁히면 서고 종류 `LIBRARY_KINDS` 는 뺌 — 프로젝트는 굳힌 사본) ·
+    `only_missing` 이면 이미 있는 파일은 건너뜀(더하기만).
     manifest 에 출처(층 · 이름 · 판 · `source_ref`)를 적음. 출처 manifest 의 원래 출처는
     적지 않음 — 「어디서 가져왔나」 한 단계만.
     """
@@ -292,6 +308,8 @@ def copy_templates(
     rows = list_templates(source_dir)
     if kind is not None:
         rows = [row for row in rows if row["종류"] == check_kind(kind)]
+    else:
+        rows = [row for row in rows if row["종류"] not in LIBRARY_KINDS]
     if name is not None:
         rows = [row for row in rows if row["이름"] == check_name(name)]
     manifest = read_manifest(target_dir)
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Api.ts b/M02_MasterTemplete/StructOptions/M02_SO_Api.ts
index a8bafd1fa..a91a2578f 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Api.ts
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Api.ts
@@ -1,56 +1,29 @@
 /* =============================================================================
  * M02_SO_Api.ts
- * 구조물 옵션 보이기 · 그룹 서버 호출 — 서버 = `M02_SO_Router.py`
- * (마스터 템플릿 `구조물옵션표시.json` · `구조물옵션그룹.json`)
+ * 구조물 정의 서버 호출 — 서버 = `M02_SO_Router.py`(마스터 템플릿 `구조물정의.json` 한 벌 · PLAN 48)
  * ========================================================================== */
 
 import { call } from "../M02_MasterTemplete_Api_Fetch";
+import type { StructDef } from "./M02_SO_Def_Model";
 
-export interface OptionKind {
-  type_id: string;
-  group: string;
-  name: string;
-  /** 거짓이면 B05 선택지에 안 나오는 종류 */
-  enabled: boolean;
-  options: { key: string; label: string; phase: "b05" | "detail"; required: boolean }[];
+/* --- 구조물 정의(PLAN 48 · 마스터 템플릿 `구조물정의.json` · 판 번호 · 이력) --- */
+
+/** 지난 판 한 줄 */
+export interface DefVersion {
+  판: number;
+  저장일: string;
 }
 
-/** 판 · 표시(숨긴 것만 `{종류: {옵션: false}}`) · 종류(옵션이 있는 것과 그 옵션) */
-export interface OptionsDoc {
-  판: string;
-  표시: Record<string, Record<string, false>>;
-  종류: OptionKind[];
-}
+/** 정의 한 벌 — 읽기 = 로그인 누구나 */
+export const fetchStructureDef = (): Promise<StructDef> => call("/structure-definition");
 
-export const fetchStructureOptions = (): Promise<OptionsDoc> =>
-  call("/layers/system/structure-options"); // 읽기 = 로그인 누구나 · 고쳐 씀은 시스템 관리자
+/** 통째로 고쳐 씀(시스템 관리자만) — 읽어 간 판이 지금 판과 다르면 StaleError · 돌려받는 것 = 판 +1 정의 */
+export const saveStructureDef = (판: number, 정의: StructDef): Promise<StructDef> =>
+  call("/structure-definition", { method: "PUT", body: JSON.stringify({ 판, 정의 }) });
 
-/** 고쳐 씀 — 숨긴 것만 보냄 · 낡은 판이면 StaleError · 돌려받는 것은 새 문서 */
-export const saveStructureOptions = (판: string, 표시: OptionsDoc["표시"]): Promise<OptionsDoc> =>
-  call("/structure-options", { method: "PUT", body: JSON.stringify({ 판, 표시 }) });
+/** 지난 판 목록(`구조물정의_이력/판_N.json`) */
+export const fetchStructureDefHistory = (): Promise<DefVersion[]> =>
+  call("/structure-definition/history");
 
-/* --- 옵션 그룹(PLAN 46-2 · 마스터 템플릿 `구조물옵션그룹.json` · 시스템 관리자만) --- */
-
-/** 그룹 하나 = 프로젝트 폼의 보조 컨테이너 하나(제목 = 이름) · 옵션 0 도 됨 */
-export interface OptionGroupDef {
-  id: string;
-  이름: string;
-  옵션: string[];
-}
-
-/** 판 · 그룹(`{종류: 그룹[]}`) · 종류(레지스트리 전부 — 옵션 없는 종류도) */
-export interface GroupsDoc {
-  판: string;
-  그룹: Record<string, OptionGroupDef[]>;
-  종류: OptionKind[];
-}
-
-export const fetchStructureOptionGroups = (): Promise<GroupsDoc> =>
-  call("/structure-option-groups");
-
-/** 고쳐 씀 — 낡은 판이면 StaleError · 돌려받는 것은 새 문서 */
-export const saveStructureOptionGroups = (
-  판: string,
-  그룹: GroupsDoc["그룹"],
-): Promise<GroupsDoc> =>
-  call("/structure-option-groups", { method: "PUT", body: JSON.stringify({ 판, 그룹 }) });
+export const fetchStructureDefAt = (판: number): Promise<StructDef> =>
+  call(`/structure-definition/history/${판}`);
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Def.ts b/M02_MasterTemplete/StructOptions/M02_SO_Def.ts
new file mode 100644
index 000000000..26899fdc1
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Def.ts
@@ -0,0 +1,339 @@
+/* =============================================================================
+ * M02_SO_Def.ts
+ * 구조물 정의 편집 화면(PLAN 48-2 · 메인 칸) — 왼쪽 구조물군 · 종류 목록(이름 바꿈 · 순서 · 안 씀) ·
+ * 오른쪽 고른 종류(이름 · 안 씀 · 기준 측점 표시 · 옵션 · 배치 격자 · 그룹 · 규칙) ·
+ * 아래 [저장](판 +1 · 시스템 관리자만) · 지난 판 목록(누르면 그 판을 읽기만으로 봄).
+ * 다른 역할은 읽기만. 고칠 사본은 저장 전까지 서버에 안 감 · 정본 = `구조물정의.json`(48-1).
+ * ========================================================================== */
+
+import { createButton, createTag, el, showToast } from "@ui/ui_template_elements";
+import { StaleError } from "../M02_MasterTemplete_Api_Fetch";
+import {
+  fetchStructureDef,
+  fetchStructureDefAt,
+  fetchStructureDefHistory,
+  saveStructureDef,
+  type DefVersion,
+} from "./M02_SO_Api";
+import { buildLayoutBlock } from "./M02_SO_Def_Layout";
+import {
+  baseShown,
+  clone,
+  problems,
+  stepFamily,
+  stepType,
+  type StructDef,
+} from "./M02_SO_Def_Model";
+import { buildOptionsBlock } from "./M02_SO_Def_Options";
+import { buildRulesBlock } from "./M02_SO_Def_Rules";
+import { checkBox, textBox } from "./M02_SO_Def_Ui";
+import { buildGroupBlock } from "./M02_SO_Groups";
+import { to } from "./M02_SO_Text";
+
+export interface DefScreenOptions {
+  /** 시스템 관리자 — 아니면 읽기만 */
+  isAdmin: boolean;
+  /** 메인 칸에 화면을 띄움 — 고침 표시 손잡이를 돌려받음 */
+  show: (label: string, node: HTMLElement) => (dirty: boolean) => void;
+}
+
+const why = (error: unknown): string => (error instanceof Error ? error.message : "");
+
+/** 빈 묶음 걷어냄 — 그리기 중 만든 빈 그룹 목록 · 배치 · 종류 덧칸 */
+function tidy(def: StructDef): StructDef {
+  const out = clone(def);
+  for (const part of [out.그룹, out.배치, out.종류, out.표시] as Record<string, unknown>[])
+    for (const [k, v] of Object.entries(part))
+      if (Array.isArray(v) ? !v.length : !Object.keys(v as object).length) delete part[k];
+  return out;
+}
+
+/** 작은 단추 */
+function smallButton(
+  label: string,
+  run: () => void,
+  off = false,
+  variant: "ghost" | "danger" = "ghost",
+): HTMLButtonElement {
+  const b = createButton({ label, variant, size: "sm" });
+  b.disabled = off;
+  b.addEventListener("click", run);
+  return b;
+}
+
+/** 화면을 받아 띄움 — 못 받으면 알림만 · 띄웠으면 참 */
+export async function openDefScreen(opt: DefScreenOptions): Promise<boolean> {
+  let def: StructDef;
+  try {
+    def = await fetchStructureDef();
+  } catch (error) {
+    showToast(to("Load_Failed", why(error)), "error");
+    return false;
+  }
+  drawDef(def, opt);
+  return true;
+}
+
+function drawDef(first: StructDef, opt: DefScreenOptions): void {
+  /** 지금 판(서버) · 고칠 사본 · 보는 지난 판(있으면 읽기만) */
+  let base = first;
+  let work = clone(first);
+  let past: StructDef | null = null;
+  let dirty = false;
+  let current: string | null = null;
+  const open = new Set<string>(); // 선택지를 펼친 옵션
+  let versions: DefVersion[] | null = null;
+
+  const shown = (): StructDef => past ?? work;
+  const canEdit = (): boolean => opt.isAdmin && !past;
+  const kindList = el("div", { className: "m02-opts__kinds", attrs: { "data-sod-kinds": "" } });
+  const detail = el("div", { className: "m02-opts__list", attrs: { "data-sod-detail": "" } });
+  const banner = el("div", { className: "m02-sod__banner", attrs: { "data-sod-banner": "" } });
+  const issues = el("div", { className: "m02-sod__issues", attrs: { "data-sod-issues": "" } });
+  const historyBox = el("div", {
+    className: "m02-sod__history",
+    attrs: { "data-sod-history": "" },
+  });
+
+  const changed = (): void => {
+    dirty = true;
+    sync();
+    paint();
+  };
+
+  const paintKinds = (): void => {
+    const d = shown();
+    const edit = canEdit();
+    const parts: HTMLElement[] = [];
+    const families = Object.keys(d.구조물군);
+    families.forEach((g, gi) => {
+      parts.push(
+        el("div", {
+          className: "m02-sod__family",
+          attrs: { "data-sod-family": g },
+          children: [
+            textBox(d.구조물군[g], (v) => (d.구조물군[g] = v), changed, {
+              edit,
+              attr: "data-sod-family-name",
+            }),
+            ...(edit
+              ? [
+                  smallButton(to("GroupUp"), () => stepFamily(d, g, -1) && changed(), gi === 0),
+                  smallButton(
+                    to("GroupDown"),
+                    () => stepFamily(d, g, 1) && changed(),
+                    gi === families.length - 1,
+                  ),
+                ]
+              : []),
+          ],
+        }),
+      );
+      const kinds = d.types.filter((t) => t.group === g);
+      kinds.forEach((t, ti) => {
+        const off = t.enabled === false;
+        const groups = d.그룹[t.type_id]?.length ?? 0;
+        const b = el("button", {
+          className: `m02-opts__kind${t.type_id === current ? " is-active" : ""}${off ? " is-off" : ""}`,
+          attrs: { type: "button", "data-sod-kind": t.type_id },
+          children: [
+            el("span", { text: t.name }),
+            ...(groups ? [createTag(to("GroupTag", String(groups)), "accent")] : []),
+            ...(off ? [createTag(to("Off"), "neutral")] : []),
+          ],
+        });
+        b.addEventListener("click", () => {
+          current = t.type_id;
+          paint();
+        });
+        parts.push(
+          el("div", {
+            className: "m02-sod__kindrow",
+            children: [
+              b,
+              ...(edit
+                ? [
+                    smallButton(
+                      to("GroupUp"),
+                      () => stepType(d, t.type_id, -1) && changed(),
+                      ti === 0,
+                    ),
+                    smallButton(
+                      to("GroupDown"),
+                      () => stepType(d, t.type_id, 1) && changed(),
+                      ti === kinds.length - 1,
+                    ),
+                  ]
+                : []),
+            ],
+          }),
+        );
+      });
+    });
+    kindList.replaceChildren(...parts);
+  };
+
+  const paintDetail = (): void => {
+    const d = shown();
+    const type = d.types.find((t) => t.type_id === current);
+    if (!type) {
+      detail.replaceChildren(el("p", { className: "m02-side__empty", text: to("Pick") }));
+      return;
+    }
+    const edit = canEdit();
+    const extra = (): NonNullable<StructDef["종류"][string]> => (d.종류[type.type_id] ??= {});
+    detail.replaceChildren(
+      el("div", {
+        className: "m02-sod__kindhead",
+        children: [
+          textBox(type.name, (v) => (type.name = v), changed, {
+            edit,
+            attr: "data-sod-kind-name",
+            cls: "m02-sod__name",
+          }),
+          el("small", { className: "m02-opts__key", text: type.type_id }),
+          checkBox(to("Unused"), type.enabled === false, (v) => ((type.enabled = !v), changed()), {
+            edit,
+            attr: "data-sod-kind-off",
+          }),
+          checkBox(
+            to("BaseStationShow"),
+            baseShown(d, type.type_id),
+            (v) => {
+              if (v) delete extra().기준측점;
+              else extra().기준측점 = false;
+              changed();
+            },
+            { edit, attr: "data-sod-base" },
+          ),
+          ...(d.종류[type.type_id]?.동작 ?? []).map((a) => {
+            const tag = createTag(a, "neutral");
+            tag.title = d.동작[a] ?? "";
+            return tag;
+          }),
+        ],
+      }),
+      buildOptionsBlock({ def: d, type, edit, open, changed }),
+      buildLayoutBlock({ def: d, type, edit, changed }),
+      buildGroupBlock({ list: (d.그룹[type.type_id] ??= []), edit, changed }),
+      buildRulesBlock({ def: d, type, edit, changed }),
+    );
+  };
+
+  const paintFoot = (): void => {
+    banner.replaceChildren(
+      ...(past
+        ? [
+            el("span", { text: to("PastView", String(past.판)) }),
+            smallButton(to("PastBack"), () => ((past = null), paint(), paintHistory())),
+          ]
+        : [
+            el("span", { text: to("Version", String(base.판)) }),
+            ...(opt.isAdmin ? [] : [createTag(to("ReadOnly"), "neutral")]),
+          ]),
+    );
+    banner.classList.toggle("is-past", !!past);
+    const list = past ? [] : problems(work);
+    issues.replaceChildren(...list.map((t) => el("p", { className: "m02-sod__bad", text: t })));
+    save.disabled = !opt.isAdmin || !!past || !dirty || list.length > 0;
+  };
+
+  const paint = (): void => {
+    paintKinds();
+    paintDetail();
+    paintFoot();
+  };
+
+  const reload = async (): Promise<void> => {
+    try {
+      base = await fetchStructureDef();
+      work = clone(base);
+      dirty = false;
+      sync();
+    } catch (again) {
+      showToast(to("Load_Failed", why(again)), "error");
+    }
+  };
+
+  const save = createButton({ label: to("Save"), variant: "filled" });
+  save.setAttribute("data-sod-save", "");
+  save.addEventListener("click", async () => {
+    if (problems(work).length) return;
+    save.disabled = true; // 연달아 눌러도 한 번만
+    try {
+      base = await saveStructureDef(base.판, tidy(work));
+      work = clone(base);
+      dirty = false;
+      versions = null;
+      sync();
+      showToast(to("SavedVersion", String(base.판)), "success");
+    } catch (error) {
+      if (error instanceof StaleError) {
+        showToast(to("Stale"), "error");
+        await reload();
+      } else showToast(to("Failed", why(error)), "error");
+    } finally {
+      paint();
+      paintHistory();
+    }
+  });
+
+  /** 지난 판 목록 — 펼칠 때 받음 · 누르면 그 판을 읽기만으로 */
+  const paintHistory = (): void => {
+    if (!versions) return historyBox.replaceChildren();
+    historyBox.replaceChildren(
+      ...(versions.length
+        ? versions.map((v) => {
+            const b = createButton({
+              label: to("PastItem", `${v.판} · ${v.저장일}`),
+              variant: past?.판 === v.판 ? "filled" : "ghost",
+              size: "sm",
+            });
+            b.setAttribute("data-sod-past", String(v.판));
+            b.addEventListener("click", async () => {
+              try {
+                past = await fetchStructureDefAt(v.판);
+              } catch (error) {
+                return showToast(to("Load_Failed", why(error)), "error");
+              }
+              paint();
+              paintHistory();
+            });
+            return b;
+          })
+        : [el("p", { className: "m02-side__empty", text: to("PastNone") })]),
+    );
+  };
+  const history = createButton({ label: to("PastList"), variant: "ghost" });
+  history.setAttribute("data-sod-history-toggle", "");
+  history.addEventListener("click", async () => {
+    if (versions) {
+      versions = null;
+      return paintHistory();
+    }
+    try {
+      versions = (await fetchStructureDefHistory()).sort((a, b) => b.판 - a.판);
+    } catch (error) {
+      return showToast(to("Load_Failed", why(error)), "error");
+    }
+    paintHistory();
+  });
+
+  const node = el("div", {
+    className: "m02-opts m02-sod",
+    children: [
+      el("p", { className: "m02-side__empty", text: to("DefNote") }),
+      banner,
+      el("div", { className: "m02-opts__panes", children: [kindList, detail] }),
+      issues,
+      el("div", {
+        className: "m02-side__row",
+        children: [...(opt.isAdmin ? [save] : []), history],
+      }),
+      historyBox,
+    ],
+  });
+  const setDirty = opt.show(to("Screen"), node);
+  const sync = (): void => setDirty(dirty);
+  paint();
+}
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Def_Layout.ts b/M02_MasterTemplete/StructOptions/M02_SO_Def_Layout.ts
new file mode 100644
index 000000000..d6e4338e0
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Def_Layout.ts
@@ -0,0 +1,120 @@
+/* =============================================================================
+ * M02_SO_Def_Layout.ts
+ * 구조물 정의 편집 화면(PLAN 48-2) — 고른 종류의 **배치 격자**(B05 · B06 좌측 구조물 칸 = 두 칸)
+ * 옵션마다 줄 · 칸 · 너비 + 미리보기(기준 측점은 맨 위 한 줄 · 겹치면 빨강).
+ * 자리를 안 정한 옵션은 차례대로 빈 칸을 채움 · 숫자를 고치면 그 옵션 자리만 정의 `배치` 에 남음.
+ * ========================================================================== */
+
+import { el } from "@ui/ui_template_elements";
+import {
+  baseShown,
+  GRID_COLS,
+  live,
+  overlaps,
+  placeAll,
+  type Spot,
+  type StructDef,
+  type TypeDef,
+} from "./M02_SO_Def_Model";
+import { head, numberBox } from "./M02_SO_Def_Ui";
+import { to } from "./M02_SO_Text";
+
+export interface LayoutBlockOptions {
+  def: StructDef;
+  type: TypeDef;
+  edit: boolean;
+  changed: () => void;
+}
+
+const ROW_MAX = 60;
+
+/** 미리보기 — 두 칸 격자 · 옵션마다 상자 */
+function preview(def: StructDef, type: TypeDef, cells: Map<string, Spot>): HTMLElement {
+  const bad = new Set(overlaps(cells));
+  const base = baseShown(def, type.type_id);
+  const offset = base ? 1 : 0;
+  const boxes: HTMLElement[] = [];
+  if (base)
+    boxes.push(
+      el("div", {
+        className: "m02-sod__cell is-base",
+        text: to("BaseStation"),
+        attrs: { style: `grid-row: 1; grid-column: 1 / span ${GRID_COLS}` },
+      }),
+    );
+  for (const o of live(type.options)) {
+    const c = cells.get(o.key)!;
+    boxes.push(
+      el("div", {
+        className: `m02-sod__cell${bad.has(o.key) ? " is-bad" : ""}`,
+        text: o.label,
+        attrs: {
+          "data-sod-cell": o.key,
+          title: o.label,
+          style: `grid-row: ${c.줄 + offset}; grid-column: ${c.칸} / span ${c.너비}`,
+        },
+      }),
+    );
+  }
+  return el("div", {
+    className: "m02-sod__grid",
+    attrs: {
+      "data-sod-preview": "",
+      style: `grid-template-columns: repeat(${GRID_COLS}, minmax(0, 1fr))`,
+    },
+    children: boxes,
+  });
+}
+
+export function buildLayoutBlock(opt: LayoutBlockOptions): HTMLElement {
+  const { def, type, edit, changed } = opt;
+  const cells = placeAll(type.options, def.배치[type.type_id]);
+  const rows = live(type.options).map((o) => {
+    const c = cells.get(o.key)!;
+    const fix = (patch: Partial<Spot>): void => {
+      (def.배치[type.type_id] ??= {})[o.key] = { ...c, ...patch };
+      changed();
+    };
+    return el("div", {
+      className: "m02-sod__place",
+      attrs: { "data-sod-place-row": o.key },
+      children: [
+        el("span", { className: "m02-sod__placename", text: o.label }),
+        el("small", { text: to("GridRow") }),
+        numberBox(c.줄, (n) => fix({ 줄: n }), {
+          edit,
+          min: 1,
+          max: ROW_MAX,
+          attr: "data-sod-row",
+        }),
+        el("small", { text: to("GridCol") }),
+        numberBox(c.칸, (n) => fix({ 칸: n }), {
+          edit,
+          min: 1,
+          max: GRID_COLS,
+          attr: "data-sod-col",
+        }),
+        el("small", { text: to("GridWidth") }),
+        numberBox(c.너비, (n) => fix({ 너비: n }), {
+          edit,
+          min: 1,
+          max: GRID_COLS,
+          attr: "data-sod-width",
+        }),
+      ],
+    });
+  });
+  return el("div", {
+    className: "m02-sod__block",
+    children: [
+      ...head(to("LayoutHead"), to("LayoutNote")),
+      el("div", {
+        className: "m02-sod__layout",
+        children: [
+          el("div", { className: "m02-sod__places", children: rows }),
+          preview(def, type, cells),
+        ],
+      }),
+    ],
+  });
+}
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Def_Model.ts b/M02_MasterTemplete/StructOptions/M02_SO_Def_Model.ts
new file mode 100644
index 000000000..d45d9511b
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Def_Model.ts
@@ -0,0 +1,268 @@
+/* =============================================================================
+ * M02_SO_Def_Model.ts
+ * 구조물 정의 편집 화면(PLAN 48-2)의 자료 꼴 · 순수 손질 함수 — 화면 그리기 없음.
+ * 정본 = 마스터 템플릿 `구조물정의.json`(48-1 · 틀 `docs/raw/M02_구조물옵션정의/정의_틀.md`).
+ * 키는 만들 때 자동 · 안 바뀜 · 이름 자유 · 지움 = 「안 씀」(`enabled: false`).
+ * 선택지는 글 그대로가 값 — 이름을 바꾸면 이 정의 안의 기본값 · 규칙도 같이 바꿈.
+ * ========================================================================== */
+
+export type OptionForm = "select" | "number" | "text" | "bool";
+
+export interface Spot {
+  줄: number;
+  칸: number;
+  너비: number;
+}
+
+export interface OptionDef {
+  key: string;
+  label: string;
+  input: OptionForm;
+  choices?: string[];
+  unit?: string | null;
+  default?: unknown;
+  enabled?: boolean;
+  phase?: "b05" | "detail";
+  [more: string]: unknown;
+}
+
+export interface TypeDef {
+  type_id: string;
+  group: string;
+  name: string;
+  options: OptionDef[];
+  enabled?: boolean;
+  [more: string]: unknown;
+}
+
+export type ShapeKey = "길이" | "높이" | "전" | "후";
+export const SHAPE_KEYS: readonly ShapeKey[] = ["길이", "높이", "전", "후"];
+
+export interface GroupDef {
+  id: string;
+  이름: string;
+  옵션: string[];
+  형상?: Partial<Record<ShapeKey, { 받기: boolean; 뜻: string }>>;
+}
+
+/** 만약 상위 옵션 = 값들 중 하나 → 하위 옵션의 선택지 · 보이기 · 기본값(하나 이상) */
+export interface RuleDef {
+  종류: string;
+  만약: { 옵션: string; 값들: string[] };
+  그러면: { 옵션: string; 선택지?: string[]; 보이기?: boolean; 기본값?: unknown };
+}
+
+export interface StructDef {
+  판: number;
+  구조물군: Record<string, string>;
+  동작: Record<string, string>;
+  types: TypeDef[];
+  종류: Record<string, { 기준측점?: boolean; 동작?: string[] }>;
+  표시: Record<string, Record<string, false>>;
+  그룹: Record<string, GroupDef[]>;
+  배치: Record<string, Record<string, Spot>>;
+  규칙: RuleDef[];
+  [more: string]: unknown;
+}
+
+export const NAME_MAX = 40;
+/** B05 · B06 좌측 구조물 칸 = 두 칸 격자 */
+export const GRID_COLS = 2;
+
+/** 깊은 사본 — 고칠 사본을 서버 문서와 떼어 놓음 */
+export const clone = <T>(value: T): T => structuredClone(value);
+
+/** 새 키 — 머리글 + 영문 소문자 · 숫자 6자 · 이미 있는 키와 안 겹침 */
+export function newKey(prefix: string, taken: Iterable<string>): string {
+  const used = new Set(taken);
+  for (;;) {
+    const key = `${prefix}${Math.random().toString(36).slice(2, 8)}`;
+    if (key.length > prefix.length + 3 && !used.has(key)) return key;
+  }
+}
+
+/** 목록 안에서 한 칸 옮김 — 끝이면 그대로 · 옮겼으면 참 */
+export function step<T>(list: T[], index: number, delta: number): boolean {
+  const at = index + delta;
+  if (index < 0 || at < 0 || at >= list.length) return false;
+  [list[index], list[at]] = [list[at], list[index]];
+  return true;
+}
+
+/** 쓰는 것만 — 「안 씀」(enabled 거짓) 뺌 */
+export const live = <T extends { enabled?: boolean }>(list: readonly T[]): T[] =>
+  list.filter((x) => x.enabled !== false);
+
+/** 기준 측점 칸 보이기 — 없으면 보임 */
+export const baseShown = (def: StructDef, typeId: string): boolean =>
+  def.종류[typeId]?.기준측점 !== false;
+
+/** 이름 검사 — 1~40자 · 같은 목록 안에서 안 겹침 · 틀린 이름들 */
+export function badNames(names: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const bad: string[] = [];
+  for (const raw of names) {
+    const name = raw.trim();
+    if (!name || name.length > NAME_MAX || seen.has(name)) bad.push(name || "(빈 이름)");
+    seen.add(name);
+  }
+  return bad;
+}
+
+/** 구조물군 순서 바꿈 — `{키: 이름}` 묶음의 키 차례 */
+export function stepFamily(def: StructDef, key: string, delta: number): boolean {
+  const entries = Object.entries(def.구조물군);
+  if (
+    !step(
+      entries,
+      entries.findIndex(([k]) => k === key),
+      delta,
+    )
+  )
+    return false;
+  def.구조물군 = Object.fromEntries(entries);
+  return true;
+}
+
+/** 종류 순서 바꿈 — 같은 군 안 앞뒤 종류와 `types` 자리를 바꿈 */
+export function stepType(def: StructDef, typeId: string, delta: number): boolean {
+  const t = def.types.find((x) => x.type_id === typeId);
+  if (!t) return false;
+  const same = def.types.filter((x) => x.group === t.group);
+  const other = same[same.indexOf(t) + delta];
+  if (!other) return false;
+  const i = def.types.indexOf(t);
+  const j = def.types.indexOf(other);
+  [def.types[i], def.types[j]] = [def.types[j], def.types[i]];
+  return true;
+}
+
+/** 선택지 이름 바꿈 — 그 옵션 기본값 · 이 종류 규칙의 값들 · 선택지 · 기본값도 같이 */
+export function renameChoice(
+  def: StructDef,
+  typeId: string,
+  o: OptionDef,
+  from: string,
+  to: string,
+): void {
+  if (from === to || !o.choices) return;
+  o.choices = o.choices.map((c) => (c === from ? to : c));
+  if (o.default === from) o.default = to;
+  for (const r of def.규칙) {
+    if (r.종류 !== typeId) continue;
+    if (r.만약.옵션 === o.key) r.만약.값들 = r.만약.값들.map((v) => (v === from ? to : v));
+    if (r.그러면.옵션 === o.key) {
+      if (r.그러면.선택지) r.그러면.선택지 = r.그러면.선택지.map((v) => (v === from ? to : v));
+      if (r.그러면.기본값 === from) r.그러면.기본값 = to;
+    }
+  }
+}
+
+/** 선택지 뺌 — 기본값 · 규칙에서도 뺌(규칙 값들이 비면 그 규칙은 검사에서 걸림) */
+export function dropChoice(def: StructDef, typeId: string, o: OptionDef, value: string): void {
+  o.choices = (o.choices ?? []).filter((c) => c !== value);
+  if (o.default === value) o.default = null;
+  for (const r of def.규칙) {
+    if (r.종류 !== typeId) continue;
+    if (r.만약.옵션 === o.key) r.만약.값들 = r.만약.값들.filter((v) => v !== value);
+    if (r.그러면.옵션 === o.key) {
+      if (r.그러면.선택지) r.그러면.선택지 = r.그러면.선택지.filter((v) => v !== value);
+      if (r.그러면.기본값 === value) delete r.그러면.기본값;
+    }
+  }
+}
+
+/** 배치 격자 — 정한 자리 먼저 · 안 정한 옵션은 차례대로 빈 칸 채움 · 안 씀은 빠짐 */
+export function placeAll(
+  options: readonly OptionDef[],
+  spots: Record<string, Spot> = {},
+  cols = GRID_COLS,
+): Map<string, Spot> {
+  const out = new Map<string, Spot>();
+  const taken = new Set<string>();
+  const mark = (c: Spot): void => {
+    for (let i = 0; i < c.너비; i += 1) taken.add(`${c.줄}:${c.칸 + i}`);
+  };
+  const shown = live(options);
+  for (const o of shown) {
+    const s = spots[o.key];
+    if (!s) continue;
+    const width = Math.max(1, Math.min(cols, s.너비 || 1));
+    const cell = { 줄: s.줄, 칸: Math.min(s.칸, cols - width + 1), 너비: width };
+    out.set(o.key, cell);
+    mark(cell);
+  }
+  let row = 1;
+  let col = 1;
+  for (const o of shown) {
+    if (out.has(o.key)) continue;
+    while (taken.has(`${row}:${col}`)) {
+      col += 1;
+      if (col > cols) ((row += 1), (col = 1));
+    }
+    const cell = { 줄: row, 칸: col, 너비: 1 };
+    out.set(o.key, cell);
+    mark(cell);
+  }
+  return out;
+}
+
+/** 겹친 칸 — 두 옵션이 같은 줄 · 칸을 쓰면 그 키들 */
+export function overlaps(cells: Map<string, Spot>): string[] {
+  const owner = new Map<string, string>();
+  const bad = new Set<string>();
+  for (const [key, c] of cells)
+    for (let i = 0; i < c.너비; i += 1) {
+      const at = `${c.줄}:${c.칸 + i}`;
+      const other = owner.get(at);
+      if (other) bad.add(other).add(key);
+      else owner.set(at, key);
+    }
+  return [...bad];
+}
+
+/** 규칙 한 줄이 틀렸나 — 서버 검사(`M02_SO_Definition._rule_errors`)와 같은 뜻 */
+export function ruleBad(def: StructDef, r: RuleDef): boolean {
+  const t = def.types.find((x) => x.type_id === r.종류);
+  const src = t?.options.find((o) => o.key === r.만약.옵션);
+  const dst = t?.options.find((o) => o.key === r.그러면.옵션);
+  if (!src || !dst || src === dst || !r.만약.값들.length) return true;
+  if (src.input === "select" && !r.만약.값들.every((v) => src.choices?.includes(v))) return true;
+  const { 선택지, 보이기, 기본값 } = r.그러면;
+  if (선택지 === undefined && 보이기 === undefined && 기본값 === undefined) return true;
+  let allowed = dst.choices ?? [];
+  if (선택지 !== undefined) {
+    if (dst.input !== "select" || !선택지.every((v) => allowed.includes(v))) return true;
+    allowed = 선택지;
+  }
+  return 기본값 !== undefined && dst.input === "select" && !allowed.includes(String(기본값));
+}
+
+/** 저장 전 검사 — 화면에 띄울 까닭 글들(빈 목록 = 저장 됨) */
+export function problems(def: StructDef): string[] {
+  const out: string[] = [];
+  const fam = badNames(Object.values(def.구조물군));
+  if (fam.length) out.push(`구조물군 이름: ${fam.join(", ")}`);
+  for (const g of Object.keys(def.구조물군)) {
+    const bad = badNames(def.types.filter((t) => t.group === g).map((t) => t.name));
+    if (bad.length) out.push(`${def.구조물군[g]} 종류 이름: ${bad.join(", ")}`);
+  }
+  for (const t of def.types) {
+    const opt = badNames(t.options.map((o) => o.label));
+    if (opt.length) out.push(`${t.name} 옵션 이름: ${opt.join(", ")}`);
+    for (const o of t.options) {
+      if (o.input !== "select") continue;
+      const ch = badNames(o.choices ?? []);
+      if (ch.length) out.push(`${t.name}.${o.label} 선택지: ${ch.join(", ")}`);
+      if (!o.choices?.length) out.push(`${t.name}.${o.label} 고르기 꼴은 선택지가 있어야 함`);
+    }
+    const grp = badNames((def.그룹[t.type_id] ?? []).map((g) => g.이름));
+    if (grp.length) out.push(`${t.name} 그룹 이름: ${grp.join(", ")}`);
+    const lap = overlaps(placeAll(t.options, def.배치[t.type_id]));
+    if (lap.length) out.push(`${t.name} 배치 겹침: ${lap.join(", ")}`);
+  }
+  def.규칙.forEach((r, i) => {
+    if (ruleBad(def, r)) out.push(`규칙 ${i + 1} 이 틀림`);
+  });
+  return out;
+}
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Def_Options.ts b/M02_MasterTemplete/StructOptions/M02_SO_Def_Options.ts
new file mode 100644
index 000000000..10254bba8
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Def_Options.ts
@@ -0,0 +1,231 @@
+/* =============================================================================
+ * M02_SO_Def_Options.ts
+ * 구조물 정의 편집 화면(PLAN 48-2) — 고른 종류의 **옵션 목록**
+ * (이름 · 꼴 · 단위 · 기본값 · 보이기 · 들어갈 자리 · 안 씀 · 순서 · [옵션 더함]) +
+ * 고르기 꼴의 **선택지 목록**(이름 바꿈 · 빼기 · 순서 · [선택지 더함]).
+ * 옵션 키는 더할 때 자동 · 안 바뀜 · 선택지는 글이 곧 값(이름 바꿈 = 기본값 · 규칙도 같이) ·
+ * 저장은 화면 [저장](`M02_SO_Def.ts`).
+ * ========================================================================== */
+
+import { createButton, createTag, el, showConfirmDialog } from "@ui/ui_template_elements";
+import {
+  dropChoice,
+  newKey,
+  renameChoice,
+  type OptionDef,
+  type OptionForm,
+  type StructDef,
+  type TypeDef,
+} from "./M02_SO_Def_Model";
+import { checkBox, head, moveButtons, pickBox, textBox } from "./M02_SO_Def_Ui";
+import { buildPlaceSelect } from "./M02_SO_Groups";
+import { to } from "./M02_SO_Text";
+
+export interface OptionsBlockOptions {
+  def: StructDef;
+  type: TypeDef;
+  edit: boolean;
+  /** 선택지를 펼친 옵션 키 — 다시 그려도 남음 */
+  open: Set<string>;
+  changed: () => void;
+}
+
+const FORMS: readonly OptionForm[] = ["select", "number", "text", "bool"];
+const FORM_TEXT = {
+  select: "FormSelect",
+  number: "FormNumber",
+  text: "FormText",
+  bool: "FormBool",
+} as const;
+
+/** 기본값 칸 — 꼴에 맞춤(고르기 = 선택지 · 예/아니오 · 숫자 · 글) · 비우면 기본값 없음 */
+function defaultBox(o: OptionDef, edit: boolean, changed: () => void): HTMLElement {
+  const attr = "data-sod-default";
+  const now = o.default == null ? "" : String(o.default);
+  if (o.input === "select" || o.input === "bool") {
+    const pairs: [string, string][] =
+      o.input === "select"
+        ? (o.choices ?? []).map((c) => [c, c])
+        : [
+            ["true", to("Yes")],
+            ["false", to("No")],
+          ];
+    return pickBox(
+      [["", to("NoDefault")], ...pairs],
+      now,
+      (v) => {
+        o.default = v === "" ? null : o.input === "bool" ? v === "true" : v;
+        changed();
+      },
+      { edit, attr, cls: "m02-sod__default" },
+    );
+  }
+  return textBox(
+    now,
+    (v) => {
+      const n = Number(v);
+      o.default = v.trim() === "" ? null : o.input === "number" && Number.isFinite(n) ? n : v;
+    },
+    changed,
+    { edit, attr, cls: "m02-sod__default", place: to("NoDefault") },
+  );
+}
+
+/** 선택지 목록 — 이름(떠날 때 바꿈) · 빼기 · 순서 · [선택지 더함] */
+function choicesBlock(opt: OptionsBlockOptions, o: OptionDef): HTMLElement {
+  const { def, type, edit, changed } = opt;
+  const list = (o.choices ??= []);
+  const rows = list.map((c) => {
+    let next = c;
+    const del = createButton({ label: to("ChoiceDrop"), variant: "danger", size: "sm" });
+    del.addEventListener("click", async () => {
+      if (!(await showConfirmDialog(to("ChoiceDropAsk", c), to("ChoiceDrop")))) return;
+      dropChoice(def, type.type_id, o, c);
+      changed();
+    });
+    return el("div", {
+      className: "m02-sod__choice",
+      attrs: { "data-sod-choice": c },
+      children: [
+        textBox(
+          c,
+          (v) => (next = v.trim()),
+          () => {
+            if (next && next !== c && !list.includes(next))
+              renameChoice(def, type.type_id, o, c, next);
+            changed();
+          },
+          { edit, attr: "data-sod-choice-name" },
+        ),
+        ...moveButtons(list, c, changed, edit),
+        ...(edit ? [del] : []),
+      ],
+    });
+  });
+  const add = createButton({ label: to("ChoiceAdd"), variant: "ghost", size: "sm" });
+  add.setAttribute("data-sod-choice-add", "");
+  add.addEventListener("click", () => {
+    let n = list.length + 1;
+    while (list.includes(to("ChoiceNew", String(n)))) n += 1;
+    list.push(to("ChoiceNew", String(n)));
+    changed();
+  });
+  return el("div", {
+    className: "m02-sod__choices",
+    children: [
+      el("p", { className: "m02-side__empty", text: to("ChoiceNote") }),
+      ...(rows.length ? rows : [el("p", { className: "m02-sod__bad", text: to("ChoiceNone") })]),
+      ...(edit ? [add] : []),
+    ],
+  });
+}
+
+/** 옵션 한 줄(+ 펼친 선택지) */
+function optionRow(opt: OptionsBlockOptions, o: OptionDef): HTMLElement {
+  const { def, type, edit, open, changed } = opt;
+  const off = o.enabled === false;
+  const hidden = def.표시[type.type_id]?.[o.key] === false;
+  const form = pickBox(
+    FORMS.map((f) => [f, to(FORM_TEXT[f])] as const),
+    o.input,
+    (v) => {
+      o.input = v as OptionForm;
+      o.default = null; // 꼴이 바뀌면 옛 기본값은 뜻이 없음
+      if (o.input === "select") open.add(o.key);
+      changed();
+    },
+    { edit, attr: "data-sod-form", cls: "m02-sod__form" },
+  );
+  const choices =
+    o.input === "select"
+      ? createButton({
+          label: to("Choices", String(o.choices?.length ?? 0)),
+          variant: open.has(o.key) ? "filled" : "ghost",
+          size: "sm",
+        })
+      : null;
+  choices?.setAttribute("data-sod-choices", o.key);
+  choices?.addEventListener("click", () => {
+    if (open.has(o.key)) open.delete(o.key);
+    else open.add(o.key);
+    changed();
+  });
+  const show = checkBox(
+    to("Shown"),
+    !hidden,
+    (v) => {
+      const row = (def.표시[type.type_id] ??= {});
+      if (v) delete row[o.key];
+      else row[o.key] = false;
+      if (!Object.keys(row).length) delete def.표시[type.type_id];
+      changed();
+    },
+    { edit, attr: "data-sod-shown" },
+  );
+  const row = el("div", {
+    className: `m02-sod__option${off ? " is-off" : ""}`,
+    attrs: { "data-sod-option": o.key },
+    children: [
+      textBox(o.label, (v) => (o.label = v), changed, {
+        edit,
+        attr: "data-sod-name",
+        cls: "m02-sod__name",
+      }),
+      el("small", { className: "m02-opts__key", text: o.key }),
+      ...(o.phase === "detail" ? [createTag(to("Detail"), "accent")] : []),
+      form,
+      textBox(o.unit ?? "", (v) => (o.unit = v.trim() || null), changed, {
+        edit,
+        attr: "data-sod-unit",
+        cls: "m02-sod__unit",
+        place: to("Unit"),
+        max: 12,
+      }),
+      defaultBox(o, edit, changed),
+      show,
+      buildPlaceSelect((def.그룹[type.type_id] ??= []), o.key, edit, changed),
+      checkBox(to("Unused"), off, (v) => ((o.enabled = !v), changed()), {
+        edit,
+        attr: "data-sod-off",
+      }),
+      ...moveButtons(type.options, o, changed, edit),
+      ...(choices ? [choices] : []),
+    ],
+  });
+  return o.input === "select" && open.has(o.key)
+    ? el("div", { className: "m02-sod__optwrap", children: [row, choicesBlock(opt, o)] })
+    : row;
+}
+
+/** 옵션 목록 칸 — 제목 · 안내 · 옵션 줄 · [옵션 더함] */
+export function buildOptionsBlock(opt: OptionsBlockOptions): HTMLElement {
+  const { type, edit, changed } = opt;
+  const add = createButton({ label: to("OptionAdd"), variant: "ghost", size: "sm" });
+  add.setAttribute("data-sod-option-add", "");
+  add.addEventListener("click", () => {
+    const n = type.options.length + 1;
+    const o: OptionDef = {
+      key: newKey(
+        "opt_",
+        type.options.map((x) => x.key),
+      ),
+      label: to("OptionNew", String(n)),
+      input: "select",
+      choices: [to("ChoiceNew", "1")],
+      default: null,
+    };
+    type.options.push(o);
+    opt.open.add(o.key);
+    changed();
+  });
+  return el("div", {
+    className: "m02-sod__block",
+    children: [
+      ...head(to("OptionHead"), to("OptionNote")),
+      ...(type.options.length
+        ? type.options.map((o) => optionRow(opt, o))
+        : [el("p", { className: "m02-side__empty", text: to("NoOptionKind") })]),
+      ...(edit ? [el("div", { className: "m02-side__row", children: [add] })] : []),
+    ],
+  });
+}
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Def_Rules.ts b/M02_MasterTemplete/StructOptions/M02_SO_Def_Rules.ts
new file mode 100644
index 000000000..bca6186e0
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Def_Rules.ts
@@ -0,0 +1,234 @@
+/* =============================================================================
+ * M02_SO_Def_Rules.ts
+ * 구조물 정의 편집 화면(PLAN 48-2) — 고른 종류의 **규칙 표**(정의 `규칙` 중 그 종류 것만)
+ * 「만약 상위 옵션 = 값들 중 하나 → 하위 옵션의 선택지 · 보이기 · 기본값」 한 줄씩 · [규칙 더함] · 지우기.
+ * 「그대로」 칸은 정의에 안 남김 · 셋 다 그대로면 틀린 줄(빨강) · 적용은 B05 · B06(48-4).
+ * ========================================================================== */
+
+import { createButton, el } from "@ui/ui_template_elements";
+import {
+  live,
+  ruleBad,
+  type OptionDef,
+  type RuleDef,
+  type StructDef,
+  type TypeDef,
+} from "./M02_SO_Def_Model";
+import { head, pickBox } from "./M02_SO_Def_Ui";
+import { to } from "./M02_SO_Text";
+
+export interface RulesBlockOptions {
+  def: StructDef;
+  type: TypeDef;
+  edit: boolean;
+  changed: () => void;
+}
+
+const bool = (): [string, string][] => [
+  ["true", to("Yes")],
+  ["false", to("No")],
+];
+
+/** 여럿 고르기 — 체크한 것만 차례대로 */
+function multiPick(
+  all: readonly string[],
+  picked: readonly string[],
+  set: (v: string[]) => void,
+  edit: boolean,
+  attr: string,
+): HTMLElement {
+  const on = new Set(picked);
+  return el("div", {
+    className: "m02-sod__rulechoices",
+    attrs: { [attr]: "" },
+    children: all.map((c) => {
+      const box = el("input", { attrs: { type: "checkbox", value: c } }) as HTMLInputElement;
+      box.checked = on.has(c);
+      box.disabled = !edit;
+      box.addEventListener("change", () => {
+        if (box.checked) on.add(c);
+        else on.delete(c);
+        set(all.filter((x) => on.has(x)));
+      });
+      return el("label", { className: "m02-sod__check", children: [box, el("span", { text: c })] });
+    }),
+  });
+}
+
+/** 글 칸 — 쉼표로 여럿 */
+function listText(
+  value: string[],
+  set: (v: string[]) => void,
+  edit: boolean,
+  attr: string,
+): HTMLElement {
+  const box = el("input", {
+    className: "ui-input ui-input--sm m02-sod__rulepick",
+    attrs: { type: "text", [attr]: "", placeholder: to("RuleValues") },
+  }) as HTMLInputElement;
+  box.value = value.join(", ");
+  box.disabled = !edit;
+  box.addEventListener("change", () =>
+    set(
+      box.value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean),
+    ),
+  );
+  return box;
+}
+
+/** 만약 값들 — 고르기 = 선택지 체크 · 예/아니오 = 하나 · 그 밖 = 쉼표 글 */
+function whenValues(
+  src: OptionDef | undefined,
+  rule: RuleDef,
+  edit: boolean,
+  changed: () => void,
+): HTMLElement {
+  const set = (v: string[]): void => ((rule.만약.값들 = v), changed());
+  if (src?.input === "select")
+    return multiPick(src.choices ?? [], rule.만약.값들, set, edit, "data-sod-rule-value");
+  if (src?.input === "bool")
+    return pickBox(bool(), rule.만약.값들[0] ?? "true", (v) => set([v]), {
+      edit,
+      attr: "data-sod-rule-value",
+      cls: "m02-sod__rulepick",
+    });
+  return listText(rule.만약.값들, set, edit, "data-sod-rule-value");
+}
+
+/** 그러면 기본값 — 「그대로」 + (좁힌) 선택지 · 예/아니오 · 글 */
+function thenDefault(
+  dst: OptionDef | undefined,
+  rule: RuleDef,
+  edit: boolean,
+  changed: () => void,
+): HTMLElement {
+  const then = rule.그러면;
+  const now = then.기본값 === undefined ? "" : String(then.기본값);
+  const set = (v: string): void => {
+    if (v === "") delete then.기본값;
+    else
+      then.기본값 =
+        dst?.input === "bool"
+          ? v === "true"
+          : dst?.input === "number" && Number.isFinite(Number(v))
+            ? Number(v)
+            : v;
+    changed();
+  };
+  const pairs: [string, string][] =
+    dst?.input === "select"
+      ? (then.선택지 ?? dst.choices ?? []).map((c) => [c, c])
+      : dst?.input === "bool"
+        ? bool()
+        : [];
+  if (pairs.length || (dst?.input !== "number" && dst?.input !== "text"))
+    return pickBox([["", to("KeepDefault")], ...pairs], now, set, {
+      edit,
+      attr: "data-sod-rule-default",
+      cls: "m02-sod__rulepick",
+    });
+  const box = el("input", {
+    className: "ui-input ui-input--sm m02-sod__rulepick",
+    attrs: { type: "text", "data-sod-rule-default": "", placeholder: to("KeepDefault") },
+  }) as HTMLInputElement;
+  box.value = now;
+  box.disabled = !edit;
+  box.addEventListener("change", () => set(box.value.trim()));
+  return box;
+}
+
+function ruleRow(opt: RulesBlockOptions, rule: RuleDef, index: number): HTMLElement {
+  const { def, type, edit, changed } = opt;
+  const byKey = new Map(type.options.map((o) => [o.key, o]));
+  const names = live(type.options).map((o) => [o.key, o.label] as [string, string]);
+  const src = byKey.get(rule.만약.옵션);
+  const dst = byKey.get(rule.그러면.옵션);
+  const then = rule.그러면;
+  const del = createButton({ label: to("GroupDel"), variant: "danger", size: "sm" });
+  del.addEventListener("click", () => (def.규칙.splice(def.규칙.indexOf(rule), 1), changed()));
+  const show = then.보이기 === undefined ? "" : then.보이기 ? "1" : "0";
+  return el("div", {
+    className: `m02-sod__rule${ruleBad(def, rule) ? " is-bad" : ""}`,
+    attrs: { "data-sod-rule": String(index) },
+    children: [
+      el("small", { text: to("RuleIf") }),
+      pickBox(names, rule.만약.옵션, (v) => ((rule.만약 = { 옵션: v, 값들: [] }), changed()), {
+        edit,
+        attr: "data-sod-rule-top",
+        cls: "m02-sod__rulepick",
+      }),
+      el("small", { text: "=" }),
+      whenValues(src, rule, edit, changed),
+      el("small", { text: to("RuleThen") }),
+      pickBox(names, then.옵션, (v) => ((rule.그러면 = { 옵션: v }), changed()), {
+        edit,
+        attr: "data-sod-rule-target",
+        cls: "m02-sod__rulepick",
+      }),
+      ...(dst?.input === "select"
+        ? [
+            el("small", { text: to("RuleChoices") }),
+            multiPick(
+              dst.choices ?? [],
+              then.선택지 ?? [],
+              (v) => {
+                if (v.length) then.선택지 = v;
+                else delete then.선택지;
+                changed();
+              },
+              edit,
+              "data-sod-rule-choice",
+            ),
+          ]
+        : []),
+      pickBox(
+        [
+          ["", to("Keep")],
+          ["1", to("Show")],
+          ["0", to("Hide")],
+        ],
+        show,
+        (v) => {
+          if (v === "") delete then.보이기;
+          else then.보이기 = v === "1";
+          changed();
+        },
+        { edit, attr: "data-sod-rule-show", cls: "m02-sod__rulepick" },
+      ),
+      thenDefault(dst, rule, edit, changed),
+      ...(edit ? [del] : []),
+    ],
+  });
+}
+
+export function buildRulesBlock(opt: RulesBlockOptions): HTMLElement {
+  const { def, type, edit, changed } = opt;
+  const mine = def.규칙.filter((r) => r.종류 === type.type_id);
+  const opts = live(type.options);
+  const add = createButton({ label: to("RuleAdd"), variant: "ghost", size: "sm" });
+  add.setAttribute("data-sod-rule-add", "");
+  add.disabled = opts.length < 2;
+  add.addEventListener("click", () => {
+    const top = opts.find((o) => o.input === "select") ?? opts[0];
+    const target = opts.find((o) => o.key !== top.key)!;
+    def.규칙.push({
+      종류: type.type_id,
+      만약: { 옵션: top.key, 값들: top.choices?.length ? [top.choices[0]] : [] },
+      그러면: { 옵션: target.key, 보이기: false },
+    });
+    changed();
+  });
+  return el("div", {
+    className: "m02-sod__block",
+    children: [
+      ...head(to("RuleHead"), to("RuleNote")),
+      ...(mine.length
+        ? mine.map((r) => ruleRow(opt, r, def.규칙.indexOf(r)))
+        : [el("p", { className: "m02-side__empty", text: to("RuleNone") })]),
+      ...(edit ? [el("div", { className: "m02-side__row", children: [add] })] : []),
+    ],
+  });
+}
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Def_Ui.ts b/M02_MasterTemplete/StructOptions/M02_SO_Def_Ui.ts
new file mode 100644
index 000000000..837c344bd
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Def_Ui.ts
@@ -0,0 +1,121 @@
+/* =============================================================================
+ * M02_SO_Def_Ui.ts
+ * 구조물 정의 편집 화면(PLAN 48-2)의 작은 입력 부품 — 글 · 숫자 · 체크 · 고르기 · 위아래 단추.
+ * 값은 받은 손잡이로 사본만 고침 · 글은 칸을 떠날 때(`change`) 다시 그림(초점 안 끊김).
+ * ========================================================================== */
+
+import { createButton, el } from "@ui/ui_template_elements";
+import { step } from "./M02_SO_Def_Model";
+import { to } from "./M02_SO_Text";
+
+/** 글 칸 — 글자마다 `set` · 떠날 때 `done` */
+export function textBox(
+  value: string,
+  set: (v: string) => void,
+  done: () => void,
+  opt: { edit: boolean; attr?: string; place?: string; cls?: string; max?: number },
+): HTMLInputElement {
+  const box = el("input", {
+    className: `ui-input ui-input--sm ${opt.cls ?? ""}`,
+    attrs: {
+      type: "text",
+      maxlength: String(opt.max ?? 40),
+      ...(opt.attr ? { [opt.attr]: "" } : {}),
+    },
+  }) as HTMLInputElement;
+  box.value = value;
+  box.placeholder = opt.place ?? "";
+  box.disabled = !opt.edit;
+  box.addEventListener("input", () => {
+    set(box.value);
+    box.classList.toggle("is-invalid", !box.value.trim() && !opt.place);
+  });
+  box.addEventListener("change", done);
+  return box;
+}
+
+/** 숫자 칸 — 범위 밖 · 빈 칸은 무름 */
+export function numberBox(
+  value: number,
+  set: (v: number) => void,
+  opt: { edit: boolean; min: number; max: number; attr?: string },
+): HTMLInputElement {
+  const box = el("input", {
+    className: "ui-input ui-input--sm m02-sod__num",
+    attrs: {
+      type: "number",
+      min: String(opt.min),
+      max: String(opt.max),
+      ...(opt.attr ? { [opt.attr]: "" } : {}),
+    },
+  }) as HTMLInputElement;
+  box.value = String(value);
+  box.disabled = !opt.edit;
+  box.addEventListener("change", () => {
+    const n = Math.round(Number(box.value));
+    if (box.value === "" || !Number.isFinite(n) || n < opt.min || n > opt.max) {
+      box.value = String(value);
+      return;
+    }
+    set(n);
+  });
+  return box;
+}
+
+/** 체크 + 글 */
+export function checkBox(
+  label: string,
+  on: boolean,
+  set: (v: boolean) => void,
+  opt: { edit: boolean; attr?: string },
+): HTMLLabelElement {
+  const box = el("input", {
+    attrs: { type: "checkbox", ...(opt.attr ? { [opt.attr]: "" } : {}) },
+  }) as HTMLInputElement;
+  box.checked = on;
+  box.disabled = !opt.edit;
+  box.addEventListener("change", () => set(box.checked));
+  return el("label", { className: "m02-sod__check", children: [box, el("span", { text: label })] });
+}
+
+/** 고르기 — [값, 글] 짝 */
+export function pickBox(
+  pairs: readonly (readonly [string, string])[],
+  value: string,
+  set: (v: string) => void,
+  opt: { edit: boolean; attr?: string; cls?: string },
+): HTMLSelectElement {
+  const box = el("select", {
+    className: `ui-input ui-input--sm ${opt.cls ?? ""}`,
+    attrs: opt.attr ? { [opt.attr]: "" } : {},
+  }) as HTMLSelectElement;
+  box.append(...pairs.map(([v, t]) => new Option(t, v)));
+  box.value = value;
+  box.disabled = !opt.edit;
+  box.addEventListener("change", () => set(box.value));
+  return box;
+}
+
+/** 위로 · 아래로 단추 둘 — 고치는 사람만 · 옮겼으면 `changed` */
+export function moveButtons<T>(
+  list: T[],
+  item: T,
+  changed: () => void,
+  edit: boolean,
+): HTMLElement[] {
+  if (!edit) return [];
+  const index = list.indexOf(item);
+  const make = (label: string, delta: number, off: boolean): HTMLButtonElement => {
+    const b = createButton({ label, variant: "ghost", size: "sm" });
+    b.disabled = off;
+    b.addEventListener("click", () => step(list, list.indexOf(item), delta) && changed());
+    return b;
+  };
+  return [make(to("GroupUp"), -1, index <= 0), make(to("GroupDown"), 1, index >= list.length - 1)];
+}
+
+/** 절 제목 + 안내 한 줄 */
+export const head = (title: string, note?: string): HTMLElement[] => [
+  el("h4", { className: "m02-opts__group", text: title }),
+  ...(note ? [el("p", { className: "m02-side__empty", text: note })] : []),
+];
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Definition.py b/M02_MasterTemplete/StructOptions/M02_SO_Definition.py
new file mode 100644
index 000000000..439e0daf0
--- /dev/null
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Definition.py
@@ -0,0 +1,226 @@
+"""M02 구조물 정의 한 벌(PLAN 48-1) — 정본 `resources/master_template/구조물정의.json`.
+
+틀 = `docs/raw/M02_구조물옵션정의/정의_틀.md`. 읽기 = 로그인 누구나 · 쓰기 = 시스템 관리자만.
+판 = 정수 · 저장마다 +1 · 앞 판은 `구조물정의_이력/판_N.json` 으로 남김(지난 정의 값 읽기용).
+검사 = 칸 꼴 · 키 겹침 · 표시 · 그룹 · 배치 · 규칙 대상 있음 — 틀리면 422 · 낡은 판 409.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from pydantic import ValidationError
+
+from B05_Profile import B05_Profile_Structures_Schema as schema
+from common_util.common_util_json import atomic_write_json
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+
+FILE = "구조물정의.json"
+HISTORY = "구조물정의_이력"
+TOP = {"판", "schema_version", "comment", "구조물군", "동작", "types"}
+SECTIONS = {"종류": dict, "표시": dict, "그룹": dict, "배치": dict, "규칙": list}
+SPOT = ("줄", "칸", "너비")
+
+
+def read() -> dict[str, Any]:
+    return schema.load_definition()
+
+
+def history_path(version: int) -> Path:
+    return Path(schema.DEFINITION_PATH).parent / HISTORY / f"판_{version}.json"
+
+
+def history() -> list[dict[str, Any]]:
+    """지난 판 목록 `[{판, 저장일}]` — 이력 `판_N.json` · 저장일 = 파일 고친 때(분까지)."""
+    folder = history_path(1).parent
+    rows = []
+    for path in folder.glob("판_*.json") if folder.is_dir() else []:
+        number = path.stem.removeprefix("판_")
+        if number.isdigit():
+            when = datetime.fromtimestamp(path.stat().st_mtime).strftime("%Y-%m-%d %H:%M")
+            rows.append({"판": int(number), "저장일": when})
+    return sorted(rows, key=lambda r: r["판"], reverse=True)
+
+
+def read_version(version: int) -> dict[str, Any]:
+    """지난 판 한 벌(읽기만) — 없으면 404."""
+    path = history_path(version)
+    if not path.is_file():
+        raise store.StoreError(404, f"판 {version} 이력이 없음")
+    return json.loads(path.read_text("utf-8"))
+
+
+def _type_errors(doc: dict[str, Any]) -> tuple[list[str], dict[str, dict[str, Any]]]:
+    """(틀린 것 · 종류 → {옵션 키: 옵션}) — 종류 꼴 · 키 겹침 · 구조물군 있음."""
+    errors: list[str] = []
+    keys: dict[str, dict[str, Any]] = {}
+    groups = doc.get("구조물군")
+    if not isinstance(groups, dict):
+        errors.append("구조물군은 {키: 이름} 묶음이어야 함")
+        groups = {}
+    for row in doc.get("types") if isinstance(doc.get("types"), list) else []:
+        try:
+            t = schema.StructureType.model_validate(row)
+        except ValidationError as e:
+            errors.append(
+                f"종류 「{row.get('type_id') if isinstance(row, dict) else row}」 꼴 — {e}"
+            )
+            continue
+        if t.type_id in keys:
+            errors.append(f"종류 키 「{t.type_id}」 겹침")
+        if t.group not in groups:
+            errors.append(f"「{t.type_id}」 구조물군 「{t.group}」 이 구조물군에 없음")
+        opts: dict[str, Any] = {}
+        for o in t.options:
+            if o.key in opts:
+                errors.append(f"「{t.type_id}」 옵션 키 「{o.key}」 겹침")
+            if o.input == "select" and not o.choices:
+                errors.append(f"「{t.type_id}.{o.key}」 고르기 꼴은 선택지가 있어야 함")
+            opts[o.key] = o
+        keys[t.type_id] = opts
+    if not isinstance(doc.get("types"), list) or not keys:
+        errors.append("types 는 종류 목록이어야 함")
+    return errors, keys
+
+
+def _names_ok(value: Any) -> bool:
+    """구조물 명세 이름 바꿈 표 — `{컨테이너[.항목[=값]]: 빈 글 아닌 이름}`."""
+    return isinstance(value, dict) and all(
+        isinstance(k, str) and isinstance(v, str) and v.strip() for k, v in value.items()
+    )
+
+
+def _kind_errors(doc: dict[str, Any], keys: dict[str, dict[str, Any]]) -> list[str]:
+    """종류마다 덧칸 — `{기준측점: 참거짓, 동작: [동작 이름], 이름: {명세 이름 키: 이름}}`(이름 = PLAN 52)."""
+    errors: list[str] = []
+    acts = doc.get("동작") if isinstance(doc.get("동작"), dict) else {}
+    for tid, row in doc["종류"].items():
+        if tid not in keys or not isinstance(row, dict):
+            errors.append(f"종류 덧칸 「{tid}」 — 없는 종류이거나 묶음 아님")
+            continue
+        for name, value in row.items():
+            if name == "기준측점" and isinstance(value, bool):
+                continue
+            if name == "동작" and isinstance(value, list) and all(a in acts for a in value):
+                continue
+            if name == "이름" and _names_ok(value):
+                continue
+            errors.append(
+                f"종류 덧칸 「{tid}.{name}」 이 틀림(기준측점 참거짓 · 동작 = 동작 이름들 · 이름 = 글 묶음)"
+            )
+    return errors
+
+
+def _spot_errors(doc: dict[str, Any], keys: dict[str, dict[str, Any]]) -> list[str]:
+    """배치 — `{종류: {옵션 키: {줄, 칸, 너비}}}` · 1 이상 정수."""
+    errors: list[str] = []
+    for tid, row in doc["배치"].items():
+        if tid not in keys or not isinstance(row, dict):
+            errors.append(f"배치 「{tid}」 — 없는 종류이거나 묶음 아님")
+            continue
+        for key, spot in row.items():
+            ok = isinstance(spot, dict) and set(spot) <= set(SPOT)
+            ok = ok and all(type(v) is int and v >= 1 for v in spot.values())
+            if key not in keys[tid] or not ok:
+                errors.append(
+                    f"배치 「{tid}.{key}」 — 없는 옵션이거나 줄 · 칸 · 너비가 1 이상 정수 아님"
+                )
+    return errors
+
+
+def _rule_errors(doc: dict[str, Any], keys: dict[str, dict[str, Any]]) -> list[str]:
+    """규칙 — `{종류, 만약: {옵션, 값들}, 그러면: {옵션, 선택지? · 보이기? · 기본값?}}`."""
+    errors: list[str] = []
+    for i, rule in enumerate(doc["규칙"], 1):
+        where = f"규칙 {i}"
+        if not isinstance(rule, dict) or rule.get("종류") not in keys:
+            errors.append(f"{where} — 없는 종류")
+            continue
+        opts = keys[rule["종류"]]
+        when, then = rule.get("만약"), rule.get("그러면")
+        if not isinstance(when, dict) or not isinstance(then, dict):
+            errors.append(f"{where} — 만약 · 그러면은 묶음이어야 함")
+            continue
+        src, dst = opts.get(when.get("옵션")), opts.get(then.get("옵션"))
+        if src is None or dst is None or src is dst:
+            errors.append(f"{where} — 만약 · 그러면 옵션이 없거나 같음")
+            continue
+        values = when.get("값들")
+        if not isinstance(values, list) or not values:
+            errors.append(f"{where} — 값들이 비었음")
+        elif src.input == "select" and not set(map(str, values)) <= set(src.choices):
+            errors.append(f"{where} — 값들이 「{src.key}」 선택지에 없음")
+        effects = set(then) - {"옵션"}
+        if not effects or not effects <= {"선택지", "보이기", "기본값"}:
+            errors.append(f"{where} — 그러면은 선택지 · 보이기 · 기본값 중 하나 이상")
+        allowed = dst.choices
+        if "선택지" in then:
+            pick = then["선택지"]
+            if dst.input != "select" or not isinstance(pick, list) or not set(pick) <= set(allowed):
+                errors.append(f"{where} — 선택지는 「{dst.key}」 고르기 선택지 안에서만")
+            else:
+                allowed = pick
+        if "보이기" in then and not isinstance(then["보이기"], bool):
+            errors.append(f"{where} — 보이기는 참거짓")
+        if "기본값" in then and dst.input == "select" and str(then["기본값"]) not in allowed:
+            errors.append(f"{where} — 기본값이 「{dst.key}」 선택지에 없음")
+    return errors
+
+
+def check(doc: Any) -> list[str]:
+    """정의 한 벌 검사 — 틀린 것 목록(빈 목록 = 통과)."""
+    from M02_MasterTemplete.StructOptions import M02_SO_Groups as groups
+    from M02_MasterTemplete.StructOptions import M02_SO_Options as options
+
+    if not isinstance(doc, dict):
+        return ["정의는 묶음이어야 함"]
+    errors = [f"모르는 칸 「{k}」" for k in doc if k not in TOP and k not in SECTIONS]
+    errors += [
+        f"「{k}」 꼴이 틀림" for k, kind in SECTIONS.items() if not isinstance(doc.get(k), kind)
+    ]
+    if not isinstance(doc.get("동작"), dict):
+        errors.append("동작은 {이름: 뜻} 묶음이어야 함")
+    if errors:
+        return errors
+    found, keys = _type_errors(doc)
+    errors += found
+    plain = {tid: set(opts) for tid, opts in keys.items()}
+    for fn, section in ((options._clean, "표시"), (groups._clean, "그룹")):
+        try:
+            fn(doc[section], plain)
+        except store.StoreError as e:
+            errors += e.detail["errors"] if isinstance(e.detail, dict) else [str(e.detail)]
+    return errors + _kind_errors(doc, keys) + _spot_errors(doc, keys) + _rule_errors(doc, keys)
+
+
+def _commit(change: Callable[[dict[str, Any]], dict[str, Any]], version: Any) -> dict[str, Any]:
+    """판이 같을 때만 고쳐 씀 — 앞 판은 이력으로 · 새 판 = 앞 판 + 1."""
+    path = Path(schema.DEFINITION_PATH)
+    with store._LOCK:
+        current = read()
+        have = int(current.get("판", 1))
+        if str(version) != str(have):
+            raise store.StoreError(409, {"stale": [FILE], "판": have})
+        doc = {**change(current), "판": have}
+        errors = check(doc)
+        if errors:
+            raise store.StoreError(422, {"errors": errors})
+        atomic_write_json(history_path(have), current)
+        atomic_write_json(path, {**doc, "판": have + 1})
+    return read()
+
+
+def save(doc: Any, version: Any) -> dict[str, Any]:
+    """정의 통째로 고쳐 씀(시스템 관리자) — 돌려주는 것 = 새 정의."""
+    if not isinstance(doc, dict):
+        raise store.StoreError(400, "정의는 묶음이어야 함")
+    return _commit(lambda _: dict(doc), version)
+
+
+def save_sections(changes: dict[str, Any], version: Any) -> dict[str, Any]:
+    """정의 몇 칸만 고쳐 씀(옵션 보이기 · 그룹 화면)."""
+    return _commit(lambda current: {**current, **changes}, version)
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Groups.py b/M02_MasterTemplete/StructOptions/M02_SO_Groups.py
index 6a23fb62e..f103f8edc 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Groups.py
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Groups.py
@@ -1,45 +1,34 @@
 """M02 구조물 옵션 그룹 — 구조물 종류 안에 이름 붙은 묶음(PLAN 46-2).
 
-정본 = `resources/master_template/구조물옵션그룹.json` =
-    `{type_id: [{"id": "g1a2b3c", "이름": "유입구 기슭막이", "옵션": ["inlet_revet_form", …]}]}`
-— 없는 종류 = 그룹 없음(파일이 없어도 됨) · 빈 그룹(옵션 0)도 그룹.
+정본 = 구조물 정의 한 벌(`M02_SO_Definition` · PLAN 48-1)의 「그룹」 칸 =
+    `{type_id: [{"id": "g1a2b3c", "이름": "유입구 기슭막이", "옵션": [...], "형상"?: {...}}]}`
+— 없는 종류 = 그룹 없음 · 빈 그룹(옵션 0)도 그룹 · 형상 = 길이 · 높이 · 전 · 후 받기 + 뜻.
 
 그룹 하나 = 프로젝트 B05 · B06 폼의 보조 컨테이너 하나(제목 = 이름) — 그 안에서 구조물 조합
 항목 하나를 지정(구조물 기록 `group_items[그룹 id]`). 그룹에 안 넣은 옵션 = 본체 칸(`summary_item`).
 옵션 하나는 한 종류 안에서 그룹 하나에만. 시스템 공통 · 고쳐 씀은 시스템 관리자(길이 막음).
-판 = 파일 sha256 앞 16자(`store.version_of`) · 낡은 판으로 쓰면 409.
+판 = 정의 판(글) · 낡은 판으로 쓰면 409 · 저장마다 정의 판 +1 · 이력.
 """
 
 from __future__ import annotations
 
-import json
 import logging
 import re
 from typing import Any
 
-from B05_Profile.B05_Profile_Structures_Schema import load_structure_types
-from common_util.common_util_json import atomic_write_json
+from B05_Profile.B05_Profile_Structures_Schema import load_definition, load_structure_types
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 
-FILE = "구조물옵션그룹.json"
 GROUP_ID = re.compile(r"^g[0-9a-z]{1,16}$")
 NAME_MAX = 40
+SHAPE = ("길이", "높이", "전", "후")  # 그룹이 받을 형상 칸 — `{칸: {받기: 참거짓, 뜻: 글}}`
 logger = logging.getLogger(__name__)
 
 
 def _load() -> tuple[dict[str, Any], str]:
-    """(그룹 표 · 판) — 파일이 없으면 빈 표 · 판 빈 글."""
-    path = store.FOLDER / FILE
-    if not path.is_file():
-        return {}, ""
-    raw = path.read_bytes()
-    try:
-        doc = json.loads(raw)
-    except ValueError as e:
-        raise store.StoreError(500, f"{FILE} 을 못 읽음 — {e}") from e
-    if not isinstance(doc, dict):
-        raise store.StoreError(500, f"{FILE} 은 종류별 묶음이어야 함")
-    return doc, store.version_of(raw)
+    """(그룹 표 · 판) — 정의 한 벌(`M02_SO_Definition`)의 「그룹」 칸 · 판 = 정의 판 글."""
+    doc = load_definition()
+    return doc.get("그룹") or {}, str(doc.get("판", 1))
 
 
 def groups_of() -> dict[str, list[dict[str, Any]]]:
@@ -83,11 +72,23 @@ def listing() -> dict[str, Any]:
     return {"판": version, "그룹": doc, "종류": kinds}
 
 
-def _clean(groups: Any) -> dict[str, list[dict[str, Any]]]:
-    """받은 표 검사 — 없는 종류 · 키 · 겹친 id · 이름 · 옵션 두 그룹은 422 · 빈 종류는 뺌."""
+def _shape_ok(shape: Any) -> bool:
+    return isinstance(shape, dict) and all(
+        k in SHAPE
+        and isinstance(v, dict)
+        and isinstance(v.get("받기"), bool)
+        and isinstance(v.get("뜻", ""), str)
+        and set(v) <= {"받기", "뜻"}
+        for k, v in shape.items()
+    )
+
+
+def _clean(groups: Any, keys: dict[str, set[str]] | None = None) -> dict[str, list[dict[str, Any]]]:
+    """받은 표 검사 — 없는 종류 · 키 · 겹친 id · 이름 · 옵션 두 그룹 · 틀린 형상 422."""
     if not isinstance(groups, dict):
         raise store.StoreError(400, "그룹은 종류별 묶음이어야 함")
-    keys = {t.type_id: {o.key for o in t.options} for t in load_structure_types()}
+    if keys is None:
+        keys = {t.type_id: {o.key for o in t.options} for t in load_structure_types()}
     errors: list[str] = []
     out: dict[str, list[dict[str, Any]]] = {}
     for type_id, rows in groups.items():
@@ -126,9 +127,14 @@ def _clean(groups: Any) -> dict[str, list[dict[str, Any]]]:
                     )
                 else:
                     owner[key] = name
+            if "형상" in row and not _shape_ok(row["형상"]):
+                errors.append(
+                    f"「{type_id}.{name}」 형상은 {{길이 · 높이 · 전 · 후: {{받기, 뜻}}}}"
+                )
             ids.add(gid)
             names.add(name)
-            clean.append({"id": gid, "이름": name, "옵션": [k for k in opts if k in keys[type_id]]})
+            kept = {"id": gid, "이름": name, "옵션": [k for k in opts if k in keys[type_id]]}
+            clean.append({**kept, "형상": row["형상"]} if "형상" in row else kept)
         if clean:
             out[type_id] = clean
     if errors:
@@ -138,11 +144,7 @@ def _clean(groups: Any) -> dict[str, list[dict[str, Any]]]:
 
 def save(groups: Any, version: str) -> dict[str, Any]:
     """고쳐 씀 — 판이 같을 때만. 돌려주는 것 = 새 `listing()`."""
-    fixed = _clean(groups)
-    path = store.FOLDER / FILE
-    with store._LOCK:
-        have = store.version_of(path.read_bytes()) if path.is_file() else ""
-        if have != (version or ""):
-            raise store.StoreError(409, {"stale": [FILE], "판": have})
-        atomic_write_json(path, fixed)
+    from M02_MasterTemplete.StructOptions.M02_SO_Definition import save_sections
+
+    save_sections({"그룹": _clean(groups)}, version)
     return listing()
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Groups.ts b/M02_MasterTemplete/StructOptions/M02_SO_Groups.ts
index 242dad8b4..410875cf4 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Groups.ts
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Groups.ts
@@ -1,19 +1,21 @@
 /* =============================================================================
  * M02_SO_Groups.ts
- * 「구조물 옵션 보이기」 화면의 **옵션 그룹** 부품(PLAN 46-2) — 고른 종류의 그룹 목록
- * (이름 · 위로 · 아래로 · 지우기 · [그룹 추가]) · 옵션 줄마다 「들어갈 자리」 고르기(본체 · 그룹).
- * 값은 화면이 쥔 고칠 사본(종류 → 그룹[])에만 — 저장은 화면 [저장](`M02_SO_Options.ts`).
+ * 구조물 정의 화면의 **옵션 그룹** 부품(PLAN 46-2 · 48-2) — 고른 종류의 그룹 목록
+ * (이름 · 위로 · 아래로 · 지우기 · 형상 칸 길이 · 높이 · 전 · 후 받기 켬끔과 뜻 · [그룹 추가]) ·
+ * 옵션 줄마다 「들어갈 자리」 고르기(본체 · 그룹).
+ * 값은 화면이 쥔 고칠 사본에만 — 저장은 화면 [저장](`M02_SO_Def.ts`).
  * 그룹 하나 = 프로젝트 B05 · B06 폼의 보조 컨테이너 하나 · 옵션이 없어도 됨(서버 `M02_SO_Groups.py`).
  * ========================================================================== */
 
 import { createButton, el, showConfirmDialog } from "@ui/ui_template_elements";
-import type { OptionGroupDef } from "./M02_SO_Api";
+import { SHAPE_KEYS, type GroupDef } from "./M02_SO_Def_Model";
+import { checkBox, textBox } from "./M02_SO_Def_Ui";
 import { to } from "./M02_SO_Text";
 
 const NAME_MAX = 40;
 
 /** 새 그룹 id — 서버 규칙 `g[0-9a-z]{1,16}` · 같은 종류 안에서 안 겹치게 */
-export function newGroupId(list: readonly OptionGroupDef[]): string {
+export function newGroupId(list: readonly GroupDef[]): string {
   const taken = new Set(list.map((g) => g.id));
   for (;;) {
     const id = `g${Math.random().toString(36).slice(2, 8)}`;
@@ -22,35 +24,49 @@ export function newGroupId(list: readonly OptionGroupDef[]): string {
 }
 
 /** 그 옵션이 든 그룹 id — 없으면 null(본체) */
-export function groupOf(list: readonly OptionGroupDef[], key: string): string | null {
+export function groupOf(list: readonly GroupDef[], key: string): string | null {
   return list.find((g) => g.옵션.includes(key))?.id ?? null;
 }
 
 /** 옵션을 그룹(null = 본체)으로 옮김 — 한 옵션은 한 그룹에만 */
-export function moveOption(list: OptionGroupDef[], key: string, gid: string | null): void {
+export function moveOption(list: GroupDef[], key: string, gid: string | null): void {
   for (const g of list) g.옵션 = g.옵션.filter((k) => k !== key);
   const target = gid ? list.find((g) => g.id === gid) : null;
   if (target) target.옵션.push(key);
 }
 
-/** 이름이 다 괜찮은가 — 1~40자 · 같은 종류 안에서 안 겹침(서버도 같은 검사) */
-export function namesOk(groups: Map<string, OptionGroupDef[]>): boolean {
-  for (const list of groups.values()) {
-    const names = list.map((g) => g.이름.trim());
-    if (names.some((n) => !n || n.length > NAME_MAX)) return false;
-    if (new Set(names).size !== names.length) return false;
-  }
-  return true;
-}
-
 export interface GroupBlockOptions {
   /** 고른 종류의 그룹(고칠 사본 — 이 부품이 직접 고침) */
-  list: OptionGroupDef[];
+  list: GroupDef[];
   edit: boolean;
   /** 고쳤음 — 화면이 고침 표시 · 다시 그리기 */
   changed: () => void;
 }
 
+/** 그룹 형상 줄 — 칸마다 받기 체크 + 뜻(무엇을 정하는지 한 줄) */
+function shapeLine(group: GroupDef, edit: boolean, changed: () => void): HTMLElement {
+  const shape = (group.형상 ??= {});
+  return el("div", {
+    className: "m02-sog__shape",
+    attrs: { "data-sog-shape": group.id },
+    children: SHAPE_KEYS.map((k) => {
+      const f = shape[k] ?? { 받기: false, 뜻: "" };
+      const on = checkBox(
+        to(`Shape_${k}` as const),
+        f.받기,
+        (v) => ((shape[k] = { ...f, 받기: v }), changed()),
+        { edit, attr: `data-sog-shape-${SHAPE_KEYS.indexOf(k)}` },
+      );
+      const mean = textBox(f.뜻, (v) => (shape[k] = { ...(shape[k] ?? f), 뜻: v }), changed, {
+        edit: edit && f.받기,
+        cls: "m02-sog__mean",
+        place: to("ShapeMean"),
+      });
+      return el("div", { className: "m02-sog__shapecell", children: [on, mean] });
+    }),
+  });
+}
+
 /** 그룹 목록 칸 — 제목 · 안내 · 그룹 줄 · [그룹 추가] */
 export function buildGroupBlock(opt: GroupBlockOptions): HTMLElement {
   const { list } = opt;
@@ -87,7 +103,7 @@ export function buildGroupBlock(opt: GroupBlockOptions): HTMLElement {
       list.splice(list.indexOf(group), 1);
       opt.changed();
     });
-    return el("div", {
+    const line = el("div", {
       className: "m02-sog__row",
       attrs: { "data-sog-group": group.id },
       children: [
@@ -99,6 +115,10 @@ export function buildGroupBlock(opt: GroupBlockOptions): HTMLElement {
         ...(opt.edit ? [up, down, del] : []),
       ],
     });
+    return el("div", {
+      className: "m02-sog__item",
+      children: [line, shapeLine(group, opt.edit, opt.changed)],
+    });
   });
   const add = createButton({ label: to("GroupAdd"), variant: "ghost", size: "sm" });
   add.setAttribute("data-sog-add", "");
@@ -121,7 +141,7 @@ export function buildGroupBlock(opt: GroupBlockOptions): HTMLElement {
 
 /** 옵션 줄의 「들어갈 자리」 고르기 — 본체 · 그룹 이름들 */
 export function buildPlaceSelect(
-  list: OptionGroupDef[],
+  list: GroupDef[],
   key: string,
   edit: boolean,
   changed: () => void,
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Options.py b/M02_MasterTemplete/StructOptions/M02_SO_Options.py
index 18ad33184..c059859e1 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Options.py
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Options.py
@@ -1,15 +1,14 @@
 """M02 구조물 옵션 보이기 — 구조물 종류마다 B05/B06 폼에 보일 옵션을 사용자가 체크.
 
-정본 = `resources/master_template/구조물옵션표시.json` = `{type_id: {option_key: false}}`
-— 없는 종류 · 키는 보임(파일이 없어도 모두 보임).
+정본 = 구조물 정의(`M02_SO_Definition` · PLAN 48-1) 「표시」 칸 = `{type_id: {option_key: false}}`
+— 없는 종류 · 키는 보임.
 저장은 **숨김(false)만** 남김 — 「모두 보임」 = `{}`.
 옵션 정의 · 옛 값은 그대로 — 폼이 그리는 것만 갈림(`GET /api/projects/structure-types` `visible`).
-판 = 파일 sha256 앞 16자(`store.version_of`) · 낡은 판으로 쓰면 409.
+판 = 정의 판(글) · 낡은 판으로 쓰면 409 · 저장마다 정의 판 +1 · 이력.
 """
 
 from __future__ import annotations
 
-import json
 import logging
 from typing import Any
 
@@ -19,14 +18,13 @@ from B05_Profile.B05_Profile_Structures_Schema import (
     StructureOptionField,
     StructureType,
     StructureTypesResponse,
+    load_definition,
     load_structure_types,
     registry_schema_version,
 )
-from common_util.common_util_json import atomic_write_json
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 from M02_MasterTemplete.StructOptions.M02_SO_Groups import groups_of
 
-FILE = "구조물옵션표시.json"
 logger = logging.getLogger(__name__)
 
 
@@ -56,18 +54,9 @@ class TypesWithVisible(StructureTypesResponse):
 
 
 def _load() -> tuple[dict[str, Any], str]:
-    """(숨김 표 · 판) — 파일이 없으면 빈 표 · 판 빈 글."""
-    path = store.FOLDER / FILE
-    if not path.is_file():
-        return {}, ""
-    raw = path.read_bytes()
-    try:
-        doc = json.loads(raw)
-    except ValueError as e:
-        raise store.StoreError(500, f"{FILE} 을 못 읽음 — {e}") from e
-    if not isinstance(doc, dict):
-        raise store.StoreError(500, f"{FILE} 은 종류별 묶음이어야 함")
-    return doc, store.version_of(raw)
+    """(표시 표 · 판) — 정의 한 벌(`M02_SO_Definition`)의 「표시」 칸 · 판 = 정의 판 글."""
+    doc = load_definition()
+    return doc.get("표시") or {}, str(doc.get("판", 1))
 
 
 def _shown(doc: dict[str, Any], type_id: str, key: str) -> bool:
@@ -138,11 +127,12 @@ def listing() -> dict[str, Any]:
     return {"판": version, "표시": hidden, "종류": kinds}
 
 
-def _clean(shown: Any) -> dict[str, dict[str, bool]]:
+def _clean(shown: Any, keys: dict[str, set[str]] | None = None) -> dict[str, dict[str, bool]]:
     """받은 표 검사 → 숨김만 남김. 없는 종류 · 키 · 참거짓 아닌 값은 422."""
     if not isinstance(shown, dict):
         raise store.StoreError(400, "표시는 종류별 묶음이어야 함")
-    keys = {t.type_id: {o.key for o in t.options} for t in load_structure_types()}
+    if keys is None:
+        keys = {t.type_id: {o.key for o in t.options} for t in load_structure_types()}
     errors: list[str] = []
     out: dict[str, dict[str, bool]] = {}
     for type_id, row in shown.items():
@@ -165,11 +155,7 @@ def _clean(shown: Any) -> dict[str, dict[str, bool]]:
 
 def save(shown: Any, version: str) -> dict[str, Any]:
     """고쳐 씀 — 판이 같을 때만. 돌려주는 것 = 새 `listing()`."""
-    fixed = _clean(shown)
-    path = store.FOLDER / FILE
-    with store._LOCK:
-        have = store.version_of(path.read_bytes()) if path.is_file() else ""
-        if have != (version or ""):
-            raise store.StoreError(409, {"stale": [FILE], "판": have})
-        atomic_write_json(path, fixed)
+    from M02_MasterTemplete.StructOptions.M02_SO_Definition import save_sections
+
+    save_sections({"표시": _clean(shown)}, version)
     return listing()
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Options.ts b/M02_MasterTemplete/StructOptions/M02_SO_Options.ts
index d340d13f6..7ede2af54 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Options.ts
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Options.ts
@@ -1,25 +1,12 @@
 /* =============================================================================
  * M02_SO_Options.ts
- * 좌측 「구조물 옵션 보이기」 줄(구조물 집계 양식 아래 별도 · 시스템 관리자만) — 누르면 메인 칸에
- * 종류 목록(군별) → 고른 종류의 **그룹**(PLAN 46-2 · `M02_SO_Groups.ts`) + 옵션 줄
- * (보이기 체크 · 라벨 · 키 작은 글 · B06 전용 · 필수 표시 · 들어갈 자리) · [저장] · [모두 보임].
- * 체크 안 한 옵션은 B05 · B06 구조물 폼에서 숨음(정의 · 값은 그대로).
- * 서버 = `M02_SO_Options.py`(`구조물옵션표시.json` · 숨긴 것만) · `M02_SO_Groups.py`(`구조물옵션그룹.json`).
+ * 좌측 「구조물 옵션 정의」 줄(구조물 집계 양식 아래 별도 · 시스템 층) — 누르면 메인 칸에
+ * 정의 편집 화면(PLAN 48-2 · `M02_SO_Def.ts`) · 고쳐 씀은 시스템 관리자만 · 다른 역할은 읽기만.
+ * 옛 「보이기 · 그룹」 화면(46장)은 정의 화면의 옵션 줄 「보이기」 · 그룹 칸으로 들어감.
  * ========================================================================== */
 
-import { createButton, createTag, el, showToast } from "@ui/ui_template_elements";
-import { StaleError } from "../M02_MasterTemplete_Api_Fetch";
-import {
-  fetchStructureOptionGroups,
-  fetchStructureOptions,
-  saveStructureOptionGroups,
-  saveStructureOptions,
-  type GroupsDoc,
-  type OptionGroupDef,
-  type OptionKind,
-  type OptionsDoc,
-} from "./M02_SO_Api";
-import { buildGroupBlock, buildPlaceSelect, namesOk } from "./M02_SO_Groups";
+import { el } from "@ui/ui_template_elements";
+import { openDefScreen } from "./M02_SO_Def";
 import "./M02_SO_Style.css";
 import { to } from "./M02_SO_Text";
 
@@ -40,8 +27,6 @@ export interface OptionsSection {
   clear: () => void;
 }
 
-const why = (error: unknown): string => (error instanceof Error ? error.message : "");
-
 export function buildOptionsSection(opt: OptionsSectionOptions): OptionsSection {
   const row = el("button", {
     className: "m02-side__item ui-sidebar-row",
@@ -49,7 +34,6 @@ export function buildOptionsSection(opt: OptionsSectionOptions): OptionsSection
     attrs: { type: "button", "data-options-row": "" },
   });
   const body = el("div", { className: "m02-side__items ui-sidebar-list", children: [row] });
-  row.addEventListener("click", () => void open());
 
   /** 이 화면이 열려 있는 동안 참 — 다른 것이 열리면 `clear` 가 내림 */
   let opened = false;
@@ -57,241 +41,12 @@ export function buildOptionsSection(opt: OptionsSectionOptions): OptionsSection
     opened = on;
     row.classList.toggle("is-active", on);
   };
-
-  async function open(): Promise<void> {
+  row.addEventListener("click", async () => {
     if (opened || !(await opt.confirmLeave())) return;
-    let doc: OptionsDoc;
-    let groups: GroupsDoc;
-    try {
-      [doc, groups] = await Promise.all([fetchStructureOptions(), fetchStructureOptionGroups()]);
-    } catch (error) {
-      return showToast(to("Load_Failed", why(error)), "error");
-    }
-    draw(doc, groups);
-  }
-
-  /** 메인 칸 화면 — `doc.표시` · `groups.그룹` 을 고칠 사본(저장 전까지 서버에 안 감)으로 쥠 */
-  function draw(doc: OptionsDoc, groupsDoc: GroupsDoc): void {
-    let version = doc.판;
-    let groupVersion = groupsDoc.판;
-    const edit = opt.isAdmin;
-    /** 숨긴 옵션 — 종류 → 키 집합 */
-    const hidden = new Map<string, Set<string>>();
-    const load = (src: OptionsDoc["표시"]): void => {
-      hidden.clear();
-      for (const [id, keys] of Object.entries(src)) hidden.set(id, new Set(Object.keys(keys)));
-    };
-    /** 그룹 — 종류 → 그룹[](고칠 사본) */
-    const groups = new Map<string, OptionGroupDef[]>();
-    const loadGroups = (src: GroupsDoc["그룹"]): void => {
-      groups.clear();
-      for (const [id, list] of Object.entries(src))
-        groups.set(
-          id,
-          list.map((g) => ({ ...g, 옵션: [...g.옵션] })),
-        );
-    };
-    load(doc.표시);
-    loadGroups(groupsDoc.그룹);
-    /** 종류 = 레지스트리 전부(옵션 없는 종류도 그룹을 둘 수 있음) */
-    let kinds = groupsDoc.종류;
-    let current: OptionKind | null = null;
-    let shownDirty = false;
-    let groupDirty = false;
-
-    const kindList = el("div", { className: "m02-opts__kinds" });
-    const optionList = el("div", { className: "m02-opts__list" });
-    const off = (id: string): number => hidden.get(id)?.size ?? 0;
-    const groupList = (id: string): OptionGroupDef[] => {
-      if (!groups.has(id)) groups.set(id, []);
-      return groups.get(id)!;
-    };
-
-    const paintKinds = (): void => {
-      const parts: HTMLElement[] = [];
-      let group = "";
-      for (const k of kinds) {
-        if (k.group !== group) {
-          group = k.group;
-          parts.push(
-            el("h4", {
-              className: "m02-opts__group",
-              text: group.length === 1 ? to("Group", group) : group,
-            }),
-          );
-        }
-        const n = off(k.type_id);
-        const g = groups.get(k.type_id)?.length ?? 0;
-        const b = el("button", {
-          className: `m02-opts__kind${k.type_id === current?.type_id ? " is-active" : ""}`,
-          attrs: { type: "button", "data-options-kind": k.type_id },
-          children: [
-            el("span", { text: k.name }),
-            ...(g ? [createTag(to("GroupTag", String(g)), "accent")] : []),
-            ...(n ? [createTag(to("Hidden", String(n)), "warning")] : []),
-            ...(k.enabled ? [] : [createTag(to("Off"), "neutral")]),
-          ],
-        });
-        b.addEventListener("click", () => {
-          current = k;
-          paintKinds();
-          paintOptions();
-        });
-        parts.push(b);
-      }
-      kindList.replaceChildren(...parts);
-    };
-
-    /** 그룹을 고쳤음 — 고침 표시 · 종류 목록(그룹 수) · 오른쪽 다시 그림 */
-    const groupsChanged = (): void => {
-      groupDirty = true;
-      sync();
-      paintKinds();
-      paintOptions();
-    };
-
-    const paintOptions = (): void => {
-      if (!current) {
-        optionList.replaceChildren(el("p", { className: "m02-side__empty", text: to("Pick") }));
-        return;
-      }
-      const kind = current;
-      const list = groupList(kind.type_id);
-      const rows = kind.options.map((o) => {
-        const box = el("input", {
-          attrs: { type: "checkbox", "data-options-key": o.key },
-        }) as HTMLInputElement;
-        box.checked = !hidden.get(kind.type_id)?.has(o.key);
-        box.disabled = !edit;
-        box.addEventListener("change", () => {
-          const set = hidden.get(kind.type_id) ?? new Set<string>();
-          if (box.checked) set.delete(o.key);
-          else set.add(o.key);
-          hidden.set(kind.type_id, set);
-          shownDirty = true;
-          sync();
-          paintKinds();
-        });
-        const tags: HTMLElement[] = [];
-        if (o.phase === "detail") tags.push(createTag(to("Detail"), "accent"));
-        if (o.required && o.phase === "b05") {
-          const tag = createTag(to("Required"), "danger");
-          tag.title = to("RequiredTip");
-          tags.push(tag);
-        }
-        return el("div", {
-          className: "m02-opts__option",
-          children: [
-            el("label", {
-              className: "m02-opts__check",
-              children: [
-                box,
-                el("span", { text: o.label }),
-                el("small", { className: "m02-opts__key", text: o.key }),
-                ...tags,
-              ],
-            }),
-            buildPlaceSelect(list, o.key, edit, groupsChanged),
-          ],
-        });
-      });
-      optionList.replaceChildren(
-        el("h3", { className: "m02-options__head", text: kind.name }),
-        buildGroupBlock({ list, edit, changed: groupsChanged }),
-        el("h4", { className: "m02-opts__group", text: to("OptionHead") }),
-        ...(rows.length
-          ? rows
-          : [el("p", { className: "m02-side__empty", text: to("NoOptionKind") })]),
-      );
-    };
-
-    const save = createButton({ label: to("Save"), variant: "filled" });
-    const all = createButton({ label: to("ShowAll"), variant: "ghost" });
-    all.addEventListener("click", () => {
-      if (![...hidden.values()].some((s) => s.size)) return;
-      hidden.clear();
-      shownDirty = true;
-      sync();
-      paintKinds();
-      paintOptions();
-    });
-
-    /** 다시 받기 — 낡은 판으로 막혔을 때 둘 다 새로 */
-    const reload = async (): Promise<void> => {
-      try {
-        const [fresh, freshGroups] = await Promise.all([
-          fetchStructureOptions(),
-          fetchStructureOptionGroups(),
-        ]);
-        version = fresh.판;
-        groupVersion = freshGroups.판;
-        kinds = freshGroups.종류;
-        load(fresh.표시);
-        loadGroups(freshGroups.그룹);
-        shownDirty = groupDirty = false;
-        sync();
-        current = kinds.find((k) => k.type_id === current?.type_id) ?? null;
-        paintKinds();
-        paintOptions();
-      } catch (again) {
-        showToast(to("Load_Failed", why(again)), "error");
-      }
-    };
-
-    save.addEventListener("click", async () => {
-      if (groupDirty && !namesOk(groups)) return showToast(to("NameBad"), "error");
-      save.disabled = true; // 연달아 눌러도 한 번만
-      try {
-        if (shownDirty) {
-          const 표시: OptionsDoc["표시"] = {};
-          for (const [id, keys] of hidden)
-            if (keys.size) 표시[id] = Object.fromEntries([...keys].map((k) => [k, false as const]));
-          const done = await saveStructureOptions(version, 표시);
-          version = done.판;
-          load(done.표시);
-          shownDirty = false;
-        }
-        if (groupDirty) {
-          const 그룹: GroupsDoc["그룹"] = {};
-          for (const [id, list] of groups)
-            if (list.length) 그룹[id] = list.map((g) => ({ ...g, 이름: g.이름.trim() }));
-          const done = await saveStructureOptionGroups(groupVersion, 그룹);
-          groupVersion = done.판;
-          loadGroups(done.그룹);
-          groupDirty = false;
-        }
-        sync();
-        showToast(to("Saved"), "success");
-        paintKinds();
-        paintOptions();
-      } catch (error) {
-        if (error instanceof StaleError) {
-          showToast(to("Stale"), "error");
-          await reload();
-        } else showToast(to("Failed", why(error)), "error");
-      } finally {
-        save.disabled = false;
-      }
-    });
-
-    const node = el("div", {
-      className: "m02-opts",
-      children: [
-        el("p", { className: "m02-side__empty", text: to("Note") }),
-        el("div", {
-          className: "m02-opts__panes",
-          children: [kindList, optionList],
-        }),
-        ...(edit ? [el("div", { className: "m02-side__row", children: [save, all] })] : []),
-      ],
-    });
-    const setDirty = opt.show(to("Screen"), node);
-    const sync = (): void => setDirty(shownDirty || groupDirty);
-    paintKinds();
-    paintOptions();
+    if (!(await openDefScreen({ isAdmin: opt.isAdmin, show: opt.show }))) return;
     opt.onOpen();
     mark(true);
-  }
+  });
 
   return { title: to("Title"), body, clear: () => mark(false) };
 }
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Router.py b/M02_MasterTemplete/StructOptions/M02_SO_Router.py
index d417fc2e9..b18945fdb 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Router.py
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Router.py
@@ -1,7 +1,8 @@
-"""M02 구조물 옵션 보이기 · 그룹 길 — 정본 `M02_SO_Options.py` · `M02_SO_Groups.py`.
+"""M02 구조물 옵션 보이기 · 그룹 · 정의 길 — 정본 `M02_SO_Definition.py`(PLAN 48-1) 한 벌.
 
 `router` = 고쳐 씀 · 관리 읽기(`main.py` 가 `system_admin_only` 로 붙임) ·
-`read_router` = 읽기만(로그인 누구나 · `main.py` 가 `protected` 로 붙임).
+`read_router` = 읽기만(로그인 누구나 · `main.py` 가 `protected` 로 붙임) · 정의 쓰기는 여기서
+시스템 관리자만(`access.require(write=True)` · 아니면 403).
 """
 
 from __future__ import annotations
@@ -14,6 +15,7 @@ from pydantic import BaseModel
 from common_util.common_util_auth import verify_session
 from M02_MasterTemplete import M02_Layer_Access as access
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete.StructOptions import M02_SO_Definition as definition
 from M02_MasterTemplete.StructOptions import M02_SO_Groups as groups
 from M02_MasterTemplete.StructOptions import M02_SO_Options as options
 
@@ -31,6 +33,11 @@ class GroupsBody(BaseModel):
     그룹: dict[str, Any]  # {종류: [{id, 이름, 옵션[]}]}
 
 
+class DefinitionBody(BaseModel):
+    판: int  # 읽어 간 정의 판 — 어긋나면 409
+    정의: dict[str, Any]  # 정의 한 벌(틀 = docs/raw/M02_구조물옵션정의/정의_틀.md)
+
+
 def _call(fn, *args):
     with store.at(store.FOLDER):
         try:
@@ -68,3 +75,31 @@ def get_structure_options_read(session=Depends(verify_session)) -> dict:
     """구조물 옵션 보이기 읽기 — 로그인 누구나(마스터 한 벌 · 고쳐 씀은 시스템 관리자만)."""
     access.require(session, "system", None)
     return _call(options.listing)
+
+
+@read_router.get("/structure-definition")
+def get_structure_definition(session=Depends(verify_session)) -> dict:
+    """구조물 정의 한 벌(판 · 구조물군 · 동작 · types · 종류 · 표시 · 그룹 · 배치 · 규칙)."""
+    access.require(session, "system", None)
+    return _call(definition.read)
+
+
+@read_router.get("/structure-definition/history")
+def get_structure_definition_history(session=Depends(verify_session)) -> list[dict]:
+    """지난 판 목록 `[{판, 저장일}]`(새 판부터) — 로그인 누구나(PLAN 48-2)."""
+    access.require(session, "system", None)
+    return _call(definition.history)
+
+
+@read_router.get("/structure-definition/history/{version}")
+def get_structure_definition_at(version: int, session=Depends(verify_session)) -> dict:
+    """지난 판 한 벌(읽기만) — 없으면 404."""
+    access.require(session, "system", None)
+    return _call(definition.read_version, version)
+
+
+@read_router.put("/structure-definition")
+def put_structure_definition(body: DefinitionBody, session=Depends(verify_session)) -> dict:
+    """정의 고쳐 씀 — 시스템 관리자만(403) · 낡은 판 409 · 검사 422 · 판 +1 · 앞 판은 이력."""
+    access.require(session, "system", None, write=True)
+    return _call(definition.save, body.정의, body.판)
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Style.css b/M02_MasterTemplete/StructOptions/M02_SO_Style.css
index 2670d6cfe..a8570c86a 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Style.css
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Style.css
@@ -112,3 +112,223 @@
   color: var(--color-text-muted);
   font-size: 11px;
 }
+
+/* 구조물 정의 편집 화면(PLAN 48-2) — 판 띠 · 종류 머리 · 옵션 · 선택지 · 배치 격자 · 규칙 · 지난 판 */
+.m02-sod {
+  max-width: 80rem;
+}
+
+.m02-sod__banner {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-8);
+  color: var(--color-text-muted);
+}
+
+.m02-sod__banner.is-past {
+  padding: var(--spacing-4) var(--spacing-8);
+  border: 1px solid var(--color-accent);
+  border-radius: var(--radius-sm);
+  background: var(--color-mist-violet);
+  color: var(--color-text);
+}
+
+.m02-sod__family,
+.m02-sod__kindrow,
+.m02-sod__kindhead,
+.m02-sod__option,
+.m02-sod__choice,
+.m02-sod__place,
+.m02-sod__rule {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-8);
+}
+
+.m02-sod__family {
+  margin-top: var(--spacing-8);
+}
+
+.m02-sod__family > .ui-input {
+  flex: 1 1 8rem;
+  min-width: 0;
+  font-weight: 600;
+}
+
+.m02-sod__kindrow {
+  flex-wrap: nowrap;
+}
+
+.m02-sod__kindrow > .m02-opts__kind {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.m02-sod__kindrow > button:not(.m02-opts__kind),
+.m02-sod__family > button {
+  flex: none;
+  white-space: nowrap;
+}
+
+.m02-sod__block {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  padding-top: var(--spacing-8);
+  border-top: 1px solid var(--color-border);
+}
+
+.m02-sod__option {
+  padding: var(--spacing-4) 0;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.is-off > .ui-input,
+.m02-opts__kind.is-off > span:first-child {
+  color: var(--color-text-muted);
+  text-decoration: line-through;
+}
+
+.m02-sod__name {
+  flex: 1 1 10rem;
+  min-width: 0;
+}
+
+.m02-sod__form,
+.m02-sod__default {
+  width: 8rem;
+}
+
+.m02-sod__unit,
+.m02-sod__num {
+  width: 4.5rem;
+}
+
+.m02-sod__check {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--spacing-4);
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.m02-sod__choices {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  margin: 0 0 var(--spacing-8) var(--spacing-24);
+  padding-left: var(--spacing-8);
+  border-left: 2px solid var(--color-border);
+}
+
+/* 배치 격자 — 왼쪽 칸 숫자 · 오른쪽 미리보기 */
+.m02-sod__layout {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(12rem, 22rem);
+  gap: var(--spacing-16);
+  align-items: start;
+}
+
+.m02-sod__place {
+  flex-wrap: nowrap;
+}
+
+.m02-sod__placename {
+  flex: 1 1 6rem;
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.m02-sod__place > .m02-sod__num {
+  flex: none;
+  width: 4rem;
+}
+
+.m02-sod__grid {
+  display: grid;
+  gap: var(--spacing-4);
+  padding: var(--spacing-8);
+  border: 1px dashed var(--color-border);
+  border-radius: var(--radius-sm);
+}
+
+.m02-sod__cell {
+  overflow: hidden;
+  padding: var(--spacing-4);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: var(--color-surface-raised);
+  font-size: 11px;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.m02-sod__cell.is-base {
+  background: var(--color-mist-violet);
+}
+
+.m02-sod__cell.is-bad,
+.m02-sod__rule.is-bad {
+  border-color: var(--color-danger);
+}
+
+.m02-sod__rule {
+  padding: var(--spacing-4);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+}
+
+.m02-sod__rulepick {
+  width: 9rem;
+}
+
+.m02-sod__rulechoices {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-8);
+}
+
+/* 그룹 형상 칸 — 길이 · 높이 · 전 · 후 받기 + 뜻 */
+.m02-sog__item {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  padding-bottom: var(--spacing-4);
+  border-bottom: 1px solid var(--color-border);
+}
+
+.m02-sog__shape {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(14rem, 1fr));
+  gap: var(--spacing-4) var(--spacing-12);
+}
+
+.m02-sog__shapecell {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-4);
+}
+
+.m02-sog__mean {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.m02-sod__issues:empty,
+.m02-sod__history:empty {
+  display: none;
+}
+
+.m02-sod__history {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-4);
+}
+
+.m02-sod__bad {
+  margin: 0;
+  color: var(--color-danger);
+}
diff --git a/M02_MasterTemplete/StructOptions/M02_SO_Text.ts b/M02_MasterTemplete/StructOptions/M02_SO_Text.ts
index 9b4409b41..90037edd8 100644
--- a/M02_MasterTemplete/StructOptions/M02_SO_Text.ts
+++ b/M02_MasterTemplete/StructOptions/M02_SO_Text.ts
@@ -6,13 +6,12 @@
 import { currentLanguageIndex } from "@ui/ui_template_locale";
 
 const TEXT = {
-  Title: ["구조물 옵션 보이기", "Structure options shown"],
-  Row: ["종류마다 그룹 · 보일 옵션 정하기", "Groups and shown options per type"],
-  Screen: ["구조물 옵션 보이기 · 그룹", "Structure options · groups"],
-  Note: [
-    "체크한 옵션만 B05 · B06 구조물 폼에 보임 — 옵션 정의 · 이미 넣은 값은 그대로 · 처음은 모두 보임",
-    "Only checked options appear in the B05 · B06 forms — definitions and stored values stay",
+  Title: ["구조물 옵션 정의", "Structure option definition"],
+  Row: [
+    "구조물군 · 종류 · 옵션 · 배치 · 그룹 · 규칙",
+    "Families · types · options · layout · groups · rules",
   ],
+  Screen: ["구조물 옵션 정의", "Structure option definition"],
   GroupHead: ["그룹", "Groups"],
   GroupNote: [
     "그룹 하나 = 프로젝트 B05 · B06 폼의 보조 컨테이너 하나(제목 = 그룹 이름) · 그 안에서 구조물 조합 항목을 따로 지정 · 옵션이 없어도 연결됨 · 그룹에 안 넣은 옵션은 본체",
@@ -35,35 +34,92 @@ const TEXT = {
   ],
   GroupTag: ["그룹 {value}", "{value} groups"],
   Main: ["본체", "Main body"],
-  OptionHead: ["옵션 — 보이기 · 들어갈 자리", "Options — shown · container"],
+  OptionHead: ["옵션", "Options"],
+  OptionNote: [
+    "이름 · 꼴 · 단위 · 기본값 · 들어갈 자리(본체 · 그룹) · 안 씀 · 순서 — 키(작은 글)는 안 바뀜 · 고르기 꼴은 [선택지]로 목록을 고침",
+    "Name · form · unit · default · container · unused · order — keys never change",
+  ],
+  OptionAdd: ["옵션 더함", "Add option"],
+  OptionNew: ["새 옵션 {value}", "New option {value}"],
+  FormSelect: ["고르기", "Select"],
+  FormNumber: ["숫자", "Number"],
+  FormText: ["글", "Text"],
+  FormBool: ["예/아니오", "Yes/No"],
+  Yes: ["예", "Yes"],
+  No: ["아니오", "No"],
+  Unit: ["단위", "Unit"],
+  NoDefault: ["기본값 없음", "No default"],
+  Unused: ["안 씀", "Unused"],
+  Choices: ["선택지 {value}", "{value} choices"],
+  ChoiceAdd: ["선택지 더함", "Add choice"],
+  ChoiceNew: ["새 선택지 {value}", "New choice {value}"],
+  ChoiceNone: ["선택지 없음 — 고르기 꼴은 하나 이상", "No choices — select needs at least one"],
+  ChoiceNote: [
+    "선택지 글이 곧 저장 값 — 이름을 바꾸면 기본값 · 규칙도 같이 바뀜 · 이미 저장한 프로젝트 값은 「지난 정의 값」으로 남음",
+    "Choice text is the stored value — renaming updates defaults and rules here",
+  ],
+  ChoiceDrop: ["빼기", "Remove"],
+  ChoiceDropAsk: [
+    "선택지 「{value}」 를 뺌 — 기본값 · 규칙에서도 빠짐 · 이미 저장한 프로젝트 값은 「지난 정의 값」으로 남음",
+    "Remove choice “{value}” — also from defaults and rules",
+  ],
+  Shown: ["보이기", "Shown"],
+  RuleValues: ["값(쉼표로 여럿)", "Values (comma separated)"],
+  RuleChoices: ["선택지", "Choices"],
+  LayoutHead: ["배치 격자", "Layout grid"],
+  LayoutNote: [
+    "B05 · B06 좌측 구조물 칸(두 칸)의 배치 — 옵션마다 줄 · 칸 · 너비 · 기준 측점은 맨 위 한 줄 · 겹치면 빨강 · 안 정한 옵션은 차례대로",
+    "Left panel layout (two columns) — row · column · width per option · overlaps in red",
+  ],
+  GridRow: ["줄", "Row"],
+  GridCol: ["칸", "Col"],
+  GridWidth: ["너비", "Width"],
+  BaseStation: ["기준 측점", "Base station"],
+  BaseStationShow: ["기준 측점 표시", "Show base station"],
+  Shape_길이: ["길이", "Length"],
+  Shape_높이: ["높이", "Height"],
+  Shape_전: ["기준 측점 전", "Before"],
+  Shape_후: ["기준 측점 후", "After"],
+  ShapeMean: ["무엇을 정하는지", "What it controls"],
+  RuleHead: ["규칙", "Rules"],
+  RuleNote: [
+    "만약 상위 옵션 = 값 → 하위 옵션의 선택지 · 보이기 · 기본값 — 「그대로」 칸은 손대지 않음 · 틀린 줄은 빨강",
+    "If parent = value → child choices · visibility · default",
+  ],
+  RuleNone: ["규칙 없음", "No rules"],
+  RuleAdd: ["규칙 더함", "Add rule"],
+  RuleIf: ["만약", "If"],
+  RuleThen: ["→", "→"],
+  Keep: ["보이기 그대로", "Keep visibility"],
+  Show: ["보임", "Show"],
+  Hide: ["숨김", "Hide"],
+  KeepDefault: ["기본값 그대로", "Keep default"],
+  DefNote: [
+    "구조물군 · 종류 · 옵션 · 선택지 · 배치 · 그룹 · 규칙 정의 — [저장]하면 판이 하나 오르고 B05 · B06 에 바로 적용 · 지난 판은 이력으로 남음",
+    "Structure definition — Save bumps the version; past versions stay in history",
+  ],
+  Version: ["판 {value}", "Version {value}"],
+  ReadOnly: ["읽기만", "Read only"],
+  SavedVersion: ["저장함 — 판 {value}", "Saved — version {value}"],
+  PastList: ["지난 판", "Past versions"],
+  PastItem: ["판 {value}", "v{value}"],
+  PastNone: ["지난 판 없음", "No past versions"],
+  PastView: ["판 {value} 보는 중 — 읽기만", "Viewing version {value} — read only"],
+  PastBack: ["지금 판으로", "Back to current"],
   NoOptionKind: [
     "이 종류는 옵션이 없음 — 그룹만 만들 수 있음(그룹마다 조합 연결)",
     "No options — groups only (each links a combo)",
   ],
-  NameBad: [
-    "그룹 이름은 1~40자 · 같은 종류 안에서 겹치면 안 됨",
-    "Group names: 1–40 chars, unique",
-  ],
-  Group: ["{value}군", "Group {value}"],
-  Hidden: ["숨김 {value}", "{value} hidden"],
   Off: ["안 쓰는 종류", "Not offered"],
-  NoOption: ["옵션 없음", "No options"],
   Pick: ["왼쪽에서 구조물 종류를 고름", "Pick a structure type on the left"],
   Detail: ["B06 전용", "B06 only"],
-  Required: ["필수", "Required"],
-  RequiredTip: [
-    "필수 옵션 — 숨기면 폼에 안 나오고 필수로도 안 침(저장이 안 막힘)",
-    "Required — when hidden it is not shown and not enforced",
-  ],
   Save: ["저장", "Save"],
-  ShowAll: ["모두 보임", "Show all"],
-  Saved: ["저장함", "Saved"],
   Stale: [
-    "그 사이 옵션 표시가 바뀜 — 새로 받았으니 다시 고쳐 주세요",
+    "그 사이 정의가 바뀜 — 새로 받았으니 다시 고쳐 주세요",
     "Changed meanwhile — reloaded, please edit again",
   ],
-  Load_Failed: ["옵션 표시를 못 받음 — {value}", "Could not load option display — {value}"],
-  Failed: ["옵션 표시를 못 저장함 — {value}", "Could not save option display — {value}"],
+  Load_Failed: ["구조물 정의를 못 받음 — {value}", "Could not load the definition — {value}"],
+  Failed: ["구조물 정의를 못 저장함 — {value}", "Could not save the definition — {value}"],
 } as const satisfies Record<string, readonly [string, string]>;
 
 export type OptionsTextKey = keyof typeof TEXT;
diff --git a/common_util/common_util_culvert_sets.ts b/common_util/common_util_culvert_sets.ts
index f9055b0ac..d53993a58 100644
--- a/common_util/common_util_culvert_sets.ts
+++ b/common_util/common_util_culvert_sets.ts
@@ -241,7 +241,8 @@ function wingSpec(
   const length = num(values[`${prefix}_length_m`], num(defaults[`${prefix}_length_m`], 0.0));
   const angle = num(values[`${prefix}_angle_deg`], num(defaults[`${prefix}_angle_deg`], 45.0));
   const height = num(values[`${prefix}_height_m`], num(defaults[`${prefix}_height_m`], 0.0));
-  const installed = String(install ?? "").trim() !== "없음";
+  // BOX암거 유입·유출 구조(표 02) — 없음 · 날개벽 · 흙막이 · 옛 값 있음 = 날개벽. 날개벽만 세움.
+  const installed = !["없음", "흙막이"].includes(String(install ?? "").trim());
   return {
     installed,
     height_m: height,
diff --git a/docs/raw/M02_구조물옵션정의/정의_틀.md b/docs/raw/M02_구조물옵션정의/정의_틀.md
new file mode 100644
index 000000000..c64e03855
--- /dev/null
+++ b/docs/raw/M02_구조물옵션정의/정의_틀.md
@@ -0,0 +1,101 @@
+# 구조물 정의 틀 (PLAN 48-1)
+
+정본 = `resources/master_template/구조물정의.json` 한 벌. 서버 · 화면은 이 한 벌만 읽음.
+
+## 1. 길
+
+| 길 | 누가 | 하는 것 |
+| --- | --- | --- |
+| `GET /api/m02/structure-definition` | 로그인 누구나 | 정의 한 벌 그대로 |
+| `PUT /api/m02/structure-definition` `{판, 정의}` | 시스템 관리자만(아니면 403) | 통째로 고쳐 씀 · 낡은 판 409 · 검사 틀림 422 |
+| `GET /api/projects/structure-types` | 로그인 | 정의의 `types` + `표시` · `그룹` 을 옛 꼴 그대로(`visible` · `groups`) |
+| `PUT /api/m02/structure-options` · `structure-option-groups` | 시스템 관리자 | 정의의 `표시` · `그룹` 칸만 고쳐 씀(같은 판 · 같은 이력) |
+
+- 서버 읽기 = `B05_Profile_Structures_Schema.load_definition()` · `load_structure_types()` · 쓰기 = `M02_SO_Definition.save()` · `save_sections()`.
+
+## 2. 담는 것
+
+| 칸 | 꼴 | 뜻 |
+| --- | --- | --- |
+| `판` | 정수 | 저장마다 +1 · 앞 판은 `구조물정의_이력/판_N.json` |
+| `schema_version` · `comment` | 수 · 글 | 옛 레지스트리 머리 그대로 |
+| `구조물군` | `{군 키: 이름}` | 구조물군 이름(A 횡단배수 …) |
+| `동작` | `{동작 이름: 뜻}` | 손코딩 특수 동작 목록(5장) |
+| `types` | 종류 목록 | 종류 · 옵션 · 선택지 · 기본값 · placement 등(옛 `B05_Profile_Structure_Types.json` 꼴 그대로) |
+| `종류` | `{종류 키: {기준측점?, 동작?}}` | 종류마다 덧칸 — 없으면 기본 |
+| `표시` | `{종류 키: {옵션 키: false}}` | 끈 옵션만(옛 `구조물옵션표시.json`) |
+| `그룹` | `{종류 키: [그룹]}` | 옵션 그룹(옛 `구조물옵션그룹.json` · 46장) + 형상 칸 |
+| `배치` | `{종류 키: {옵션 키: {줄, 칸, 너비}}}` | B05 · B06 좌측 「구조물 배치」 칸 자리 — 없으면 지금 차례 |
+| `규칙` | 규칙 목록 | 상위 옵션 값 → 하위 옵션(4장) |
+
+## 3. 키 규칙
+
+- 키 = 만들 때 자동 · 안 바뀜 · 영문 소문자 · 숫자 · `_`. 이름(`name` · `label` · 선택지 글 · 그룹 `이름`)은 자유.
+- 종류 키(`type_id`) 는 정의 안에서 하나 · 옵션 키(`key`) 는 종류 안에서 하나 · 그룹 id 는 `g` + 소문자 · 숫자.
+- 지움 = 「안 씀」(`enabled: false`) — 종류 · 옵션을 목록에서 빼지 않음.
+- 저장된 값의 키가 지금 정의에 없으면 = 지난 정의 값 — 버리지 않고 남김(오류 없음 · 계산은 없는 값으로).
+- 프로젝트 `structures.json` 에 저장 때 정의 판(`definition_version`).
+
+## 4. 옵션
+
+### 꼴
+
+| `input` | 이름 | 값 |
+| --- | --- | --- |
+| `select` | 고르기 | `choices` 중 하나(선택지 있어야 함) |
+| `number` | 숫자 | 0 이상 수 · `unit` |
+| `text` | 글 | 글 |
+| `bool` | 예/아니오 | 참 · 거짓 |
+
+- 옵션 덧칸(옛 그대로) = `label` · `choices` · `unit` · `default` · `required` · `phase`(b05 · detail) · `enabled` · `empty_means` · `default_basis` · `warn_above` · `warn_message` · `not_in_table`.
+
+### 배치 칸
+
+- `줄` = 몇째 줄(1부터) · `칸` = 그 줄 몇째 칸(1부터) · `너비` = 칸 몇 개 차지(1부터). 셋 다 1 이상 정수.
+
+### 그룹
+
+```
+{"id": "g1a2b3c", "이름": "유입구 기슭막이", "옵션": ["옵션 키", …],
+ "형상": {"길이": {"받기": true, "뜻": "유입구 기슭막이 연장"}, "높이": {…}, "전": {…}, "후": {…}}}
+```
+
+- 옵션 하나는 한 종류 안에서 그룹 하나에만 · 빈 그룹(옵션 0)도 그룹 · 그룹에 안 넣은 옵션 = 본체 칸.
+- `형상` = 그룹이 받을 형상 칸(길이 · 높이 · 기준 측점 전 · 후) — 칸마다 `받기`(켬끔) + `뜻`(무엇을 정하는지). 없는 칸 = 안 받음.
+
+### 종류 덧칸
+
+- `기준측점` = 종류 맨 위 기준 측점 칸 보이기(없으면 보임).
+- `동작` = 이 종류에 붙인 특수 동작 이름들(`동작` 목록 안에서).
+
+## 5. 규칙 꼴
+
+```
+{"종류": "종류 키",
+ "만약": {"옵션": "상위 옵션 키", "값들": ["값", …]},
+ "그러면": {"옵션": "하위 옵션 키", "선택지": ["값", …], "보이기": false, "기본값": "값"}}
+```
+
+- 만약 상위 옵션 = 값들 중 하나 → 그러면 하위 옵션의 선택지 / 보이기 / 기본값(셋 중 하나 이상).
+- 상위 · 하위는 같은 종류 안 · 서로 다른 옵션 · 고르기 꼴이면 값들은 선택지 안 · 하위 `선택지` 는 고르기 꼴의 선택지 안 · `기본값` 은 (좁힌) 선택지 안.
+- 계산 · 연동 제어는 넣지 않음(48-5).
+
+## 6. 동작 이름(손코딩 특수 동작)
+
+| 이름 | 붙은 종류 | 하는 것 |
+| --- | --- | --- |
+| `계곡통과시설` | pipe · box_culvert · ford_pavement · ford_bridge · revetment | 관 지점 정본 시설 — 부속 옵션 서브폼 · 저장은 폼이 아는 칸만 |
+| `유입유출_묶음` | pipe | 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹 |
+| `기슭막이_한벌` | pipe · revetment | 형태 · 길이 · 높이 · 바닥 보호공 한 벌 |
+| `BOX_본체규격` | box_culvert | 본체 규격 프리셋(폭 × 높이) |
+| `날개벽` | box_culvert · ford_bridge | 날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 |
+| `월류단면` | ford_pavement · ford_bridge | 월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 · 필요 수심 미만 되돌림 |
+| `포장_물넘이_겹침` | pavement_concrete | 포장 구간이 물넘이를 품으면 나눔 · 끝만 걸치면 저장 멈춤 |
+
+- 정의에서 붙이고 뗌 = `종류.{키}.동작` · 새 동작은 코딩 뒤 목록에 이름을 더함.
+
+## 7. 판 · 이력
+
+- 저장 = 읽어 간 `판` 을 같이 보냄 → 같으면 앞 판을 `구조물정의_이력/판_N.json` 으로 남기고 새 판 = N + 1.
+- 검사(틀리면 422 · 안 씀) = 칸 꼴 · 종류 키 · 옵션 키 겹침 · 고르기 선택지 있음 · 구조물군 있음 · 표시 · 그룹 · 배치 · 종류 덧칸 · 규칙 대상 있음.
+- 판 1 = 옛 `B05_Profile_Structure_Types.json`(37종 · 옵션 235) + `구조물옵션표시.json` + `구조물옵션그룹.json` 을 키 그대로 옮김.
diff --git a/docs/raw/구조물정의_표/01_횡단배수_배관.md b/docs/raw/구조물정의_표/01_횡단배수_배관.md
new file mode 100644
index 000000000..7af37a8c5
--- /dev/null
+++ b/docs/raw/구조물정의_표/01_횡단배수_배관.md
@@ -0,0 +1,12 @@
+# 구조물 표 01 — 횡단배수 › 배관 (사용자 10-5 · 원문 그대로 · 탭 구분)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목    컨테이너 2    컨테이너 2 옵션항목    컨테이너 3    컨테이너 3 옵션항목    컨테이너 4    컨테이너 4 옵션항목    컨테이너 5    컨테이너 5 옵션항목
+            (필수)컨테이너 제목 :  관        (필수)컨테이너 제목 : 관 보호공 (유입)        (필수)컨테이너 제목 : 관 보호공 (유출)        (선택)컨테이너 제목 : 흙막이 추가 | 여러개일수 있음.        (선택)컨테이너 제목 : 도수로/돌붙임 | 여러개일수 있음.
+횡단배수    배관    측점 No, + 측점거리    관경    800, 1000, 1200, 1500    구조    집수정, 흙막이    구조    흙막이    구조    흙막이    구조    도수로, 돌붙임
+            관 길이    입력값 아님, 자동계산됨    형태    집수정 : I형, L형, ㄷ형  | 흙막이 : 돌 쌓기(찰), 돌 쌓기(메), 콘크리트, 돌망태, 통나무/목재틀, 바자    형태    (같음)    형태    (같음)
+                    길이    수기입력    길이    수기입력    길이    수기입력
+                    높이    수기입력 및 횡단도에서 제어    높이    수기입력 및 횡단도에서 제어    높이    수기입력 및 횡단도에서 제어
+                    기준측점 전    수기입력(길이 + 기준측점 전/후에 따라 연동 계산)    (같음)    (같음)
+                    기준측점 후    수기입력(길이 + 기준측점 전/후에 따라 연동 계산)    (같음)    (같음)
+
+운영(사용자 10-5): M02 「구조물 옵션 정의」 = 이름 · 값 이름 바꿀 때만 · 구조는 사용자가 엑셀 표로 주는 대로 브레인이 구조물마다 작업 창 하나에 코드로 넣음 · 연동 계산까지 · 구조물별 계산 파일 따로 됨.
diff --git a/docs/raw/구조물정의_표/02_횡단배수_박스암거.md b/docs/raw/구조물정의_표/02_횡단배수_박스암거.md
new file mode 100644
index 000000000..84db436a0
--- /dev/null
+++ b/docs/raw/구조물정의_표/02_횡단배수_박스암거.md
@@ -0,0 +1,8 @@
+# 구조물 표 02 — 횡단배수 › 박스암거 (사용자 10-5 · 고친 판 · 원문 그대로)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목    컨테이너 2    컨테이너 2 옵션항목    컨테이너 3    컨테이너 3 옵션항목
+            (필수)컨테이너 제목 :  본체        (필수)유입 구조        (필수) 유출 구조
+횡단배수    박스암거    측점 No, + 측점거리    본체 규격    2.0 X 2.0, 3.0 X 3.0, 사용자 입력    구조    없음, 날개벽, 흙막이    구조    없음, 날개벽, 흙막이
+
+(첫 판: 날개벽(유입) · 날개벽(유출) 설치 있음/없음 → 이 판으로 바뀜)
+사용자 참고(10-5): 컨테이너 항목별로 이전에 작업한 구조물 조합의 키값을 연결할 예정 · 연결 코드는 이미 있음.
diff --git a/docs/raw/구조물정의_표/03_횡단배수_물넘이포장.md b/docs/raw/구조물정의_표/03_횡단배수_물넘이포장.md
new file mode 100644
index 000000000..dc4fa248c
--- /dev/null
+++ b/docs/raw/구조물정의_표/03_횡단배수_물넘이포장.md
@@ -0,0 +1,5 @@
+# 구조물 표 03 — 횡단배수 › 물넘이 포장 (사용자 10-5 · 원문 그대로)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목    컨테이너 2    컨테이너 2 옵션항목    컨테이너 3    컨테이너 3 옵션항목
+            (필수)컨테이너 제목 :  경사각도        (선택)컨테이너 제목 : 도수로/돌붙임
+횡단배수    물넘이 포장    측점 No, + 측점거리    경사각도    각도 수기입력    구조    도수로, 돌붙임
diff --git a/docs/raw/구조물정의_표/04_횡단배수_세월교.md b/docs/raw/구조물정의_표/04_횡단배수_세월교.md
new file mode 100644
index 000000000..16a74addd
--- /dev/null
+++ b/docs/raw/구조물정의_표/04_횡단배수_세월교.md
@@ -0,0 +1,8 @@
+# 구조물 표 04 — 횡단배수 › 세월교 (사용자 10-5 · 원문 그대로)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목    컨테이너 2    컨테이너 2 옵션항목    컨테이너 3    컨테이너 3 옵션항목
+            (필수)컨테이너 제목 :  세월교        (필수)유입 구조        (필수) 유출 구조
+횡단배수    세월교    측점 No, + 측점거리    관경    800, 1000, 1200, 1500    구조    없음, 날개벽, 흙막이    구조    없음, 날개벽, 흙막이
+            월류 폭    수기 입력
+            월류 높이    월류 폭과 높이는 연동 자동계산
+            수량(련)    수기 입력
diff --git a/docs/raw/구조물정의_표/05_횡단배수_노출형횡단수로_개거.md b/docs/raw/구조물정의_표/05_횡단배수_노출형횡단수로_개거.md
new file mode 100644
index 000000000..0fefba539
--- /dev/null
+++ b/docs/raw/구조물정의_표/05_횡단배수_노출형횡단수로_개거.md
@@ -0,0 +1,6 @@
+# 구조물 표 05 — 횡단배수 › 노출형 횡단수로 · 개거(겉도랑) (사용자 10-5 · 원문 그대로)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목
+            컨테이너 없는 항목 측점 하단에 구조물 조합 연결 항목 넣기
+횡단배수    노출형 횡단수로    측점 No, + 측점거리
+횡단배수    개거(겉도랑)    측점 No, + 측점거리
diff --git a/docs/raw/구조물정의_표/06_횡단배수_맹암거.md b/docs/raw/구조물정의_표/06_횡단배수_맹암거.md
new file mode 100644
index 000000000..7b319babc
--- /dev/null
+++ b/docs/raw/구조물정의_표/06_횡단배수_맹암거.md
@@ -0,0 +1,7 @@
+# 구조물 표 06 — 횡단배수 › 맹암거 (새 종류 · 사용자 10-5 · 원문 그대로)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목
+횡단배수    맹암거    측점 No, + 측점거리    (필수)컨테이너 제목 :  맹암거
+            암거 높이    수기입력
+            암거 경사    수기입력
+* 종단 배수의 암거와는 다른 내용임
diff --git a/docs/raw/구조물정의_표/07_안전부대용지_숨김.md b/docs/raw/구조물정의_표/07_안전부대용지_숨김.md
new file mode 100644
index 000000000..4b3636e7f
--- /dev/null
+++ b/docs/raw/구조물정의_표/07_안전부대용지_숨김.md
@@ -0,0 +1,25 @@
+# 구조물 표 07 — 안전부대용지 · 종단배수 · 계류사방 (사용자 10-5 · 원문 그대로)
+
+사용자: 다음 종단배수 전체 항목은 구조물 연결 지정 없으며 현재처럼 숨김처리. 계류사방 항목도 숨김처리
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목
+안전부대용지    대피로    측점 No, + 측점거리    (필수)컨테이너 제목 : 상세 내용
+            상세    대피소, 정차/작업장, 차돌림곳
+
+            컨테이너 없는 항목 측점 하단에 구조물 조합 연결 항목 넣기
+안전부대용지    반사경    측점 No, + 측점거리
+안전부대용지    경계석    측점 No, + 측점거리
+안전부대용지    위험표시    측점 No, + 측점거리
+안전부대용지    국가지점번호판    측점 No, + 측점거리
+안전부대용지    취수정    측점 No, + 측점거리
+안전부대용지    준공표지판    측점 No, + 측점거리
+안전부대용지    차단기    측점 No, + 측점거리
+안전부대용지    취수정    측점 No, + 측점거리   (원문에 두 번 · 하나로 봄)
+
+(덧 · 사용자 10-5)
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목
+            (필수)컨테이너 제목 : 상세 내용
+안전부대용지    가드레일    측점 No, + 측점거리    형태    수기입력
+            길이    수기입력
+            기준측점 전    수기입력(길이 + 기준측점 전/후에 따라 연동 계산)
+            기준측점 후    수기입력(길이 + 기준측점 전/후에 따라 연동 계산)
diff --git a/docs/raw/구조물정의_표/08_사토장_토취장_노면공_기타.md b/docs/raw/구조물정의_표/08_사토장_토취장_노면공_기타.md
new file mode 100644
index 000000000..8f544555e
--- /dev/null
+++ b/docs/raw/구조물정의_표/08_사토장_토취장_노면공_기타.md
@@ -0,0 +1,17 @@
+# 구조물 표 08 — 안전부대용지 사토장 · 토취장 · 노면공 콘크리트 포장 · 기타 (사용자 10-5 · 원문 그대로)
+
+구조물군    상세 종류    기본 옵션    컨테이너 1     컨테이너 1 옵셩 항목    …    상세 설계     필수    선택
+안전부대용지    유용토운반작업장(사토장)    측점 No, + 측점거리    (필수)컨테이너 제목 : 상세 내용
+            사토장 부피    수기입력
+
+안전부대용지    토사채취장(토취장)    측점 No, + 측점거리    (필수)컨테이너 제목 : 상세 내용
+            토취장 부피    수기입력
+
+노면공    콘크리트 포장    측점 No, + 측점거리    (필수)컨테이너 제목 : 상세 내용
+            포장사양    콘크리트, XXX
+            높이    수기입력
+
+기타    수기입력    측점 No, + 측점거리    (선택)컨테이너 제목 : 상세 내용    (상세 설계) 도수로(or 돌붙임)
+            비고    수기 입력    (상세 설계) 도수로(or 돌붙임)    관보호공, 옹벽, 돌쌓기, 흙막이, 큰톨쌓기 가 같은 형상으로 보임.
+
+(가드레일은 표 07 덧과 같음)
diff --git a/resources/master_template/labor/item3.json b/resources/master_template/labor/item3.json
index b512db52a..964bcab3f 100644
--- a/resources/master_template/labor/item3.json
+++ b/resources/master_template/labor/item3.json
@@ -11,21 +11,44 @@
   "담은로직": [
     {
       "로직": "GF000219",
+      "별칭": null,
       "메모": "메쌓기 — 돌쌓기 인력",
       "입력값": {},
       "수량": null
     },
     {
       "로직": "GF000119",
+      "별칭": null,
       "메모": "노체포설 — 굴착기 0.7㎥",
       "입력값": {},
       "수량": null
     },
     {
       "로직": "GF000137",
+      "별칭": null,
       "메모": "운반 — 중기운반 트레일러(20ton)",
       "입력값": {},
       "수량": null
+    },
+    {
+      "참조": {
+        "층": "system",
+        "주인": null,
+        "키": "SP-000001"
+      },
+      "별칭": null,
+      "메모": null,
+      "수량": null
+    },
+    {
+      "참조": {
+        "층": "system",
+        "주인": null,
+        "키": "SC-000001"
+      },
+      "별칭": null,
+      "메모": null,
+      "수량": null
     }
   ],
   "자재": [],
@@ -43,6 +66,28 @@
           "경비": 0,
           "계": 79279.668
         },
+        "줄": [
+          {
+            "이름": "석공",
+            "단위": "인",
+            "수량": 0.195,
+            "단가": 268908,
+            "금액": 52437.06,
+            "비목": {
+              "노무비": 52437.06
+            }
+          },
+          {
+            "이름": "보통인부",
+            "단위": "인",
+            "수량": 0.156,
+            "단가": 172068,
+            "금액": 26842.608,
+            "비목": {
+              "노무비": 26842.608
+            }
+          }
+        ],
         "까닭": null,
         "수량": null,
         "수량출처": "없음",
@@ -59,6 +104,20 @@
           "경비": 1012.3273551844981,
           "계": 4522.956900158043
         },
+        "줄": [
+          {
+            "이름": "굴착기(무한궤도) 0.7㎥",
+            "단위": "시간",
+            "수량": 0.04122861265718408,
+            "단가": 109704.31961333334,
+            "금액": 4522.956900158043,
+            "비목": {
+              "노무비": 2433.321308321308,
+              "재료비": 1077.3082366522367,
+              "경비": 1012.3273551844981
+            }
+          }
+        ],
         "까닭": null,
         "수량": null,
         "수량출처": "없음",
@@ -75,18 +134,110 @@
           "경비": 13280.479259259258,
           "계": 83943.98719017902
         },
+        "줄": [
+          {
+            "이름": "트럭 트랙터 및 평판트레일러 20ton",
+            "단위": "시간",
+            "수량": 0.7670370370370371,
+            "단가": 109439.28798333333,
+            "금액": 83943.98719017902,
+            "비목": {
+              "노무비": 38181.82530864197,
+              "재료비": 32481.682622277778,
+              "경비": 13280.479259259258
+            }
+          },
+          {
+            "이름": "트럭 10.5ton",
+            "단위": "시간",
+            "수량": 0,
+            "단가": 97740.38995333333,
+            "금액": 0,
+            "비목": {
+              "노무비": 0,
+              "재료비": 0,
+              "경비": 0
+            }
+          }
+        ],
         "까닭": null,
         "수량": null,
         "수량출처": "없음",
         "반영": null
+      },
+      {
+        "참조": {
+          "층": "system",
+          "주인": null,
+          "키": "SP-000001"
+        },
+        "이름": "돌쌓기 메쌓기(인력)",
+        "알약": "참조|system||SP-000001",
+        "분모": "원/㎡",
+        "배": 1,
+        "기준": {
+          "노무비": 79279.668,
+          "재료비": 0,
+          "경비": 0,
+          "계": 79279.668
+        },
+        "까닭": null,
+        "원로직": "GF000219",
+        "줄": [
+          {
+            "이름": "석공",
+            "단위": "인",
+            "수량": 0.195,
+            "단가": 268908,
+            "금액": 52437.06,
+            "비목": {
+              "노무비": 52437.06
+            }
+          },
+          {
+            "이름": "보통인부",
+            "단위": "인",
+            "수량": 0.156,
+            "단가": 172068,
+            "금액": 26842.608,
+            "비목": {
+              "노무비": 26842.608
+            }
+          }
+        ],
+        "수량": null,
+        "수량출처": "없음",
+        "반영": null
+      },
+      {
+        "참조": {
+          "층": "system",
+          "주인": null,
+          "키": "SC-000001"
+        },
+        "이름": "테스트 사전조합",
+        "알약": "참조|system||SC-000001",
+        "분모": null,
+        "배": 1,
+        "기준": {
+          "노무비": 0,
+          "재료비": 0,
+          "경비": 0,
+          "계": 0
+        },
+        "까닭": null,
+        "안": [],
+        "수량": null,
+        "수량출처": "없음",
+        "반영": null
       }
     ],
     "자재": [],
     "기준합": {
-      "노무비": 119894.81461696328,
+      "노무비": 199174.48261696327,
       "재료비": 33558.99085893002,
       "경비": 14292.806614443756,
-      "계": 167746.61209033706
+      "계": 247026.28009033707
     },
     "반영합": {
       "노무비": 0,
diff --git a/resources/master_template/precombo/SC-000001.json b/resources/master_template/precombo/SC-000001.json
new file mode 100644
index 000000000..cb35b6b86
--- /dev/null
+++ b/resources/master_template/precombo/SC-000001.json
@@ -0,0 +1,25 @@
+{
+  "종류": "사전조합",
+  "키": "SC-000001",
+  "이름": "테스트 사전조합",
+  "단위": null,
+  "담은로직": [
+    {
+      "로직": "GF000297",
+      "입력값": {},
+      "수량": {
+        "손": 1
+      },
+      "메모": null
+    },
+    {
+      "로직": "GF000289",
+      "입력값": {},
+      "수량": {
+        "손": 1
+      },
+      "메모": null
+    }
+  ],
+  "본뜬": null
+}
diff --git a/resources/master_template/promote/SP-000001.json b/resources/master_template/promote/SP-000001.json
new file mode 100644
index 000000000..5f0020627
--- /dev/null
+++ b/resources/master_template/promote/SP-000001.json
@@ -0,0 +1,14 @@
+{
+  "종류": "단가승격",
+  "키": "SP-000001",
+  "이름": "돌쌓기 메쌓기(인력)",
+  "단위": "원/㎡",
+  "배": 1,
+  "담은로직": [
+    {
+      "로직": "GF000219",
+      "입력값": {}
+    }
+  ],
+  "본뜬": null
+}
diff --git a/resources/master_template/table/구조물집계표.json b/resources/master_template/table/구조물집계표.json
index 18996f1df..cb8d516a9 100644
--- a/resources/master_template/table/구조물집계표.json
+++ b/resources/master_template/table/구조물집계표.json
@@ -103,11 +103,11 @@
       "자재조합": null,
       "경로": [
         "기슭막이",
-        "ㄴㄴ"
+        "ㄷ2ㄷ"
       ],
       "머리": [
         "기슭막이",
-        "ㄴㄴ",
+        "ㄷ2ㄷ",
         null,
         null,
         null,
diff --git a/resources/master_template/구조물옵션그룹.json b/resources/master_template/구조물옵션그룹.json
deleted file mode 100644
index 0967ef424..000000000
--- a/resources/master_template/구조물옵션그룹.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/resources/master_template/구조물옵션표시.json b/resources/master_template/구조물옵션표시.json
deleted file mode 100644
index 0967ef424..000000000
--- a/resources/master_template/구조물옵션표시.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/resources/master_template/구조물정의.json b/resources/master_template/구조물정의.json
new file mode 100644
index 000000000..5b2e2bf07
--- /dev/null
+++ b/resources/master_template/구조물정의.json
@@ -0,0 +1,3359 @@
+{
+  "판": 6,
+  "schema_version": 1,
+  "comment": "B05 구조물 타입 레지스트리 정본. 근거·옵션 상세는 PLAN.md 구조물 리스트와 resources/knowledge/technical_info/01_임도 참조. 2026-08-17 선택지 재편: B군(종단배수)·F군(생태/녹화)·G군(노면공)은 enabled:false 보존 — B05 선택지에서 빠지고 B06 개별 횡단도 옵션으로 재사용한다. 바닥막이(bed_sill)·생태연못(eco_pond)은 임도 미사용 확정으로 삭제. 배관·BOX암거·물넘이·세월교는 pipe_points.json 정본 관리(managed_by) — structures.json에 저장하지 않으며, 배관 부속(유형/집수정/기슭막이/돌붙임)·날개벽 옵션 정의는 B06/B07 필수 승격의 선언 근거다. ★기본값 원칙(2026-08-16 크로스체크 2차): default를 두는 것은 ①법정이 등급과 무관하게 못박은 단일 수치 ②사용자가 개발 단계에서 확정한 값 ③도메인 수치가 아닌 표시용 문자열, 이 셋뿐이다. 재료·형식 같은 설계자 판단 선택지와 미확정 제원은 default 없이 required로 두어 사용자가 직접 고르게 한다 (pipe_diameter_mm 1000 = 별표2 원칙값+사용자 확정 — 화이트리스트 등재). BOX암거 본체 2.0×2.0·날개벽 유입/유출 있음·짧은쪽 높이 1m·길이 2m·각도 45°는 2026-08-17 사용자 확정값이다 — 본체 규격은 실무 관측 규격(2.0×2.0·3.0×3.0)을 폼에서 프리셋 select로 받고 필요 시 사용자 지정으로 자유 입력하되, 저장 키는 body_width_m·body_height_m 숫자 그대로다(프리셋 전용 키를 만들지 않는다). 이 값들은 B05 서브폼이 실제로 받으므로 phase를 detail로 두지 않는다. ★보호공 개편(2026-08-17 사용자 지시): 구 `*_pitching`(있음/없음) + `*_pitching_finish`(찰/메) 두 축을 `*_protection` 한 축(돌붙임(찰)·돌붙임(메)·도수로)으로 합쳤다 — 도수로·산비탈수로(B4)는 유출부에서 돌붙임 대신 쓰는 공종이라 별도 구조물이 아니라 보호공 선택지로 받는다. \"없음\"은 삭제(물이 흐르는 자리라 보호공 필수). 치수는 배타 — 돌붙임이면 `*_protection_area_m2`(10㎡), 도수로면 `*_protection_width_m`(1m, 지식DB 수치 근거 없음·사용자 확정, 실무 확인 후 개선). 구 저장분은 `common_util_drainage_pipes.parse_pipe_points`가 새 키로 옮긴다.",
+  "구조물군": {
+    "A": "A 횡단배수",
+    "B": "B 종단배수",
+    "C": "C 사면안정",
+    "D": "D 계류·사방",
+    "E": "E 안전·부대·용지",
+    "F": "F 생태·녹화",
+    "G": "G 노면공",
+    "호환": "기타"
+  },
+  "동작": {
+    "계곡통과시설": "관 지점 정본(pipe_points.json) 시설 — 부속 옵션 서브폼을 손코딩으로 그림 · 저장은 폼이 아는 칸만 갈아 끼움",
+    "유입유출_묶음": "관 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹",
+    "기슭막이_한벌": "기슭막이 형태 · 길이 · 높이 · 바닥 보호공 한 벌 — 관 유입 · 유출 · 독립 기슭막이가 같은 조각",
+    "BOX_본체규격": "BOX암거 본체 규격 프리셋 고르기(폭 × 높이 한 칸)",
+    "날개벽": "날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 조각",
+    "월류단면": "월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 줄 · 필요 수심 미만은 되돌림",
+    "포장_물넘이_겹침": "포장 구간이 물넘이포장을 품으면 앞 · 뒤로 나눔 · 끝만 걸치면 저장 멈춤"
+  },
+  "types": [
+    {
+      "type_id": "pipe",
+      "group": "A",
+      "name": "배관",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#4f8ef7",
+        "abbr": "배수관"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false,
+          "enabled": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "inlet_type",
+          "label": "유입구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이",
+            "집수정"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "wing_wall_type",
+          "label": "관보호공 날개벽",
+          "input": "select",
+          "choices": [
+            "A-TYPE",
+            "C-TYPE",
+            "A-TYPE+집수정"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 날개벽을 안 셈 — 고르면 그 형식의 개소당 원단위로 한 줄이 섬(Ø800·Ø1000 만 있음)"
+        },
+        {
+          "key": "inlet_basin_form",
+          "label": "집수정 형식",
+          "input": "select",
+          "choices": [
+            "동물이동형",
+            "□형(기본형)",
+            "돌집수정 ㄴ형",
+            "돌집수정 ㄷ형"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_material",
+          "label": "집수정 형태",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "조립식 주철맨홀",
+            "돌쌓기(찰)",
+            "돌쌓기(메)"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_length_m",
+          "label": "집수정 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_before_m",
+          "label": "집수정 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_after_m",
+          "label": "집수정 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_form",
+          "label": "유입 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(찰)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_length_m",
+          "label": "유입 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "inlet_revet_before_m",
+          "label": "유입 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_after_m",
+          "label": "유입 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_height_m",
+          "label": "유입 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "outlet_type",
+          "label": "유출구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "outlet_revet_form",
+          "label": "유출 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_length_m",
+          "label": "유출 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "outlet_revet_before_m",
+          "label": "유출 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_after_m",
+          "label": "유출 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_height_m",
+          "label": "유출 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "box_culvert",
+      "group": "A",
+      "name": "BOX암거",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#3b6fd4",
+        "abbr": "암거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "body_width_m",
+          "label": "본체 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "body_height_m",
+          "label": "본체 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "length_m",
+          "label": "연장(계류 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 수량이 안 섬 — 구체 길이는 설계자 입력(기본값 없음 · 2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wall_thickness_m",
+          "label": "측벽 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 벽 0.3 · KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "slab_thickness_m",
+          "label": "상·저판 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.25,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 판 0.25 — ⚠ KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ 에 못 미침(임도 예제 0.25 · KDS 도로 최소 300㎜) · 설계자가 고름",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "haunch_m",
+          "label": "헌치(모따기) 크기",
+          "input": "number",
+          "unit": "m",
+          "default": 0.2,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 0.2×0.2 · 실무 울진 기번3 구조도 2×2 도 0.2 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "blinding_thickness_m",
+          "label": "기초(버림) 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.1,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 기초 0.1(양쪽 0.1 여유) · 실무 울진 기번3 구조도 2×2 버림 0.1 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "trench_depth_m",
+          "label": "평균 터파기고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 구체 터파기·되메우기가 안 섬 — 원지반에서 터파기 바닥(기초잡석 밑)까지 · 토공집계로 감(2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "ford_pavement",
+      "group": "A",
+      "name": "물넘이포장",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#2f9e8f",
+        "abbr": "물넘이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "물넘이 월류 폭 기본 5m — 사용자 확정값(엔진 FORD_PAVEMENT_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "ford_slope_pct",
+          "label": "바닥 경사(유입→유출)",
+          "input": "number",
+          "unit": "%",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "thickness_cm",
+          "label": "포장 두께",
+          "input": "number",
+          "unit": "㎝",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 표가 안 서고 「두께를 적어야 섬」 사유가 뜸 — 두께로 관측 원단위(울진 20㎝)를 고름(2026-09-14 A3)"
+        },
+        {
+          "key": "length_m",
+          "label": "포장 길이(노폭 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 면적(월류 폭 × 길이)이 0 이라 표가 안 서고 사유가 뜸 — 노견까지 전폭을 적음(2026-09-14 A3)"
+        }
+      ]
+    },
+    {
+      "type_id": "ford_bridge",
+      "group": "A",
+      "name": "세월교",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#28857a",
+        "abbr": "세월교"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "pipe_count",
+          "label": "배관 수량",
+          "input": "number",
+          "unit": "련",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "세월교 월류 폭 기본 10m — 사용자 확정값(엔진 FORD_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "cross_drain_exposed",
+      "group": "A",
+      "name": "노출형 횡단수로",
+      "placement": "point",
+      "style": {
+        "color": "#5aa7e8",
+        "abbr": "횡수로"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "open_ditch",
+      "group": "A",
+      "name": "개거(겉도랑)",
+      "placement": "point",
+      "style": {
+        "color": "#6d9bd1",
+        "abbr": "개거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ditch_spec",
+          "label": "규격",
+          "input": "select",
+          "choices": [
+            "콘크리트 개거 150×200",
+            "L형수로 H=0.2"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 붙박이(콘크리트 개거)로 돎"
+        },
+        {
+          "key": "length_m",
+          "label": "연장",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 표가 안 서고 「연장을 적어야 섬」 사유가 뜸 — 개거는 m당 원단위라 연장이 곧 밑수(2026-09-14 A2)"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_side",
+      "enabled": false,
+      "group": "B",
+      "name": "측구(옆도랑)",
+      "design_owner": "횡단 설계",
+      "placement": "interval",
+      "style": {
+        "color": "#2eaadc",
+        "abbr": "측구"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "일반형(제형)",
+            "L형",
+            "U형",
+            "J형"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "depth_cm",
+          "label": "깊이",
+          "input": "number",
+          "unit": "cm",
+          "default": 30
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_ridge",
+      "enabled": false,
+      "group": "B",
+      "name": "산마루측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2e8bdc",
+        "abbr": "산마루"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_berm",
+      "enabled": false,
+      "group": "B",
+      "name": "소단측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2ec5dc",
+        "abbr": "소단구"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "사면 쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "chute",
+      "enabled": false,
+      "group": "B",
+      "name": "도수로·산비탈수로",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9bb8",
+        "abbr": "도수로"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌",
+            "콘크리트",
+            "블록판",
+            "벤치플륨관",
+            "반원관"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "section",
+          "label": "단면형",
+          "input": "select",
+          "choices": [
+            "반달꼴",
+            "U자형",
+            "사다리꼴"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "slope_drain",
+      "enabled": false,
+      "group": "B",
+      "name": "절토사면 배수로",
+      "placement": "interval",
+      "style": {
+        "color": "#28b1a1",
+        "abbr": "사면로"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "underdrain",
+      "enabled": false,
+      "group": "B",
+      "name": "맹암거",
+      "placement": "interval",
+      "style": {
+        "color": "#1f7fb8",
+        "abbr": "맹암거"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "note",
+          "label": "규격",
+          "input": "text",
+          "default": ""
+        }
+      ]
+    },
+    {
+      "type_id": "retaining_wall",
+      "group": "C",
+      "name": "옹벽",
+      "placement": "interval",
+      "style": {
+        "color": "#e07a2e",
+        "abbr": "옹벽"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "default_basis": "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음",
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "중력식",
+            "반중력식",
+            "캔틸레버식",
+            "부벽식",
+            "식생옹벽블럭"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_wet",
+      "group": "C",
+      "name": "돌쌓기(찰)",
+      "placement": "interval",
+      "style": {
+        "color": "#d0692a",
+        "abbr": "찰쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤3.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_dry",
+      "group": "C",
+      "name": "돌쌓기(메)",
+      "placement": "interval",
+      "style": {
+        "color": "#c25d2c",
+        "abbr": "메쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)",
+          "warn_above": 2,
+          "warn_message": "메쌓기 높이 기준을 넘음 — 임도기술교본 7-3:27 「메쌓기는 2.0m 이하」 · 품셈 13-4-4 [주]⑪(원문 L7192) 「높이 3m 이상이면 전부 또는 하부를 찰쌓기」 · 막지 않음(설계자 확인)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "soil_guard",
+      "group": "C",
+      "name": "흙막이",
+      "placement": "interval",
+      "style": {
+        "color": "#b8742e",
+        "abbr": "흙막이"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌(찰)",
+            "돌(메)",
+            "블록쌓기",
+            "돌망태",
+            "흙포대",
+            "통나무쌓기",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 올리지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 옮기지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 돌쌓기 기본값으로 서고 「기본값으로 섰음」이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "default_basis": "「채집」 — 별표2 「야면석 등은 가급적 현장에서 채취·사용」 권고. 구조물마다 바꿀 수 있음",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        }
+      ]
+    },
+    {
+      "type_id": "boulder_masonry",
+      "group": "C",
+      "name": "큰돌쌓기",
+      "placement": "interval",
+      "style": {
+        "color": "#a86a2a",
+        "abbr": "큰돌"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_cm",
+          "label": "돌규격",
+          "input": "select",
+          "choices": [
+            "40~60",
+            "60~80",
+            "80~100"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bond",
+          "label": "쌓기 방식",
+          "input": "select",
+          "choices": [
+            "메쌓기",
+            "찰쌓기"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 채움 콘크리트를 품에 포함 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "berm",
+      "group": "C",
+      "name": "소단",
+      "placement": "interval",
+      "style": {
+        "color": "#7f9a63",
+        "abbr": "소단"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "안쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "erosion_check",
+      "group": "D",
+      "name": "골막이",
+      "placement": "point",
+      "style": {
+        "color": "#7a52c7",
+        "abbr": "골막이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "돌",
+            "돌망태",
+            "콘크리트",
+            "통나무",
+            "바자",
+            "흙"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "spillway",
+          "label": "방수로",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이 ℓ3",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "top_length_m",
+          "label": "상장 ⓐ (윗변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bottom_length_m",
+          "label": "하장 ⓑ (아랫변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 4.5
+        },
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "bed_sill",
+      "group": "D",
+      "name": "바닥막이",
+      "placement": "point",
+      "style": {
+        "color": "#7c5f3b",
+        "abbr": "바닥"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌붙임(찰)",
+            "돌붙임(메)"
+          ],
+          "default": "돌붙임(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 평면적(돌붙임 ㎡)이라 기울기 몫이 없음 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "check_dam_small",
+      "group": "D",
+      "name": "소형사방댐(복합형)",
+      "placement": "point",
+      "style": {
+        "color": "#6b46b8",
+        "abbr": "사방댐"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revetment",
+      "group": "D",
+      "name": "기슭막이",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#9b6bdc",
+        "abbr": "기슭"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "양쪽",
+            "좌",
+            "우"
+          ],
+          "default": "양쪽",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「좌」는 셀렉트 첫 항목일 뿐 도메인 확정값이 아님 — 측점마다 사용자가 고름"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 13-4-4 [주]⑩ 뒷길이 표준 하한(높이·찰/메로 · 범위 안 가장 작은 규격 — 예 메쌓기 1.5~3m 는 36~45㎝ 라 45㎝)으로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "설계자 입력 — 계획홍수위 + 0.5~0.7m(사방기술교본 2-나:141 · 3-가:181 · 사방(계류) 교본 기준). 비우면 줄만 서고 미확정이라 금액에 안 들어감 · 옛 기본 2.5 는 근거 없어 걷음(2026-09-14 브레인 판정)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "refuge",
+      "group": "E",
+      "name": "대피소",
+      "placement": "interval",
+      "style": {
+        "color": "#2fa84f",
+        "abbr": "대피소"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 15
+        }
+      ]
+    },
+    {
+      "type_id": "work_yard",
+      "group": "E",
+      "name": "정차·작업장",
+      "placement": "interval",
+      "style": {
+        "color": "#268f43",
+        "abbr": "작업장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 7
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 20
+        }
+      ]
+    },
+    {
+      "type_id": "turnaround",
+      "group": "E",
+      "name": "차돌림곳",
+      "placement": "site",
+      "style": {
+        "color": "#37b95a",
+        "abbr": "차돌림"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        }
+      ]
+    },
+    {
+      "type_id": "mirror",
+      "group": "E",
+      "name": "반사경",
+      "placement": "point",
+      "style": {
+        "color": "#43c76b",
+        "abbr": "반사경"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": [
+        {
+          "key": "facing",
+          "label": "방향",
+          "input": "select",
+          "choices": [
+            "좌",
+            "우",
+            "양면"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "guardrail",
+      "group": "E",
+      "name": "가드레일·경계석·위험표지",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9e46",
+        "abbr": "가드"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "kind",
+          "label": "종류",
+          "input": "select",
+          "choices": [
+            "가드레일",
+            "경계석",
+            "위험표지"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "position_sign",
+      "group": "E",
+      "name": "국가지점번호판",
+      "placement": "point",
+      "style": {
+        "color": "#53a832",
+        "abbr": "번호판"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "barrier_gate",
+      "group": "E",
+      "name": "차단기",
+      "placement": "point",
+      "style": {
+        "color": "#3f9e2e",
+        "abbr": "차단기"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "completion_sign",
+      "group": "E",
+      "name": "준공표지판",
+      "placement": "point",
+      "style": {
+        "color": "#66b344",
+        "abbr": "준공"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "spoil_bank",
+      "group": "E",
+      "name": "유용토운반작업장(구 사토장)",
+      "placement": "interval",
+      "style": {
+        "color": "#8c9a2e",
+        "abbr": "사토장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "쌓는 쪽",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「자동(성토 쪽)」 — 흙은 성토 쪽에 쌓는다는 지금까지의 동작을 이어받는 표식. 측점마다 좌·우로 바꿈"
+        },
+        {
+          "key": "fill_slope_ratio",
+          "label": "비탈 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 그 측점의 노선 성토 기울기를 그대로 씀 — 지식DB 가 「기본 비탈기울기는 근거에 없다」고 못 박은 자리"
+        },
+        {
+          "key": "extra_distance_m",
+          "label": "추가 운반거리",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "0 = 「추가 없음」 — 노선 안 사토장은 측점 누가거리로 거리가 나오므로 이 칸은 외부 사토장 대비 여벌"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "borrow_pit",
+      "group": "E",
+      "name": "토사채취장(토취장)",
+      "placement": "site",
+      "style": {
+        "color": "#7d8a2a",
+        "abbr": "토취장"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "wildlife_path",
+      "enabled": false,
+      "group": "F",
+      "name": "야생동물 이동통로",
+      "placement": "point",
+      "style": {
+        "color": "#3aa88f",
+        "abbr": "동물길"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "경사로",
+            "자연형계단"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revegetation",
+      "enabled": false,
+      "group": "F",
+      "name": "비탈면 녹화",
+      "placement": "interval",
+      "style": {
+        "color": "#4cb84c",
+        "abbr": "녹화"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "method",
+          "label": "공법",
+          "input": "select",
+          "choices": [
+            "씨뿌리기(줄파종)",
+            "새심기",
+            "선떼붙이기",
+            "줄떼",
+            "평떼",
+            "비탈덮기",
+            "녹생토 뿜어붙이기",
+            "조공",
+            "편책",
+            "나무심기"
+          ],
+          "default": null,
+          "default_basis": "「초류종자 살포」는 여기 없음 — 토공집계에서 사면 전체로 섬(품셈 5-24 · 두 곳에 두면 이중계상 · 2026-09-15 브레인)",
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "face",
+          "label": "대상 면",
+          "input": "select",
+          "choices": [
+            "절토면",
+            "성토면",
+            "양쪽"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "cover_kind",
+          "label": "덮개(비탈덮기)",
+          "input": "select",
+          "choices": [
+            "거적",
+            "짚망",
+            "방초·야자섬유매트"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비탈덮기일 때만 고름 — 비면 비탈덮기 줄이 안 섬(품셈 5-25 거적덮기 ㎡ · 5-28-1 짚망 · 5-28-2 매트 · 재료가 공종을 가름)"
+        },
+        {
+          "key": "step_height_m",
+          "label": "단 직고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기·조공의 단 사이 직고 — 교본은 범위로만 줌(선떼 직고 1~2m · 조공 1.0~1.2m) · 기본값 없음 · 비면 선떼 연장(품셈 5-16-1 [주]② 대상지 직고 ÷ 단 직고 × 연장)이 안 섬"
+        },
+        {
+          "key": "sod_grade",
+          "label": "선떼 급수",
+          "input": "select",
+          "choices": [
+            "1급",
+            "2급",
+            "3급",
+            "4급",
+            "5급",
+            "6급",
+            "7급",
+            "8급",
+            "9급"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기의 급수 — 교본은 1~9급 범위만(6~7급을 많이 씀) · 기본값 없음 · 비면 m당 떼 매수(사방기술교본 표 2-2-6)가 안 섬"
+        },
+        {
+          "key": "sod_size",
+          "label": "선떼 떼 크기",
+          "input": "select",
+          "choices": [
+            "대형 40×40",
+            "소형 18×18"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "사방기술교본 표 2-2-6 이 대형(40×40)·소형(18×18) 두 줄을 나란히 줌 — 우리가 고를 자리가 아니라 기본값 없음 · 비면 선떼 떼 매수가 안 섬"
+        },
+        {
+          "key": "cutting_soil",
+          "label": "단끊기 토질",
+          "input": "select",
+          "choices": [
+            "보통토사",
+            "경질ㆍ고사점토 및 자갈섞인 점토",
+            "호박돌 섞인 토사"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "품셈 5-16-1 단끊기 표의 토질 셋 — B06 지반(토사/암)과 다른 축이라 자동으로 안 고름 · 비면 단끊기 조각만 막힘"
+        }
+      ]
+    },
+    {
+      "type_id": "pavement_concrete",
+      "group": "G",
+      "name": "콘크리트 포장",
+      "placement": "interval",
+      "style": {
+        "color": "#8a8f98",
+        "abbr": "포장"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 포장층 두께(표준 횡단면 설정 · 기본 0.2m = 임도기술교본 3-2 「두께 0.2m」)를 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "width_m",
+          "label": "포장 폭",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 노폭(구간 측점의 차도 표준 폭 · 교본 3-2 「포장 폭 3.0m」 · 실무 관측 3.5~4.0)을 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "widening_area_m2",
+          "label": "확폭 면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 곡선부 확폭을 측점 사이 평균 × 거리로 더함(교본 3-2 「곡선부에는 확폭」) — 확폭이 없으면 0 을 적을 것"
+        },
+        {
+          "key": "joint_spacing_m",
+          "label": "수축줄눈 간격",
+          "input": "number",
+          "unit": "m",
+          "default": 6,
+          "default_basis": "제안값 · 임도기술교본 부록 4-7 7-1 3.5.1 「수축줄눈의 간격은 4-6m를 기준」 · 실무 소광 6m 관측 · 바꿀 수 있음",
+          "phase": "detail"
+        },
+        {
+          "key": "separation_sheet",
+          "label": "비닐(깔기·양생)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 비닐 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「양생 재료비(비닐 등)는 별도 계상」이라 설계자가 고름(기본값 없음)"
+        },
+        {
+          "key": "wire_mesh",
+          "label": "철망",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 철망 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「철망재료비는 별도 계상」 · 교본 부록 7-1 3.4 「설계도서에 따라」 · 실무 소광 「철망포함」 관측"
+        }
+      ]
+    },
+    {
+      "type_id": "gravel_surfacing",
+      "enabled": false,
+      "group": "G",
+      "name": "쇄석(자갈) 포설",
+      "placement": "interval",
+      "style": {
+        "color": "#9aa0a8",
+        "abbr": "쇄석"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "etc",
+      "group": "호환",
+      "name": "기타",
+      "placement": "point",
+      "style": {
+        "color": "#98a2b3",
+        "abbr": "기타"
+      },
+      "drawing_views": [
+        "profile"
+      ],
+      "options": [
+        {
+          "key": "name",
+          "label": "이름",
+          "input": "text",
+          "default": "기타 구조물"
+        }
+      ]
+    }
+  ],
+  "종류": {
+    "pipe": {
+      "동작": [
+        "계곡통과시설",
+        "유입유출_묶음",
+        "기슭막이_한벌"
+      ],
+      "이름": {
+        "pipe.diameter": "관경",
+        "pipe.diameter=800": "800",
+        "pipe.diameter=1000": "1000",
+        "pipe.diameter=1200": "1200",
+        "pipe.diameter=1500": "1500",
+        "pipe.length": "관 길이 (m)",
+        "inlet.structure": "구조",
+        "inlet.structure=집수정": "집수정",
+        "inlet.structure=기슭막이": "흙막이",
+        "inlet.form": "형태",
+        "inlet.form=돌쌓기(찰)": "돌 쌓기(찰)",
+        "inlet.form=돌쌓기(메)": "돌 쌓기(메)",
+        "inlet.form=콘크리트": "콘크리트",
+        "inlet.form=돌망태": "돌망태",
+        "inlet.form=통나무·목재틀": "통나무/목재틀",
+        "inlet.form=바자": "바자",
+        "inlet.form=I": "I형",
+        "inlet.form=L": "L형",
+        "inlet.form=U": "ㄷ형",
+        "inlet.length": "길이 (m)",
+        "inlet.height": "높이 (m)",
+        "inlet.before": "기준측점 전 (m)",
+        "inlet.after": "기준측점 후 (m)",
+        "outlet.structure": "구조",
+        "outlet.structure=기슭막이": "흙막이",
+        "outlet.form": "형태",
+        "outlet.form=돌쌓기(찰)": "돌 쌓기(찰)",
+        "outlet.form=돌쌓기(메)": "돌 쌓기(메)",
+        "outlet.form=콘크리트": "콘크리트",
+        "outlet.form=돌망태": "돌망태",
+        "outlet.form=통나무·목재틀": "통나무/목재틀",
+        "outlet.form=바자": "바자",
+        "outlet.length": "길이 (m)",
+        "outlet.height": "높이 (m)",
+        "outlet.before": "기준측점 전 (m)",
+        "outlet.after": "기준측점 후 (m)",
+        "soil_add": "흙막이 추가",
+        "soil_add.structure": "구조",
+        "soil_add.structure=기슭막이": "흙막이",
+        "soil_add.form": "형태",
+        "soil_add.form=돌쌓기(찰)": "돌 쌓기(찰)",
+        "soil_add.form=돌쌓기(메)": "돌 쌓기(메)",
+        "soil_add.form=콘크리트": "콘크리트",
+        "soil_add.form=돌망태": "돌망태",
+        "soil_add.form=통나무·목재틀": "통나무/목재틀",
+        "soil_add.form=바자": "바자",
+        "soil_add.length": "길이 (m)",
+        "soil_add.height": "높이 (m)",
+        "soil_add.before": "기준측점 전 (m)",
+        "soil_add.after": "기준측점 후 (m)",
+        "chute_add": "도수로/돌붙임",
+        "chute_add.structure": "구조",
+        "chute_add.structure=도수로": "도수로",
+        "chute_add.structure=돌붙임": "돌붙임"
+      }
+    },
+    "box_culvert": {
+      "동작": [
+        "계곡통과시설",
+        "BOX_본체규격",
+        "날개벽"
+      ]
+    },
+    "ford_pavement": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면"
+      ]
+    },
+    "ford_bridge": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면",
+        "날개벽"
+      ]
+    },
+    "revetment": {
+      "동작": [
+        "계곡통과시설",
+        "기슭막이_한벌"
+      ]
+    },
+    "pavement_concrete": {
+      "동작": [
+        "포장_물넘이_겹침"
+      ]
+    }
+  },
+  "표시": {
+    "pipe": {
+      "pipe_kind": false
+    }
+  },
+  "그룹": {
+    "pipe": [
+      {
+        "id": "grv6lny",
+        "이름": "관",
+        "옵션": [
+          "pipe_kind",
+          "pipe_diameter_mm"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "gnbf9m9",
+        "이름": "관 보호공(유입)",
+        "옵션": [
+          "inlet_type"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "g9lq9uk",
+        "이름": "관 보호공(유출)",
+        "옵션": [],
+        "형상": {}
+      }
+    ]
+  },
+  "배치": {},
+  "규칙": []
+}
diff --git a/B05_Profile/B05_Profile_Structure_Types.json b/resources/master_template/구조물정의_이력/판_1.json
similarity index 83%
rename from B05_Profile/B05_Profile_Structure_Types.json
rename to resources/master_template/구조물정의_이력/판_1.json
index 43d980283..feb15c0bf 100644
--- a/B05_Profile/B05_Profile_Structure_Types.json
+++ b/resources/master_template/구조물정의_이력/판_1.json
@@ -1,6 +1,26 @@
 {
+  "판": 1,
   "schema_version": 1,
   "comment": "B05 구조물 타입 레지스트리 정본. 근거·옵션 상세는 PLAN.md 구조물 리스트와 resources/knowledge/technical_info/01_임도 참조. 2026-08-17 선택지 재편: B군(종단배수)·F군(생태/녹화)·G군(노면공)은 enabled:false 보존 — B05 선택지에서 빠지고 B06 개별 횡단도 옵션으로 재사용한다. 바닥막이(bed_sill)·생태연못(eco_pond)은 임도 미사용 확정으로 삭제. 배관·BOX암거·물넘이·세월교는 pipe_points.json 정본 관리(managed_by) — structures.json에 저장하지 않으며, 배관 부속(유형/집수정/기슭막이/돌붙임)·날개벽 옵션 정의는 B06/B07 필수 승격의 선언 근거다. ★기본값 원칙(2026-08-16 크로스체크 2차): default를 두는 것은 ①법정이 등급과 무관하게 못박은 단일 수치 ②사용자가 개발 단계에서 확정한 값 ③도메인 수치가 아닌 표시용 문자열, 이 셋뿐이다. 재료·형식 같은 설계자 판단 선택지와 미확정 제원은 default 없이 required로 두어 사용자가 직접 고르게 한다 (pipe_diameter_mm 1000 = 별표2 원칙값+사용자 확정 — 화이트리스트 등재). BOX암거 본체 2.0×2.0·날개벽 유입/유출 있음·짧은쪽 높이 1m·길이 2m·각도 45°는 2026-08-17 사용자 확정값이다 — 본체 규격은 실무 관측 규격(2.0×2.0·3.0×3.0)을 폼에서 프리셋 select로 받고 필요 시 사용자 지정으로 자유 입력하되, 저장 키는 body_width_m·body_height_m 숫자 그대로다(프리셋 전용 키를 만들지 않는다). 이 값들은 B05 서브폼이 실제로 받으므로 phase를 detail로 두지 않는다. ★보호공 개편(2026-08-17 사용자 지시): 구 `*_pitching`(있음/없음) + `*_pitching_finish`(찰/메) 두 축을 `*_protection` 한 축(돌붙임(찰)·돌붙임(메)·도수로)으로 합쳤다 — 도수로·산비탈수로(B4)는 유출부에서 돌붙임 대신 쓰는 공종이라 별도 구조물이 아니라 보호공 선택지로 받는다. \"없음\"은 삭제(물이 흐르는 자리라 보호공 필수). 치수는 배타 — 돌붙임이면 `*_protection_area_m2`(10㎡), 도수로면 `*_protection_width_m`(1m, 지식DB 수치 근거 없음·사용자 확정, 실무 확인 후 개선). 구 저장분은 `common_util_drainage_pipes.parse_pipe_points`가 새 키로 옮긴다.",
+  "구조물군": {
+    "A": "A 횡단배수",
+    "B": "B 종단배수",
+    "C": "C 사면안정",
+    "D": "D 계류·사방",
+    "E": "E 안전·부대·용지",
+    "F": "F 생태·녹화",
+    "G": "G 노면공",
+    "호환": "기타"
+  },
+  "동작": {
+    "계곡통과시설": "관 지점 정본(pipe_points.json) 시설 — 부속 옵션 서브폼을 손코딩으로 그림 · 저장은 폼이 아는 칸만 갈아 끼움",
+    "유입유출_묶음": "관 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹",
+    "기슭막이_한벌": "기슭막이 형태 · 길이 · 높이 · 바닥 보호공 한 벌 — 관 유입 · 유출 · 독립 기슭막이가 같은 조각",
+    "BOX_본체규격": "BOX암거 본체 규격 프리셋 고르기(폭 × 높이 한 칸)",
+    "날개벽": "날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 조각",
+    "월류단면": "월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 줄 · 필요 수심 미만은 되돌림",
+    "포장_물넘이_겹침": "포장 구간이 물넘이포장을 품으면 앞 · 뒤로 나눔 · 끝만 걸치면 저장 멈춤"
+  },
   "types": [
     {
       "type_id": "pipe",
@@ -12,13 +32,23 @@
         "color": "#4f8ef7",
         "abbr": "배수관"
       },
-      "drawing_views": ["plan", "profile", "cross_section", "detail", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "pipe_kind",
           "label": "관종",
           "input": "select",
-          "choices": ["흄관", "VR관", "파형강관"],
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
           "default": "파형강관",
           "required": false
         },
@@ -26,7 +56,12 @@
           "key": "pipe_diameter_mm",
           "label": "관경",
           "input": "select",
-          "choices": ["800", "1000", "1200", "1500"],
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
           "unit": "mm",
           "default": "1000",
           "required": false
@@ -35,7 +70,10 @@
           "key": "inlet_type",
           "label": "유입구 구조",
           "input": "select",
-          "choices": ["기슭막이", "집수정"],
+          "choices": [
+            "기슭막이",
+            "집수정"
+          ],
           "default": "기슭막이",
           "required": false
         },
@@ -43,7 +81,11 @@
           "key": "wing_wall_type",
           "label": "관보호공 날개벽",
           "input": "select",
-          "choices": ["A-TYPE", "C-TYPE", "A-TYPE+집수정"],
+          "choices": [
+            "A-TYPE",
+            "C-TYPE",
+            "A-TYPE+집수정"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -53,7 +95,12 @@
           "key": "inlet_basin_form",
           "label": "집수정 형식",
           "input": "select",
-          "choices": ["동물이동형", "□형(기본형)", "돌집수정 ㄴ형", "돌집수정 ㄷ형"],
+          "choices": [
+            "동물이동형",
+            "□형(기본형)",
+            "돌집수정 ㄴ형",
+            "돌집수정 ㄷ형"
+          ],
           "default": null,
           "required": false,
           "phase": "detail"
@@ -62,7 +109,12 @@
           "key": "inlet_basin_material",
           "label": "집수정 형태",
           "input": "select",
-          "choices": ["콘크리트", "조립식 주철맨홀", "돌쌓기(찰)", "돌쌓기(메)"],
+          "choices": [
+            "콘크리트",
+            "조립식 주철맨홀",
+            "돌쌓기(찰)",
+            "돌쌓기(메)"
+          ],
           "default": null,
           "required": false,
           "phase": "detail"
@@ -98,7 +150,14 @@
           "key": "inlet_revet_form",
           "label": "유입 기슭막이 형태",
           "input": "select",
-          "choices": ["돌쌓기(찰)", "돌쌓기(메)", "콘크리트", "돌망태", "통나무·목재틀", "바자"],
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
           "default": "돌쌓기(찰)",
           "required": false,
           "phase": "detail"
@@ -143,7 +202,9 @@
           "key": "outlet_type",
           "label": "유출구 구조",
           "input": "select",
-          "choices": ["기슭막이"],
+          "choices": [
+            "기슭막이"
+          ],
           "default": "기슭막이",
           "required": false
         },
@@ -151,7 +212,14 @@
           "key": "outlet_revet_form",
           "label": "유출 기슭막이 형태",
           "input": "select",
-          "choices": ["돌쌓기(찰)", "돌쌓기(메)", "콘크리트", "돌망태", "통나무·목재틀", "바자"],
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
           "default": "돌쌓기(메)",
           "required": false,
           "phase": "detail"
@@ -196,7 +264,10 @@
           "key": "revet_foundation",
           "label": "기슭막이 기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": false,
           "phase": "detail"
@@ -213,7 +284,13 @@
         "color": "#3b6fd4",
         "abbr": "암거"
       },
-      "drawing_views": ["plan", "profile", "cross_section", "detail", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "body_width_m",
@@ -227,7 +304,10 @@
           "key": "revet_foundation",
           "label": "기슭막이 기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": false,
           "phase": "detail"
@@ -303,7 +383,10 @@
           "key": "wing_in",
           "label": "날개벽(유입)",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": "있음",
           "required": false
         },
@@ -335,7 +418,10 @@
           "key": "wing_out",
           "label": "날개벽(유출)",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": "있음",
           "required": false
         },
@@ -375,7 +461,13 @@
         "color": "#2f9e8f",
         "abbr": "물넘이"
       },
-      "drawing_views": ["plan", "profile", "cross_section", "detail", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "ford_width_m",
@@ -427,13 +519,23 @@
         "color": "#28857a",
         "abbr": "세월교"
       },
-      "drawing_views": ["plan", "profile", "cross_section", "detail", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "pipe_kind",
           "label": "관종",
           "input": "select",
-          "choices": ["흄관", "VR관", "파형강관"],
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
           "default": "파형강관",
           "required": false
         },
@@ -441,7 +543,12 @@
           "key": "pipe_diameter_mm",
           "label": "관경",
           "input": "select",
-          "choices": ["800", "1000", "1200", "1500"],
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
           "unit": "mm",
           "default": "1000",
           "required": false
@@ -468,7 +575,10 @@
           "key": "wing_in",
           "label": "날개벽(유입)",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": "있음",
           "required": false
         },
@@ -500,7 +610,10 @@
           "key": "wing_out",
           "label": "날개벽(유출)",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": "있음",
           "required": false
         },
@@ -539,7 +652,12 @@
         "color": "#5aa7e8",
         "abbr": "횡수로"
       },
-      "drawing_views": ["plan", "profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": []
     },
     {
@@ -551,13 +669,21 @@
         "color": "#6d9bd1",
         "abbr": "개거"
       },
-      "drawing_views": ["plan", "profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "ditch_spec",
           "label": "규격",
           "input": "select",
-          "choices": ["콘크리트 개거 150×200", "L형수로 H=0.2"],
+          "choices": [
+            "콘크리트 개거 150×200",
+            "L형수로 H=0.2"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -585,13 +711,22 @@
         "color": "#2eaadc",
         "abbr": "측구"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "form",
           "label": "형식",
           "input": "select",
-          "choices": ["일반형(제형)", "L형", "U형", "J형"],
+          "choices": [
+            "일반형(제형)",
+            "L형",
+            "U형",
+            "J형"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -615,13 +750,21 @@
         "color": "#2e8bdc",
         "abbr": "산마루"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "material",
           "label": "재료",
           "input": "select",
-          "choices": ["콘크리트", "돌", "떼"],
+          "choices": [
+            "콘크리트",
+            "돌",
+            "떼"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -638,7 +781,10 @@
         "color": "#2ec5dc",
         "abbr": "소단구"
       },
-      "drawing_views": ["cross_section", "quantity"],
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "length_m",
@@ -706,13 +852,24 @@
         "color": "#1f9bb8",
         "abbr": "도수로"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "material",
           "label": "재료",
           "input": "select",
-          "choices": ["떼", "돌", "콘크리트", "블록판", "벤치플륨관", "반원관"],
+          "choices": [
+            "떼",
+            "돌",
+            "콘크리트",
+            "블록판",
+            "벤치플륨관",
+            "반원관"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -721,7 +878,11 @@
           "key": "section",
           "label": "단면형",
           "input": "select",
-          "choices": ["반달꼴", "U자형", "사다리꼴"],
+          "choices": [
+            "반달꼴",
+            "U자형",
+            "사다리꼴"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -738,13 +899,19 @@
         "color": "#28b1a1",
         "abbr": "사면로"
       },
-      "drawing_views": ["cross_section", "quantity"],
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "material",
           "label": "재료",
           "input": "select",
-          "choices": ["떼", "돌"],
+          "choices": [
+            "떼",
+            "돌"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -761,7 +928,11 @@
         "color": "#1f7fb8",
         "abbr": "맹암거"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "note",
@@ -780,7 +951,12 @@
         "color": "#e07a2e",
         "abbr": "옹벽"
       },
-      "drawing_views": ["profile", "cross_section", "detail", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "height_m",
@@ -824,7 +1000,13 @@
           "key": "form",
           "label": "형식",
           "input": "select",
-          "choices": ["중력식", "반중력식", "캔틸레버식", "부벽식", "식생옹벽블럭"],
+          "choices": [
+            "중력식",
+            "반중력식",
+            "캔틸레버식",
+            "부벽식",
+            "식생옹벽블럭"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -833,7 +1015,11 @@
           "key": "side",
           "label": "설치 측",
           "input": "select",
-          "choices": ["자동(성토 쪽)", "좌", "우"],
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
           "default": "자동(성토 쪽)",
           "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
         },
@@ -868,7 +1054,11 @@
         "color": "#d0692a",
         "abbr": "찰쌓기"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "height_m",
@@ -931,7 +1121,15 @@
           "key": "back_len_cm",
           "label": "뒷길이",
           "input": "select",
-          "choices": ["25", "30", "35", "45", "55", "60", "75"],
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -940,7 +1138,12 @@
           "key": "stone_kind",
           "label": "돌 종류",
           "input": "select",
-          "choices": ["야면석·호박돌", "깬잡석", "깬돌", "견치돌"],
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -949,7 +1152,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail"
@@ -958,7 +1164,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -968,7 +1177,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -987,7 +1199,10 @@
           "key": "face_role",
           "label": "성토/절토",
           "input": "select",
-          "choices": ["성토", "절토"],
+          "choices": [
+            "성토",
+            "절토"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -997,7 +1212,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1006,7 +1224,11 @@
           "key": "side",
           "label": "설치 측",
           "input": "select",
-          "choices": ["자동(성토 쪽)", "좌", "우"],
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
           "default": "자동(성토 쪽)",
           "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
         },
@@ -1034,7 +1256,10 @@
           "key": "blinding_concrete",
           "label": "버림 콘크리트",
           "input": "select",
-          "choices": ["넣음", "안 넣음"],
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
           "default": "넣음",
           "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
           "required": false,
@@ -1052,7 +1277,11 @@
         "color": "#c25d2c",
         "abbr": "메쌓기"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "height_m",
@@ -1117,7 +1346,15 @@
           "key": "back_len_cm",
           "label": "뒷길이",
           "input": "select",
-          "choices": ["25", "30", "35", "45", "55", "60", "75"],
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1126,7 +1363,12 @@
           "key": "stone_kind",
           "label": "돌 종류",
           "input": "select",
-          "choices": ["야면석·호박돌", "깬잡석", "깬돌", "견치돌"],
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1135,7 +1377,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail"
@@ -1144,7 +1389,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1154,7 +1402,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1173,7 +1424,10 @@
           "key": "face_role",
           "label": "성토/절토",
           "input": "select",
-          "choices": ["성토", "절토"],
+          "choices": [
+            "성토",
+            "절토"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1183,7 +1437,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1192,7 +1449,11 @@
           "key": "side",
           "label": "설치 측",
           "input": "select",
-          "choices": ["자동(성토 쪽)", "좌", "우"],
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
           "default": "자동(성토 쪽)",
           "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
         },
@@ -1220,7 +1481,10 @@
           "key": "blinding_concrete",
           "label": "버림 콘크리트",
           "input": "select",
-          "choices": ["넣음", "안 넣음"],
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
           "default": "넣음",
           "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
           "required": false,
@@ -1238,7 +1502,11 @@
         "color": "#b8742e",
         "abbr": "흙막이"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "height_m",
@@ -1298,7 +1566,11 @@
           "key": "side",
           "label": "설치 측",
           "input": "select",
-          "choices": ["자동(성토 쪽)", "좌", "우"],
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
           "default": "자동(성토 쪽)",
           "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
         },
@@ -1358,7 +1630,15 @@
           "key": "back_len_cm",
           "label": "뒷길이",
           "input": "select",
-          "choices": ["25", "30", "35", "45", "55", "60", "75"],
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1369,7 +1649,12 @@
           "key": "stone_kind",
           "label": "돌 종류",
           "input": "select",
-          "choices": ["야면석·호박돌", "깬잡석", "깬돌", "견치돌"],
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1380,7 +1665,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail",
@@ -1391,7 +1679,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1402,7 +1693,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1423,7 +1717,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1461,7 +1758,11 @@
         "color": "#a86a2a",
         "abbr": "큰돌"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "height_m",
@@ -1504,7 +1805,11 @@
           "key": "stone_cm",
           "label": "돌규격",
           "input": "select",
-          "choices": ["40~60", "60~80", "80~100"],
+          "choices": [
+            "40~60",
+            "60~80",
+            "80~100"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1513,7 +1818,10 @@
           "key": "bond",
           "label": "쌓기 방식",
           "input": "select",
-          "choices": ["메쌓기", "찰쌓기"],
+          "choices": [
+            "메쌓기",
+            "찰쌓기"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1522,7 +1830,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail",
@@ -1532,7 +1843,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1543,7 +1857,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1563,7 +1880,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1572,7 +1892,11 @@
           "key": "side",
           "label": "설치 측",
           "input": "select",
-          "choices": ["자동(성토 쪽)", "좌", "우"],
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
           "default": "자동(성토 쪽)",
           "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
         },
@@ -1602,7 +1926,10 @@
           "key": "blinding_concrete",
           "label": "버림 콘크리트",
           "input": "select",
-          "choices": ["넣음", "안 넣음"],
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
           "default": "넣음",
           "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
           "required": false,
@@ -1620,7 +1947,11 @@
         "color": "#7f9a63",
         "abbr": "소단"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "length_m",
@@ -1687,13 +2018,25 @@
         "color": "#7a52c7",
         "abbr": "골막이"
       },
-      "drawing_views": ["plan", "profile", "detail", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "form",
           "label": "형식",
           "input": "select",
-          "choices": ["돌", "돌망태", "콘크리트", "통나무", "바자", "흙"],
+          "choices": [
+            "돌",
+            "돌망태",
+            "콘크리트",
+            "통나무",
+            "바자",
+            "흙"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1702,7 +2045,10 @@
           "key": "spillway",
           "label": "방수로",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1711,7 +2057,12 @@
           "key": "stone_kind",
           "label": "돌 종류",
           "input": "select",
-          "choices": ["야면석·호박돌", "깬잡석", "깬돌", "견치돌"],
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1742,7 +2093,15 @@
           "key": "back_len_cm",
           "label": "뒷길이 ℓ3",
           "input": "select",
-          "choices": ["25", "30", "35", "45", "55", "60", "75"],
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1751,7 +2110,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail",
@@ -1761,7 +2123,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1772,7 +2137,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1791,7 +2159,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1859,13 +2230,20 @@
         "color": "#7c5f3b",
         "abbr": "바닥"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "form",
           "label": "형태",
           "input": "select",
-          "choices": ["돌붙임(찰)", "돌붙임(메)"],
+          "choices": [
+            "돌붙임(찰)",
+            "돌붙임(메)"
+          ],
           "default": "돌붙임(메)",
           "required": false,
           "phase": "b05"
@@ -1874,7 +2252,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail",
@@ -1884,7 +2265,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1895,7 +2279,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -1916,7 +2303,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -1950,7 +2340,12 @@
         "color": "#6b46b8",
         "abbr": "사방댐"
       },
-      "drawing_views": ["plan", "profile", "detail", "quantity"],
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
       "options": [
         {
           "key": "height_m",
@@ -1973,13 +2368,21 @@
         "color": "#9b6bdc",
         "abbr": "기슭"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "side",
           "label": "설치 측",
           "input": "select",
-          "choices": ["양쪽", "좌", "우"],
+          "choices": [
+            "양쪽",
+            "좌",
+            "우"
+          ],
           "default": "양쪽",
           "required": false,
           "phase": "b05",
@@ -2019,7 +2422,14 @@
           "key": "form",
           "label": "형태",
           "input": "select",
-          "choices": ["돌쌓기(찰)", "돌쌓기(메)", "콘크리트", "돌망태", "통나무·목재틀", "바자"],
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
           "default": "돌쌓기(메)",
           "required": false,
           "phase": "b05"
@@ -2048,7 +2458,15 @@
           "key": "back_len_cm",
           "label": "뒷길이",
           "input": "select",
-          "choices": ["25", "30", "35", "45", "55", "60", "75"],
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2058,7 +2476,12 @@
           "key": "stone_kind",
           "label": "돌 종류",
           "input": "select",
-          "choices": ["야면석·호박돌", "깬잡석", "깬돌", "견치돌"],
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2068,7 +2491,10 @@
           "key": "stone_supply",
           "label": "조달",
           "input": "select",
-          "choices": ["채집", "구입"],
+          "choices": [
+            "채집",
+            "구입"
+          ],
           "default": "채집",
           "required": false,
           "phase": "detail"
@@ -2077,7 +2503,10 @@
           "key": "stone_coeff_basis",
           "label": "야면석 계수",
           "input": "select",
-          "choices": ["품셈", "실무 관행"],
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2087,7 +2516,10 @@
           "key": "fill_concrete_mpa",
           "label": "채움 강도",
           "input": "select",
-          "choices": ["180", "210"],
+          "choices": [
+            "180",
+            "210"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2106,7 +2538,10 @@
           "key": "face_role",
           "label": "성토/절토",
           "input": "select",
-          "choices": ["성토", "절토"],
+          "choices": [
+            "성토",
+            "절토"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2116,7 +2551,10 @@
           "key": "foundation",
           "label": "기초",
           "input": "select",
-          "choices": ["기초유", "기초버림"],
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -2182,7 +2620,10 @@
           "key": "blinding_concrete",
           "label": "버림 콘크리트",
           "input": "select",
-          "choices": ["넣음", "안 넣음"],
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
           "default": "넣음",
           "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
           "required": false,
@@ -2200,7 +2641,11 @@
         "color": "#2fa84f",
         "abbr": "대피소"
       },
-      "drawing_views": ["plan", "cross_section", "quantity"],
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "width_m",
@@ -2229,7 +2674,11 @@
         "color": "#268f43",
         "abbr": "작업장"
       },
-      "drawing_views": ["plan", "cross_section", "quantity"],
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "width_m",
@@ -2256,7 +2705,10 @@
         "color": "#37b95a",
         "abbr": "차돌림"
       },
-      "drawing_views": ["plan", "quantity"],
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
       "options": [
         {
           "key": "width_m",
@@ -2276,13 +2728,19 @@
         "color": "#43c76b",
         "abbr": "반사경"
       },
-      "drawing_views": ["plan"],
+      "drawing_views": [
+        "plan"
+      ],
       "options": [
         {
           "key": "facing",
           "label": "방향",
           "input": "select",
-          "choices": ["좌", "우", "양면"],
+          "choices": [
+            "좌",
+            "우",
+            "양면"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -2298,13 +2756,21 @@
         "color": "#1f9e46",
         "abbr": "가드"
       },
-      "drawing_views": ["plan", "cross_section", "quantity"],
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "kind",
           "label": "종류",
           "input": "select",
-          "choices": ["가드레일", "경계석", "위험표지"],
+          "choices": [
+            "가드레일",
+            "경계석",
+            "위험표지"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -2320,7 +2786,10 @@
         "color": "#53a832",
         "abbr": "번호판"
       },
-      "drawing_views": ["plan", "detail"],
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
       "options": []
     },
     {
@@ -2332,7 +2801,10 @@
         "color": "#3f9e2e",
         "abbr": "차단기"
       },
-      "drawing_views": ["plan", "detail"],
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
       "options": []
     },
     {
@@ -2344,7 +2816,9 @@
         "color": "#66b344",
         "abbr": "준공"
       },
-      "drawing_views": ["plan"],
+      "drawing_views": [
+        "plan"
+      ],
       "options": []
     },
     {
@@ -2356,13 +2830,21 @@
         "color": "#8c9a2e",
         "abbr": "사토장"
       },
-      "drawing_views": ["plan", "cross_section", "quantity"],
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "side",
           "label": "쌓는 쪽",
           "input": "select",
-          "choices": ["자동(성토 쪽)", "좌", "우"],
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
           "default": "자동(성토 쪽)",
           "required": false,
           "phase": "b05",
@@ -2416,7 +2898,10 @@
         "color": "#7d8a2a",
         "abbr": "토취장"
       },
-      "drawing_views": ["plan", "quantity"],
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
       "options": [
         {
           "key": "area_m2",
@@ -2448,13 +2933,19 @@
         "color": "#3aa88f",
         "abbr": "동물길"
       },
-      "drawing_views": ["plan", "cross_section"],
+      "drawing_views": [
+        "plan",
+        "cross_section"
+      ],
       "options": [
         {
           "key": "form",
           "label": "형식",
           "input": "select",
-          "choices": ["경사로", "자연형계단"],
+          "choices": [
+            "경사로",
+            "자연형계단"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -2471,7 +2962,10 @@
         "color": "#4cb84c",
         "abbr": "녹화"
       },
-      "drawing_views": ["cross_section", "quantity"],
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "method",
@@ -2498,7 +2992,11 @@
           "key": "face",
           "label": "대상 면",
           "input": "select",
-          "choices": ["절토면", "성토면", "양쪽"],
+          "choices": [
+            "절토면",
+            "성토면",
+            "양쪽"
+          ],
           "default": null,
           "required": true,
           "phase": "detail"
@@ -2507,7 +3005,11 @@
           "key": "cover_kind",
           "label": "덮개(비탈덮기)",
           "input": "select",
-          "choices": ["거적", "짚망", "방초·야자섬유매트"],
+          "choices": [
+            "거적",
+            "짚망",
+            "방초·야자섬유매트"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2527,7 +3029,17 @@
           "key": "sod_grade",
           "label": "선떼 급수",
           "input": "select",
-          "choices": ["1급", "2급", "3급", "4급", "5급", "6급", "7급", "8급", "9급"],
+          "choices": [
+            "1급",
+            "2급",
+            "3급",
+            "4급",
+            "5급",
+            "6급",
+            "7급",
+            "8급",
+            "9급"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2537,7 +3049,10 @@
           "key": "sod_size",
           "label": "선떼 떼 크기",
           "input": "select",
-          "choices": ["대형 40×40", "소형 18×18"],
+          "choices": [
+            "대형 40×40",
+            "소형 18×18"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2547,7 +3062,11 @@
           "key": "cutting_soil",
           "label": "단끊기 토질",
           "input": "select",
-          "choices": ["보통토사", "경질ㆍ고사점토 및 자갈섞인 점토", "호박돌 섞인 토사"],
+          "choices": [
+            "보통토사",
+            "경질ㆍ고사점토 및 자갈섞인 점토",
+            "호박돌 섞인 토사"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2564,7 +3083,11 @@
         "color": "#8a8f98",
         "abbr": "포장"
       },
-      "drawing_views": ["profile", "cross_section", "quantity"],
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "length_m",
@@ -2630,7 +3153,10 @@
           "key": "separation_sheet",
           "label": "비닐(깔기·양생)",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2640,7 +3166,10 @@
           "key": "wire_mesh",
           "label": "철망",
           "input": "select",
-          "choices": ["있음", "없음"],
+          "choices": [
+            "있음",
+            "없음"
+          ],
           "default": null,
           "required": false,
           "phase": "detail",
@@ -2658,7 +3187,10 @@
         "color": "#9aa0a8",
         "abbr": "쇄석"
       },
-      "drawing_views": ["cross_section", "quantity"],
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
       "options": [
         {
           "key": "thickness_cm",
@@ -2680,7 +3212,9 @@
         "color": "#98a2b3",
         "abbr": "기타"
       },
-      "drawing_views": ["profile"],
+      "drawing_views": [
+        "profile"
+      ],
       "options": [
         {
           "key": "name",
@@ -2690,5 +3224,71 @@
         }
       ]
     }
-  ]
+  ],
+  "종류": {
+    "pipe": {
+      "동작": [
+        "계곡통과시설",
+        "유입유출_묶음",
+        "기슭막이_한벌"
+      ]
+    },
+    "box_culvert": {
+      "동작": [
+        "계곡통과시설",
+        "BOX_본체규격",
+        "날개벽"
+      ]
+    },
+    "ford_pavement": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면"
+      ]
+    },
+    "ford_bridge": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면",
+        "날개벽"
+      ]
+    },
+    "revetment": {
+      "동작": [
+        "계곡통과시설",
+        "기슭막이_한벌"
+      ]
+    },
+    "pavement_concrete": {
+      "동작": [
+        "포장_물넘이_겹침"
+      ]
+    }
+  },
+  "표시": {},
+  "그룹": {
+    "pipe": [
+      {
+        "id": "grv6lny",
+        "이름": "관",
+        "옵션": [
+          "pipe_kind",
+          "pipe_diameter_mm",
+          "inlet_type"
+        ]
+      },
+      {
+        "id": "gnbf9m9",
+        "이름": "관 보호공(유입)",
+        "옵션": []
+      },
+      {
+        "id": "g9lq9uk",
+        "이름": "관 보호공(유출)",
+        "옵션": []
+      }
+    ]
+  },
+  "배치": {},
+  "규칙": []
 }
diff --git a/resources/master_template/구조물정의_이력/판_2.json b/resources/master_template/구조물정의_이력/판_2.json
new file mode 100644
index 000000000..822907d84
--- /dev/null
+++ b/resources/master_template/구조물정의_이력/판_2.json
@@ -0,0 +1,3298 @@
+{
+  "판": 2,
+  "schema_version": 1,
+  "comment": "B05 구조물 타입 레지스트리 정본. 근거·옵션 상세는 PLAN.md 구조물 리스트와 resources/knowledge/technical_info/01_임도 참조. 2026-08-17 선택지 재편: B군(종단배수)·F군(생태/녹화)·G군(노면공)은 enabled:false 보존 — B05 선택지에서 빠지고 B06 개별 횡단도 옵션으로 재사용한다. 바닥막이(bed_sill)·생태연못(eco_pond)은 임도 미사용 확정으로 삭제. 배관·BOX암거·물넘이·세월교는 pipe_points.json 정본 관리(managed_by) — structures.json에 저장하지 않으며, 배관 부속(유형/집수정/기슭막이/돌붙임)·날개벽 옵션 정의는 B06/B07 필수 승격의 선언 근거다. ★기본값 원칙(2026-08-16 크로스체크 2차): default를 두는 것은 ①법정이 등급과 무관하게 못박은 단일 수치 ②사용자가 개발 단계에서 확정한 값 ③도메인 수치가 아닌 표시용 문자열, 이 셋뿐이다. 재료·형식 같은 설계자 판단 선택지와 미확정 제원은 default 없이 required로 두어 사용자가 직접 고르게 한다 (pipe_diameter_mm 1000 = 별표2 원칙값+사용자 확정 — 화이트리스트 등재). BOX암거 본체 2.0×2.0·날개벽 유입/유출 있음·짧은쪽 높이 1m·길이 2m·각도 45°는 2026-08-17 사용자 확정값이다 — 본체 규격은 실무 관측 규격(2.0×2.0·3.0×3.0)을 폼에서 프리셋 select로 받고 필요 시 사용자 지정으로 자유 입력하되, 저장 키는 body_width_m·body_height_m 숫자 그대로다(프리셋 전용 키를 만들지 않는다). 이 값들은 B05 서브폼이 실제로 받으므로 phase를 detail로 두지 않는다. ★보호공 개편(2026-08-17 사용자 지시): 구 `*_pitching`(있음/없음) + `*_pitching_finish`(찰/메) 두 축을 `*_protection` 한 축(돌붙임(찰)·돌붙임(메)·도수로)으로 합쳤다 — 도수로·산비탈수로(B4)는 유출부에서 돌붙임 대신 쓰는 공종이라 별도 구조물이 아니라 보호공 선택지로 받는다. \"없음\"은 삭제(물이 흐르는 자리라 보호공 필수). 치수는 배타 — 돌붙임이면 `*_protection_area_m2`(10㎡), 도수로면 `*_protection_width_m`(1m, 지식DB 수치 근거 없음·사용자 확정, 실무 확인 후 개선). 구 저장분은 `common_util_drainage_pipes.parse_pipe_points`가 새 키로 옮긴다.",
+  "구조물군": {
+    "A": "A 횡단배수",
+    "B": "B 종단배수",
+    "C": "C 사면안정",
+    "D": "D 계류·사방",
+    "E": "E 안전·부대·용지",
+    "F": "F 생태·녹화",
+    "G": "G 노면공",
+    "호환": "기타"
+  },
+  "동작": {
+    "계곡통과시설": "관 지점 정본(pipe_points.json) 시설 — 부속 옵션 서브폼을 손코딩으로 그림 · 저장은 폼이 아는 칸만 갈아 끼움",
+    "유입유출_묶음": "관 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹",
+    "기슭막이_한벌": "기슭막이 형태 · 길이 · 높이 · 바닥 보호공 한 벌 — 관 유입 · 유출 · 독립 기슭막이가 같은 조각",
+    "BOX_본체규격": "BOX암거 본체 규격 프리셋 고르기(폭 × 높이 한 칸)",
+    "날개벽": "날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 조각",
+    "월류단면": "월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 줄 · 필요 수심 미만은 되돌림",
+    "포장_물넘이_겹침": "포장 구간이 물넘이포장을 품으면 앞 · 뒤로 나눔 · 끝만 걸치면 저장 멈춤"
+  },
+  "types": [
+    {
+      "type_id": "pipe",
+      "group": "A",
+      "name": "배관",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#4f8ef7",
+        "abbr": "배수관"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false,
+          "enabled": true
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "inlet_type",
+          "label": "유입구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이",
+            "집수정"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "wing_wall_type",
+          "label": "관보호공 날개벽",
+          "input": "select",
+          "choices": [
+            "A-TYPE",
+            "C-TYPE",
+            "A-TYPE+집수정"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 날개벽을 안 셈 — 고르면 그 형식의 개소당 원단위로 한 줄이 섬(Ø800·Ø1000 만 있음)"
+        },
+        {
+          "key": "inlet_basin_form",
+          "label": "집수정 형식",
+          "input": "select",
+          "choices": [
+            "동물이동형",
+            "□형(기본형)",
+            "돌집수정 ㄴ형",
+            "돌집수정 ㄷ형"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_material",
+          "label": "집수정 형태",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "조립식 주철맨홀",
+            "돌쌓기(찰)",
+            "돌쌓기(메)"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_length_m",
+          "label": "집수정 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_before_m",
+          "label": "집수정 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_after_m",
+          "label": "집수정 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_form",
+          "label": "유입 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(찰)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_length_m",
+          "label": "유입 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "inlet_revet_before_m",
+          "label": "유입 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_after_m",
+          "label": "유입 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_height_m",
+          "label": "유입 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "outlet_type",
+          "label": "유출구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "outlet_revet_form",
+          "label": "유출 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_length_m",
+          "label": "유출 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "outlet_revet_before_m",
+          "label": "유출 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_after_m",
+          "label": "유출 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_height_m",
+          "label": "유출 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "box_culvert",
+      "group": "A",
+      "name": "BOX암거",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#3b6fd4",
+        "abbr": "암거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "body_width_m",
+          "label": "본체 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "body_height_m",
+          "label": "본체 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "length_m",
+          "label": "연장(계류 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 수량이 안 섬 — 구체 길이는 설계자 입력(기본값 없음 · 2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wall_thickness_m",
+          "label": "측벽 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 벽 0.3 · KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "slab_thickness_m",
+          "label": "상·저판 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.25,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 판 0.25 — ⚠ KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ 에 못 미침(임도 예제 0.25 · KDS 도로 최소 300㎜) · 설계자가 고름",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "haunch_m",
+          "label": "헌치(모따기) 크기",
+          "input": "number",
+          "unit": "m",
+          "default": 0.2,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 0.2×0.2 · 실무 울진 기번3 구조도 2×2 도 0.2 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "blinding_thickness_m",
+          "label": "기초(버림) 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.1,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 기초 0.1(양쪽 0.1 여유) · 실무 울진 기번3 구조도 2×2 버림 0.1 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "trench_depth_m",
+          "label": "평균 터파기고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 구체 터파기·되메우기가 안 섬 — 원지반에서 터파기 바닥(기초잡석 밑)까지 · 토공집계로 감(2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "ford_pavement",
+      "group": "A",
+      "name": "물넘이포장",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#2f9e8f",
+        "abbr": "물넘이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "물넘이 월류 폭 기본 5m — 사용자 확정값(엔진 FORD_PAVEMENT_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "ford_slope_pct",
+          "label": "바닥 경사(유입→유출)",
+          "input": "number",
+          "unit": "%",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "thickness_cm",
+          "label": "포장 두께",
+          "input": "number",
+          "unit": "㎝",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 표가 안 서고 「두께를 적어야 섬」 사유가 뜸 — 두께로 관측 원단위(울진 20㎝)를 고름(2026-09-14 A3)"
+        },
+        {
+          "key": "length_m",
+          "label": "포장 길이(노폭 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 면적(월류 폭 × 길이)이 0 이라 표가 안 서고 사유가 뜸 — 노견까지 전폭을 적음(2026-09-14 A3)"
+        }
+      ]
+    },
+    {
+      "type_id": "ford_bridge",
+      "group": "A",
+      "name": "세월교",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#28857a",
+        "abbr": "세월교"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "pipe_count",
+          "label": "배관 수량",
+          "input": "number",
+          "unit": "련",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "세월교 월류 폭 기본 10m — 사용자 확정값(엔진 FORD_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "cross_drain_exposed",
+      "group": "A",
+      "name": "노출형 횡단수로",
+      "placement": "point",
+      "style": {
+        "color": "#5aa7e8",
+        "abbr": "횡수로"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "open_ditch",
+      "group": "A",
+      "name": "개거(겉도랑)",
+      "placement": "point",
+      "style": {
+        "color": "#6d9bd1",
+        "abbr": "개거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ditch_spec",
+          "label": "규격",
+          "input": "select",
+          "choices": [
+            "콘크리트 개거 150×200",
+            "L형수로 H=0.2"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 붙박이(콘크리트 개거)로 돎"
+        },
+        {
+          "key": "length_m",
+          "label": "연장",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 표가 안 서고 「연장을 적어야 섬」 사유가 뜸 — 개거는 m당 원단위라 연장이 곧 밑수(2026-09-14 A2)"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_side",
+      "enabled": false,
+      "group": "B",
+      "name": "측구(옆도랑)",
+      "design_owner": "횡단 설계",
+      "placement": "interval",
+      "style": {
+        "color": "#2eaadc",
+        "abbr": "측구"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "일반형(제형)",
+            "L형",
+            "U형",
+            "J형"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "depth_cm",
+          "label": "깊이",
+          "input": "number",
+          "unit": "cm",
+          "default": 30
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_ridge",
+      "enabled": false,
+      "group": "B",
+      "name": "산마루측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2e8bdc",
+        "abbr": "산마루"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_berm",
+      "enabled": false,
+      "group": "B",
+      "name": "소단측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2ec5dc",
+        "abbr": "소단구"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "사면 쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "chute",
+      "enabled": false,
+      "group": "B",
+      "name": "도수로·산비탈수로",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9bb8",
+        "abbr": "도수로"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌",
+            "콘크리트",
+            "블록판",
+            "벤치플륨관",
+            "반원관"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "section",
+          "label": "단면형",
+          "input": "select",
+          "choices": [
+            "반달꼴",
+            "U자형",
+            "사다리꼴"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "slope_drain",
+      "enabled": false,
+      "group": "B",
+      "name": "절토사면 배수로",
+      "placement": "interval",
+      "style": {
+        "color": "#28b1a1",
+        "abbr": "사면로"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "underdrain",
+      "enabled": false,
+      "group": "B",
+      "name": "맹암거",
+      "placement": "interval",
+      "style": {
+        "color": "#1f7fb8",
+        "abbr": "맹암거"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "note",
+          "label": "규격",
+          "input": "text",
+          "default": ""
+        }
+      ]
+    },
+    {
+      "type_id": "retaining_wall",
+      "group": "C",
+      "name": "옹벽",
+      "placement": "interval",
+      "style": {
+        "color": "#e07a2e",
+        "abbr": "옹벽"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "default_basis": "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음",
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "중력식",
+            "반중력식",
+            "캔틸레버식",
+            "부벽식",
+            "식생옹벽블럭"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_wet",
+      "group": "C",
+      "name": "돌쌓기(찰)",
+      "placement": "interval",
+      "style": {
+        "color": "#d0692a",
+        "abbr": "찰쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤3.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_dry",
+      "group": "C",
+      "name": "돌쌓기(메)",
+      "placement": "interval",
+      "style": {
+        "color": "#c25d2c",
+        "abbr": "메쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)",
+          "warn_above": 2,
+          "warn_message": "메쌓기 높이 기준을 넘음 — 임도기술교본 7-3:27 「메쌓기는 2.0m 이하」 · 품셈 13-4-4 [주]⑪(원문 L7192) 「높이 3m 이상이면 전부 또는 하부를 찰쌓기」 · 막지 않음(설계자 확인)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "soil_guard",
+      "group": "C",
+      "name": "흙막이",
+      "placement": "interval",
+      "style": {
+        "color": "#b8742e",
+        "abbr": "흙막이"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌(찰)",
+            "돌(메)",
+            "블록쌓기",
+            "돌망태",
+            "흙포대",
+            "통나무쌓기",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 올리지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 옮기지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 돌쌓기 기본값으로 서고 「기본값으로 섰음」이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "default_basis": "「채집」 — 별표2 「야면석 등은 가급적 현장에서 채취·사용」 권고. 구조물마다 바꿀 수 있음",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        }
+      ]
+    },
+    {
+      "type_id": "boulder_masonry",
+      "group": "C",
+      "name": "큰돌쌓기",
+      "placement": "interval",
+      "style": {
+        "color": "#a86a2a",
+        "abbr": "큰돌"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_cm",
+          "label": "돌규격",
+          "input": "select",
+          "choices": [
+            "40~60",
+            "60~80",
+            "80~100"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bond",
+          "label": "쌓기 방식",
+          "input": "select",
+          "choices": [
+            "메쌓기",
+            "찰쌓기"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 채움 콘크리트를 품에 포함 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "berm",
+      "group": "C",
+      "name": "소단",
+      "placement": "interval",
+      "style": {
+        "color": "#7f9a63",
+        "abbr": "소단"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "안쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "erosion_check",
+      "group": "D",
+      "name": "골막이",
+      "placement": "point",
+      "style": {
+        "color": "#7a52c7",
+        "abbr": "골막이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "돌",
+            "돌망태",
+            "콘크리트",
+            "통나무",
+            "바자",
+            "흙"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "spillway",
+          "label": "방수로",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이 ℓ3",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "top_length_m",
+          "label": "상장 ⓐ (윗변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bottom_length_m",
+          "label": "하장 ⓑ (아랫변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 4.5
+        },
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "bed_sill",
+      "group": "D",
+      "name": "바닥막이",
+      "placement": "point",
+      "style": {
+        "color": "#7c5f3b",
+        "abbr": "바닥"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌붙임(찰)",
+            "돌붙임(메)"
+          ],
+          "default": "돌붙임(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 평면적(돌붙임 ㎡)이라 기울기 몫이 없음 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "check_dam_small",
+      "group": "D",
+      "name": "소형사방댐(복합형)",
+      "placement": "point",
+      "style": {
+        "color": "#6b46b8",
+        "abbr": "사방댐"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revetment",
+      "group": "D",
+      "name": "기슭막이",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#9b6bdc",
+        "abbr": "기슭"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "양쪽",
+            "좌",
+            "우"
+          ],
+          "default": "양쪽",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「좌」는 셀렉트 첫 항목일 뿐 도메인 확정값이 아님 — 측점마다 사용자가 고름"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 13-4-4 [주]⑩ 뒷길이 표준 하한(높이·찰/메로 · 범위 안 가장 작은 규격 — 예 메쌓기 1.5~3m 는 36~45㎝ 라 45㎝)으로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "설계자 입력 — 계획홍수위 + 0.5~0.7m(사방기술교본 2-나:141 · 3-가:181 · 사방(계류) 교본 기준). 비우면 줄만 서고 미확정이라 금액에 안 들어감 · 옛 기본 2.5 는 근거 없어 걷음(2026-09-14 브레인 판정)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "refuge",
+      "group": "E",
+      "name": "대피소",
+      "placement": "interval",
+      "style": {
+        "color": "#2fa84f",
+        "abbr": "대피소"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 15
+        }
+      ]
+    },
+    {
+      "type_id": "work_yard",
+      "group": "E",
+      "name": "정차·작업장",
+      "placement": "interval",
+      "style": {
+        "color": "#268f43",
+        "abbr": "작업장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 7
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 20
+        }
+      ]
+    },
+    {
+      "type_id": "turnaround",
+      "group": "E",
+      "name": "차돌림곳",
+      "placement": "site",
+      "style": {
+        "color": "#37b95a",
+        "abbr": "차돌림"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        }
+      ]
+    },
+    {
+      "type_id": "mirror",
+      "group": "E",
+      "name": "반사경",
+      "placement": "point",
+      "style": {
+        "color": "#43c76b",
+        "abbr": "반사경"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": [
+        {
+          "key": "facing",
+          "label": "방향",
+          "input": "select",
+          "choices": [
+            "좌",
+            "우",
+            "양면"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "guardrail",
+      "group": "E",
+      "name": "가드레일·경계석·위험표지",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9e46",
+        "abbr": "가드"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "kind",
+          "label": "종류",
+          "input": "select",
+          "choices": [
+            "가드레일",
+            "경계석",
+            "위험표지"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "position_sign",
+      "group": "E",
+      "name": "국가지점번호판",
+      "placement": "point",
+      "style": {
+        "color": "#53a832",
+        "abbr": "번호판"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "barrier_gate",
+      "group": "E",
+      "name": "차단기",
+      "placement": "point",
+      "style": {
+        "color": "#3f9e2e",
+        "abbr": "차단기"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "completion_sign",
+      "group": "E",
+      "name": "준공표지판",
+      "placement": "point",
+      "style": {
+        "color": "#66b344",
+        "abbr": "준공"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "spoil_bank",
+      "group": "E",
+      "name": "유용토운반작업장(구 사토장)",
+      "placement": "interval",
+      "style": {
+        "color": "#8c9a2e",
+        "abbr": "사토장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "쌓는 쪽",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「자동(성토 쪽)」 — 흙은 성토 쪽에 쌓는다는 지금까지의 동작을 이어받는 표식. 측점마다 좌·우로 바꿈"
+        },
+        {
+          "key": "fill_slope_ratio",
+          "label": "비탈 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 그 측점의 노선 성토 기울기를 그대로 씀 — 지식DB 가 「기본 비탈기울기는 근거에 없다」고 못 박은 자리"
+        },
+        {
+          "key": "extra_distance_m",
+          "label": "추가 운반거리",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "0 = 「추가 없음」 — 노선 안 사토장은 측점 누가거리로 거리가 나오므로 이 칸은 외부 사토장 대비 여벌"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "borrow_pit",
+      "group": "E",
+      "name": "토사채취장(토취장)",
+      "placement": "site",
+      "style": {
+        "color": "#7d8a2a",
+        "abbr": "토취장"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "wildlife_path",
+      "enabled": false,
+      "group": "F",
+      "name": "야생동물 이동통로",
+      "placement": "point",
+      "style": {
+        "color": "#3aa88f",
+        "abbr": "동물길"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "경사로",
+            "자연형계단"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revegetation",
+      "enabled": false,
+      "group": "F",
+      "name": "비탈면 녹화",
+      "placement": "interval",
+      "style": {
+        "color": "#4cb84c",
+        "abbr": "녹화"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "method",
+          "label": "공법",
+          "input": "select",
+          "choices": [
+            "씨뿌리기(줄파종)",
+            "새심기",
+            "선떼붙이기",
+            "줄떼",
+            "평떼",
+            "비탈덮기",
+            "녹생토 뿜어붙이기",
+            "조공",
+            "편책",
+            "나무심기"
+          ],
+          "default": null,
+          "default_basis": "「초류종자 살포」는 여기 없음 — 토공집계에서 사면 전체로 섬(품셈 5-24 · 두 곳에 두면 이중계상 · 2026-09-15 브레인)",
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "face",
+          "label": "대상 면",
+          "input": "select",
+          "choices": [
+            "절토면",
+            "성토면",
+            "양쪽"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "cover_kind",
+          "label": "덮개(비탈덮기)",
+          "input": "select",
+          "choices": [
+            "거적",
+            "짚망",
+            "방초·야자섬유매트"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비탈덮기일 때만 고름 — 비면 비탈덮기 줄이 안 섬(품셈 5-25 거적덮기 ㎡ · 5-28-1 짚망 · 5-28-2 매트 · 재료가 공종을 가름)"
+        },
+        {
+          "key": "step_height_m",
+          "label": "단 직고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기·조공의 단 사이 직고 — 교본은 범위로만 줌(선떼 직고 1~2m · 조공 1.0~1.2m) · 기본값 없음 · 비면 선떼 연장(품셈 5-16-1 [주]② 대상지 직고 ÷ 단 직고 × 연장)이 안 섬"
+        },
+        {
+          "key": "sod_grade",
+          "label": "선떼 급수",
+          "input": "select",
+          "choices": [
+            "1급",
+            "2급",
+            "3급",
+            "4급",
+            "5급",
+            "6급",
+            "7급",
+            "8급",
+            "9급"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기의 급수 — 교본은 1~9급 범위만(6~7급을 많이 씀) · 기본값 없음 · 비면 m당 떼 매수(사방기술교본 표 2-2-6)가 안 섬"
+        },
+        {
+          "key": "sod_size",
+          "label": "선떼 떼 크기",
+          "input": "select",
+          "choices": [
+            "대형 40×40",
+            "소형 18×18"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "사방기술교본 표 2-2-6 이 대형(40×40)·소형(18×18) 두 줄을 나란히 줌 — 우리가 고를 자리가 아니라 기본값 없음 · 비면 선떼 떼 매수가 안 섬"
+        },
+        {
+          "key": "cutting_soil",
+          "label": "단끊기 토질",
+          "input": "select",
+          "choices": [
+            "보통토사",
+            "경질ㆍ고사점토 및 자갈섞인 점토",
+            "호박돌 섞인 토사"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "품셈 5-16-1 단끊기 표의 토질 셋 — B06 지반(토사/암)과 다른 축이라 자동으로 안 고름 · 비면 단끊기 조각만 막힘"
+        }
+      ]
+    },
+    {
+      "type_id": "pavement_concrete",
+      "group": "G",
+      "name": "콘크리트 포장",
+      "placement": "interval",
+      "style": {
+        "color": "#8a8f98",
+        "abbr": "포장"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 포장층 두께(표준 횡단면 설정 · 기본 0.2m = 임도기술교본 3-2 「두께 0.2m」)를 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "width_m",
+          "label": "포장 폭",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 노폭(구간 측점의 차도 표준 폭 · 교본 3-2 「포장 폭 3.0m」 · 실무 관측 3.5~4.0)을 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "widening_area_m2",
+          "label": "확폭 면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 곡선부 확폭을 측점 사이 평균 × 거리로 더함(교본 3-2 「곡선부에는 확폭」) — 확폭이 없으면 0 을 적을 것"
+        },
+        {
+          "key": "joint_spacing_m",
+          "label": "수축줄눈 간격",
+          "input": "number",
+          "unit": "m",
+          "default": 6,
+          "default_basis": "제안값 · 임도기술교본 부록 4-7 7-1 3.5.1 「수축줄눈의 간격은 4-6m를 기준」 · 실무 소광 6m 관측 · 바꿀 수 있음",
+          "phase": "detail"
+        },
+        {
+          "key": "separation_sheet",
+          "label": "비닐(깔기·양생)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 비닐 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「양생 재료비(비닐 등)는 별도 계상」이라 설계자가 고름(기본값 없음)"
+        },
+        {
+          "key": "wire_mesh",
+          "label": "철망",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 철망 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「철망재료비는 별도 계상」 · 교본 부록 7-1 3.4 「설계도서에 따라」 · 실무 소광 「철망포함」 관측"
+        }
+      ]
+    },
+    {
+      "type_id": "gravel_surfacing",
+      "enabled": false,
+      "group": "G",
+      "name": "쇄석(자갈) 포설",
+      "placement": "interval",
+      "style": {
+        "color": "#9aa0a8",
+        "abbr": "쇄석"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "etc",
+      "group": "호환",
+      "name": "기타",
+      "placement": "point",
+      "style": {
+        "color": "#98a2b3",
+        "abbr": "기타"
+      },
+      "drawing_views": [
+        "profile"
+      ],
+      "options": [
+        {
+          "key": "name",
+          "label": "이름",
+          "input": "text",
+          "default": "기타 구조물"
+        }
+      ]
+    }
+  ],
+  "종류": {
+    "pipe": {
+      "동작": [
+        "계곡통과시설",
+        "유입유출_묶음",
+        "기슭막이_한벌"
+      ]
+    },
+    "box_culvert": {
+      "동작": [
+        "계곡통과시설",
+        "BOX_본체규격",
+        "날개벽"
+      ]
+    },
+    "ford_pavement": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면"
+      ]
+    },
+    "ford_bridge": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면",
+        "날개벽"
+      ]
+    },
+    "revetment": {
+      "동작": [
+        "계곡통과시설",
+        "기슭막이_한벌"
+      ]
+    },
+    "pavement_concrete": {
+      "동작": [
+        "포장_물넘이_겹침"
+      ]
+    }
+  },
+  "표시": {},
+  "그룹": {
+    "pipe": [
+      {
+        "id": "grv6lny",
+        "이름": "관",
+        "옵션": [
+          "pipe_kind",
+          "pipe_diameter_mm",
+          "inlet_type"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "gnbf9m9",
+        "이름": "관 보호공(유입)",
+        "옵션": [],
+        "형상": {}
+      },
+      {
+        "id": "g9lq9uk",
+        "이름": "관 보호공(유출)",
+        "옵션": [],
+        "형상": {}
+      }
+    ]
+  },
+  "배치": {},
+  "규칙": []
+}
diff --git a/resources/master_template/구조물정의_이력/판_3.json b/resources/master_template/구조물정의_이력/판_3.json
new file mode 100644
index 000000000..dba29bf2b
--- /dev/null
+++ b/resources/master_template/구조물정의_이력/판_3.json
@@ -0,0 +1,3299 @@
+{
+  "판": 3,
+  "schema_version": 1,
+  "comment": "B05 구조물 타입 레지스트리 정본. 근거·옵션 상세는 PLAN.md 구조물 리스트와 resources/knowledge/technical_info/01_임도 참조. 2026-08-17 선택지 재편: B군(종단배수)·F군(생태/녹화)·G군(노면공)은 enabled:false 보존 — B05 선택지에서 빠지고 B06 개별 횡단도 옵션으로 재사용한다. 바닥막이(bed_sill)·생태연못(eco_pond)은 임도 미사용 확정으로 삭제. 배관·BOX암거·물넘이·세월교는 pipe_points.json 정본 관리(managed_by) — structures.json에 저장하지 않으며, 배관 부속(유형/집수정/기슭막이/돌붙임)·날개벽 옵션 정의는 B06/B07 필수 승격의 선언 근거다. ★기본값 원칙(2026-08-16 크로스체크 2차): default를 두는 것은 ①법정이 등급과 무관하게 못박은 단일 수치 ②사용자가 개발 단계에서 확정한 값 ③도메인 수치가 아닌 표시용 문자열, 이 셋뿐이다. 재료·형식 같은 설계자 판단 선택지와 미확정 제원은 default 없이 required로 두어 사용자가 직접 고르게 한다 (pipe_diameter_mm 1000 = 별표2 원칙값+사용자 확정 — 화이트리스트 등재). BOX암거 본체 2.0×2.0·날개벽 유입/유출 있음·짧은쪽 높이 1m·길이 2m·각도 45°는 2026-08-17 사용자 확정값이다 — 본체 규격은 실무 관측 규격(2.0×2.0·3.0×3.0)을 폼에서 프리셋 select로 받고 필요 시 사용자 지정으로 자유 입력하되, 저장 키는 body_width_m·body_height_m 숫자 그대로다(프리셋 전용 키를 만들지 않는다). 이 값들은 B05 서브폼이 실제로 받으므로 phase를 detail로 두지 않는다. ★보호공 개편(2026-08-17 사용자 지시): 구 `*_pitching`(있음/없음) + `*_pitching_finish`(찰/메) 두 축을 `*_protection` 한 축(돌붙임(찰)·돌붙임(메)·도수로)으로 합쳤다 — 도수로·산비탈수로(B4)는 유출부에서 돌붙임 대신 쓰는 공종이라 별도 구조물이 아니라 보호공 선택지로 받는다. \"없음\"은 삭제(물이 흐르는 자리라 보호공 필수). 치수는 배타 — 돌붙임이면 `*_protection_area_m2`(10㎡), 도수로면 `*_protection_width_m`(1m, 지식DB 수치 근거 없음·사용자 확정, 실무 확인 후 개선). 구 저장분은 `common_util_drainage_pipes.parse_pipe_points`가 새 키로 옮긴다.",
+  "구조물군": {
+    "A": "A 횡단배수",
+    "B": "B 종단배수",
+    "C": "C 사면안정",
+    "D": "D 계류·사방",
+    "E": "E 안전·부대·용지",
+    "F": "F 생태·녹화",
+    "G": "G 노면공",
+    "호환": "기타"
+  },
+  "동작": {
+    "계곡통과시설": "관 지점 정본(pipe_points.json) 시설 — 부속 옵션 서브폼을 손코딩으로 그림 · 저장은 폼이 아는 칸만 갈아 끼움",
+    "유입유출_묶음": "관 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹",
+    "기슭막이_한벌": "기슭막이 형태 · 길이 · 높이 · 바닥 보호공 한 벌 — 관 유입 · 유출 · 독립 기슭막이가 같은 조각",
+    "BOX_본체규격": "BOX암거 본체 규격 프리셋 고르기(폭 × 높이 한 칸)",
+    "날개벽": "날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 조각",
+    "월류단면": "월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 줄 · 필요 수심 미만은 되돌림",
+    "포장_물넘이_겹침": "포장 구간이 물넘이포장을 품으면 앞 · 뒤로 나눔 · 끝만 걸치면 저장 멈춤"
+  },
+  "types": [
+    {
+      "type_id": "pipe",
+      "group": "A",
+      "name": "배관",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#4f8ef7",
+        "abbr": "배수관"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false,
+          "enabled": true
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "inlet_type",
+          "label": "유입구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이",
+            "집수정"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "wing_wall_type",
+          "label": "관보호공 날개벽",
+          "input": "select",
+          "choices": [
+            "A-TYPE",
+            "C-TYPE",
+            "A-TYPE+집수정"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 날개벽을 안 셈 — 고르면 그 형식의 개소당 원단위로 한 줄이 섬(Ø800·Ø1000 만 있음)"
+        },
+        {
+          "key": "inlet_basin_form",
+          "label": "집수정 형식",
+          "input": "select",
+          "choices": [
+            "동물이동형",
+            "□형(기본형)",
+            "돌집수정 ㄴ형",
+            "돌집수정 ㄷ형"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_material",
+          "label": "집수정 형태",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "조립식 주철맨홀",
+            "돌쌓기(찰)",
+            "돌쌓기(메)"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_length_m",
+          "label": "집수정 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_before_m",
+          "label": "집수정 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_after_m",
+          "label": "집수정 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_form",
+          "label": "유입 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(찰)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_length_m",
+          "label": "유입 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "inlet_revet_before_m",
+          "label": "유입 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_after_m",
+          "label": "유입 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_height_m",
+          "label": "유입 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "outlet_type",
+          "label": "유출구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "outlet_revet_form",
+          "label": "유출 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_length_m",
+          "label": "유출 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "outlet_revet_before_m",
+          "label": "유출 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_after_m",
+          "label": "유출 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_height_m",
+          "label": "유출 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "box_culvert",
+      "group": "A",
+      "name": "BOX암거",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#3b6fd4",
+        "abbr": "암거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "body_width_m",
+          "label": "본체 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "body_height_m",
+          "label": "본체 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "length_m",
+          "label": "연장(계류 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 수량이 안 섬 — 구체 길이는 설계자 입력(기본값 없음 · 2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wall_thickness_m",
+          "label": "측벽 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 벽 0.3 · KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "slab_thickness_m",
+          "label": "상·저판 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.25,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 판 0.25 — ⚠ KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ 에 못 미침(임도 예제 0.25 · KDS 도로 최소 300㎜) · 설계자가 고름",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "haunch_m",
+          "label": "헌치(모따기) 크기",
+          "input": "number",
+          "unit": "m",
+          "default": 0.2,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 0.2×0.2 · 실무 울진 기번3 구조도 2×2 도 0.2 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "blinding_thickness_m",
+          "label": "기초(버림) 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.1,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 기초 0.1(양쪽 0.1 여유) · 실무 울진 기번3 구조도 2×2 버림 0.1 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "trench_depth_m",
+          "label": "평균 터파기고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 구체 터파기·되메우기가 안 섬 — 원지반에서 터파기 바닥(기초잡석 밑)까지 · 토공집계로 감(2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "ford_pavement",
+      "group": "A",
+      "name": "물넘이포장",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#2f9e8f",
+        "abbr": "물넘이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "물넘이 월류 폭 기본 5m — 사용자 확정값(엔진 FORD_PAVEMENT_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "ford_slope_pct",
+          "label": "바닥 경사(유입→유출)",
+          "input": "number",
+          "unit": "%",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "thickness_cm",
+          "label": "포장 두께",
+          "input": "number",
+          "unit": "㎝",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 표가 안 서고 「두께를 적어야 섬」 사유가 뜸 — 두께로 관측 원단위(울진 20㎝)를 고름(2026-09-14 A3)"
+        },
+        {
+          "key": "length_m",
+          "label": "포장 길이(노폭 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 면적(월류 폭 × 길이)이 0 이라 표가 안 서고 사유가 뜸 — 노견까지 전폭을 적음(2026-09-14 A3)"
+        }
+      ]
+    },
+    {
+      "type_id": "ford_bridge",
+      "group": "A",
+      "name": "세월교",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#28857a",
+        "abbr": "세월교"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "pipe_count",
+          "label": "배관 수량",
+          "input": "number",
+          "unit": "련",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "세월교 월류 폭 기본 10m — 사용자 확정값(엔진 FORD_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "cross_drain_exposed",
+      "group": "A",
+      "name": "노출형 횡단수로",
+      "placement": "point",
+      "style": {
+        "color": "#5aa7e8",
+        "abbr": "횡수로"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "open_ditch",
+      "group": "A",
+      "name": "개거(겉도랑)",
+      "placement": "point",
+      "style": {
+        "color": "#6d9bd1",
+        "abbr": "개거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ditch_spec",
+          "label": "규격",
+          "input": "select",
+          "choices": [
+            "콘크리트 개거 150×200",
+            "L형수로 H=0.2"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 붙박이(콘크리트 개거)로 돎"
+        },
+        {
+          "key": "length_m",
+          "label": "연장",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 표가 안 서고 「연장을 적어야 섬」 사유가 뜸 — 개거는 m당 원단위라 연장이 곧 밑수(2026-09-14 A2)"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_side",
+      "enabled": false,
+      "group": "B",
+      "name": "측구(옆도랑)",
+      "design_owner": "횡단 설계",
+      "placement": "interval",
+      "style": {
+        "color": "#2eaadc",
+        "abbr": "측구"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "일반형(제형)",
+            "L형",
+            "U형",
+            "J형"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "depth_cm",
+          "label": "깊이",
+          "input": "number",
+          "unit": "cm",
+          "default": 30
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_ridge",
+      "enabled": false,
+      "group": "B",
+      "name": "산마루측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2e8bdc",
+        "abbr": "산마루"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_berm",
+      "enabled": false,
+      "group": "B",
+      "name": "소단측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2ec5dc",
+        "abbr": "소단구"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "사면 쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "chute",
+      "enabled": false,
+      "group": "B",
+      "name": "도수로·산비탈수로",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9bb8",
+        "abbr": "도수로"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌",
+            "콘크리트",
+            "블록판",
+            "벤치플륨관",
+            "반원관"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "section",
+          "label": "단면형",
+          "input": "select",
+          "choices": [
+            "반달꼴",
+            "U자형",
+            "사다리꼴"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "slope_drain",
+      "enabled": false,
+      "group": "B",
+      "name": "절토사면 배수로",
+      "placement": "interval",
+      "style": {
+        "color": "#28b1a1",
+        "abbr": "사면로"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "underdrain",
+      "enabled": false,
+      "group": "B",
+      "name": "맹암거",
+      "placement": "interval",
+      "style": {
+        "color": "#1f7fb8",
+        "abbr": "맹암거"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "note",
+          "label": "규격",
+          "input": "text",
+          "default": ""
+        }
+      ]
+    },
+    {
+      "type_id": "retaining_wall",
+      "group": "C",
+      "name": "옹벽",
+      "placement": "interval",
+      "style": {
+        "color": "#e07a2e",
+        "abbr": "옹벽"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "default_basis": "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음",
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "중력식",
+            "반중력식",
+            "캔틸레버식",
+            "부벽식",
+            "식생옹벽블럭"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_wet",
+      "group": "C",
+      "name": "돌쌓기(찰)",
+      "placement": "interval",
+      "style": {
+        "color": "#d0692a",
+        "abbr": "찰쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤3.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_dry",
+      "group": "C",
+      "name": "돌쌓기(메)",
+      "placement": "interval",
+      "style": {
+        "color": "#c25d2c",
+        "abbr": "메쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)",
+          "warn_above": 2,
+          "warn_message": "메쌓기 높이 기준을 넘음 — 임도기술교본 7-3:27 「메쌓기는 2.0m 이하」 · 품셈 13-4-4 [주]⑪(원문 L7192) 「높이 3m 이상이면 전부 또는 하부를 찰쌓기」 · 막지 않음(설계자 확인)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "soil_guard",
+      "group": "C",
+      "name": "흙막이",
+      "placement": "interval",
+      "style": {
+        "color": "#b8742e",
+        "abbr": "흙막이"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌(찰)",
+            "돌(메)",
+            "블록쌓기",
+            "돌망태",
+            "흙포대",
+            "통나무쌓기",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 올리지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 옮기지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 돌쌓기 기본값으로 서고 「기본값으로 섰음」이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "default_basis": "「채집」 — 별표2 「야면석 등은 가급적 현장에서 채취·사용」 권고. 구조물마다 바꿀 수 있음",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        }
+      ]
+    },
+    {
+      "type_id": "boulder_masonry",
+      "group": "C",
+      "name": "큰돌쌓기",
+      "placement": "interval",
+      "style": {
+        "color": "#a86a2a",
+        "abbr": "큰돌"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_cm",
+          "label": "돌규격",
+          "input": "select",
+          "choices": [
+            "40~60",
+            "60~80",
+            "80~100"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bond",
+          "label": "쌓기 방식",
+          "input": "select",
+          "choices": [
+            "메쌓기",
+            "찰쌓기"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 채움 콘크리트를 품에 포함 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "berm",
+      "group": "C",
+      "name": "소단",
+      "placement": "interval",
+      "style": {
+        "color": "#7f9a63",
+        "abbr": "소단"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "안쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "erosion_check",
+      "group": "D",
+      "name": "골막이",
+      "placement": "point",
+      "style": {
+        "color": "#7a52c7",
+        "abbr": "골막이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "돌",
+            "돌망태",
+            "콘크리트",
+            "통나무",
+            "바자",
+            "흙"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "spillway",
+          "label": "방수로",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이 ℓ3",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "top_length_m",
+          "label": "상장 ⓐ (윗변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bottom_length_m",
+          "label": "하장 ⓑ (아랫변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 4.5
+        },
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "bed_sill",
+      "group": "D",
+      "name": "바닥막이",
+      "placement": "point",
+      "style": {
+        "color": "#7c5f3b",
+        "abbr": "바닥"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌붙임(찰)",
+            "돌붙임(메)"
+          ],
+          "default": "돌붙임(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 평면적(돌붙임 ㎡)이라 기울기 몫이 없음 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "check_dam_small",
+      "group": "D",
+      "name": "소형사방댐(복합형)",
+      "placement": "point",
+      "style": {
+        "color": "#6b46b8",
+        "abbr": "사방댐"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revetment",
+      "group": "D",
+      "name": "기슭막이",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#9b6bdc",
+        "abbr": "기슭"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "양쪽",
+            "좌",
+            "우"
+          ],
+          "default": "양쪽",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「좌」는 셀렉트 첫 항목일 뿐 도메인 확정값이 아님 — 측점마다 사용자가 고름"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 13-4-4 [주]⑩ 뒷길이 표준 하한(높이·찰/메로 · 범위 안 가장 작은 규격 — 예 메쌓기 1.5~3m 는 36~45㎝ 라 45㎝)으로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "설계자 입력 — 계획홍수위 + 0.5~0.7m(사방기술교본 2-나:141 · 3-가:181 · 사방(계류) 교본 기준). 비우면 줄만 서고 미확정이라 금액에 안 들어감 · 옛 기본 2.5 는 근거 없어 걷음(2026-09-14 브레인 판정)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "refuge",
+      "group": "E",
+      "name": "대피소",
+      "placement": "interval",
+      "style": {
+        "color": "#2fa84f",
+        "abbr": "대피소"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 15
+        }
+      ]
+    },
+    {
+      "type_id": "work_yard",
+      "group": "E",
+      "name": "정차·작업장",
+      "placement": "interval",
+      "style": {
+        "color": "#268f43",
+        "abbr": "작업장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 7
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 20
+        }
+      ]
+    },
+    {
+      "type_id": "turnaround",
+      "group": "E",
+      "name": "차돌림곳",
+      "placement": "site",
+      "style": {
+        "color": "#37b95a",
+        "abbr": "차돌림"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        }
+      ]
+    },
+    {
+      "type_id": "mirror",
+      "group": "E",
+      "name": "반사경",
+      "placement": "point",
+      "style": {
+        "color": "#43c76b",
+        "abbr": "반사경"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": [
+        {
+          "key": "facing",
+          "label": "방향",
+          "input": "select",
+          "choices": [
+            "좌",
+            "우",
+            "양면"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "guardrail",
+      "group": "E",
+      "name": "가드레일·경계석·위험표지",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9e46",
+        "abbr": "가드"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "kind",
+          "label": "종류",
+          "input": "select",
+          "choices": [
+            "가드레일",
+            "경계석",
+            "위험표지"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "position_sign",
+      "group": "E",
+      "name": "국가지점번호판",
+      "placement": "point",
+      "style": {
+        "color": "#53a832",
+        "abbr": "번호판"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "barrier_gate",
+      "group": "E",
+      "name": "차단기",
+      "placement": "point",
+      "style": {
+        "color": "#3f9e2e",
+        "abbr": "차단기"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "completion_sign",
+      "group": "E",
+      "name": "준공표지판",
+      "placement": "point",
+      "style": {
+        "color": "#66b344",
+        "abbr": "준공"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "spoil_bank",
+      "group": "E",
+      "name": "유용토운반작업장(구 사토장)",
+      "placement": "interval",
+      "style": {
+        "color": "#8c9a2e",
+        "abbr": "사토장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "쌓는 쪽",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「자동(성토 쪽)」 — 흙은 성토 쪽에 쌓는다는 지금까지의 동작을 이어받는 표식. 측점마다 좌·우로 바꿈"
+        },
+        {
+          "key": "fill_slope_ratio",
+          "label": "비탈 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 그 측점의 노선 성토 기울기를 그대로 씀 — 지식DB 가 「기본 비탈기울기는 근거에 없다」고 못 박은 자리"
+        },
+        {
+          "key": "extra_distance_m",
+          "label": "추가 운반거리",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "0 = 「추가 없음」 — 노선 안 사토장은 측점 누가거리로 거리가 나오므로 이 칸은 외부 사토장 대비 여벌"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "borrow_pit",
+      "group": "E",
+      "name": "토사채취장(토취장)",
+      "placement": "site",
+      "style": {
+        "color": "#7d8a2a",
+        "abbr": "토취장"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "wildlife_path",
+      "enabled": false,
+      "group": "F",
+      "name": "야생동물 이동통로",
+      "placement": "point",
+      "style": {
+        "color": "#3aa88f",
+        "abbr": "동물길"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "경사로",
+            "자연형계단"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revegetation",
+      "enabled": false,
+      "group": "F",
+      "name": "비탈면 녹화",
+      "placement": "interval",
+      "style": {
+        "color": "#4cb84c",
+        "abbr": "녹화"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "method",
+          "label": "공법",
+          "input": "select",
+          "choices": [
+            "씨뿌리기(줄파종)",
+            "새심기",
+            "선떼붙이기",
+            "줄떼",
+            "평떼",
+            "비탈덮기",
+            "녹생토 뿜어붙이기",
+            "조공",
+            "편책",
+            "나무심기"
+          ],
+          "default": null,
+          "default_basis": "「초류종자 살포」는 여기 없음 — 토공집계에서 사면 전체로 섬(품셈 5-24 · 두 곳에 두면 이중계상 · 2026-09-15 브레인)",
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "face",
+          "label": "대상 면",
+          "input": "select",
+          "choices": [
+            "절토면",
+            "성토면",
+            "양쪽"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "cover_kind",
+          "label": "덮개(비탈덮기)",
+          "input": "select",
+          "choices": [
+            "거적",
+            "짚망",
+            "방초·야자섬유매트"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비탈덮기일 때만 고름 — 비면 비탈덮기 줄이 안 섬(품셈 5-25 거적덮기 ㎡ · 5-28-1 짚망 · 5-28-2 매트 · 재료가 공종을 가름)"
+        },
+        {
+          "key": "step_height_m",
+          "label": "단 직고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기·조공의 단 사이 직고 — 교본은 범위로만 줌(선떼 직고 1~2m · 조공 1.0~1.2m) · 기본값 없음 · 비면 선떼 연장(품셈 5-16-1 [주]② 대상지 직고 ÷ 단 직고 × 연장)이 안 섬"
+        },
+        {
+          "key": "sod_grade",
+          "label": "선떼 급수",
+          "input": "select",
+          "choices": [
+            "1급",
+            "2급",
+            "3급",
+            "4급",
+            "5급",
+            "6급",
+            "7급",
+            "8급",
+            "9급"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기의 급수 — 교본은 1~9급 범위만(6~7급을 많이 씀) · 기본값 없음 · 비면 m당 떼 매수(사방기술교본 표 2-2-6)가 안 섬"
+        },
+        {
+          "key": "sod_size",
+          "label": "선떼 떼 크기",
+          "input": "select",
+          "choices": [
+            "대형 40×40",
+            "소형 18×18"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "사방기술교본 표 2-2-6 이 대형(40×40)·소형(18×18) 두 줄을 나란히 줌 — 우리가 고를 자리가 아니라 기본값 없음 · 비면 선떼 떼 매수가 안 섬"
+        },
+        {
+          "key": "cutting_soil",
+          "label": "단끊기 토질",
+          "input": "select",
+          "choices": [
+            "보통토사",
+            "경질ㆍ고사점토 및 자갈섞인 점토",
+            "호박돌 섞인 토사"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "품셈 5-16-1 단끊기 표의 토질 셋 — B06 지반(토사/암)과 다른 축이라 자동으로 안 고름 · 비면 단끊기 조각만 막힘"
+        }
+      ]
+    },
+    {
+      "type_id": "pavement_concrete",
+      "group": "G",
+      "name": "콘크리트 포장",
+      "placement": "interval",
+      "style": {
+        "color": "#8a8f98",
+        "abbr": "포장"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 포장층 두께(표준 횡단면 설정 · 기본 0.2m = 임도기술교본 3-2 「두께 0.2m」)를 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "width_m",
+          "label": "포장 폭",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 노폭(구간 측점의 차도 표준 폭 · 교본 3-2 「포장 폭 3.0m」 · 실무 관측 3.5~4.0)을 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "widening_area_m2",
+          "label": "확폭 면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 곡선부 확폭을 측점 사이 평균 × 거리로 더함(교본 3-2 「곡선부에는 확폭」) — 확폭이 없으면 0 을 적을 것"
+        },
+        {
+          "key": "joint_spacing_m",
+          "label": "수축줄눈 간격",
+          "input": "number",
+          "unit": "m",
+          "default": 6,
+          "default_basis": "제안값 · 임도기술교본 부록 4-7 7-1 3.5.1 「수축줄눈의 간격은 4-6m를 기준」 · 실무 소광 6m 관측 · 바꿀 수 있음",
+          "phase": "detail"
+        },
+        {
+          "key": "separation_sheet",
+          "label": "비닐(깔기·양생)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 비닐 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「양생 재료비(비닐 등)는 별도 계상」이라 설계자가 고름(기본값 없음)"
+        },
+        {
+          "key": "wire_mesh",
+          "label": "철망",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 철망 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「철망재료비는 별도 계상」 · 교본 부록 7-1 3.4 「설계도서에 따라」 · 실무 소광 「철망포함」 관측"
+        }
+      ]
+    },
+    {
+      "type_id": "gravel_surfacing",
+      "enabled": false,
+      "group": "G",
+      "name": "쇄석(자갈) 포설",
+      "placement": "interval",
+      "style": {
+        "color": "#9aa0a8",
+        "abbr": "쇄석"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "etc",
+      "group": "호환",
+      "name": "기타",
+      "placement": "point",
+      "style": {
+        "color": "#98a2b3",
+        "abbr": "기타"
+      },
+      "drawing_views": [
+        "profile"
+      ],
+      "options": [
+        {
+          "key": "name",
+          "label": "이름",
+          "input": "text",
+          "default": "기타 구조물"
+        }
+      ]
+    }
+  ],
+  "종류": {
+    "pipe": {
+      "동작": [
+        "계곡통과시설",
+        "유입유출_묶음",
+        "기슭막이_한벌"
+      ]
+    },
+    "box_culvert": {
+      "동작": [
+        "계곡통과시설",
+        "BOX_본체규격",
+        "날개벽"
+      ]
+    },
+    "ford_pavement": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면"
+      ]
+    },
+    "ford_bridge": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면",
+        "날개벽"
+      ]
+    },
+    "revetment": {
+      "동작": [
+        "계곡통과시설",
+        "기슭막이_한벌"
+      ]
+    },
+    "pavement_concrete": {
+      "동작": [
+        "포장_물넘이_겹침"
+      ]
+    }
+  },
+  "표시": {},
+  "그룹": {
+    "pipe": [
+      {
+        "id": "grv6lny",
+        "이름": "관",
+        "옵션": [
+          "pipe_kind",
+          "pipe_diameter_mm"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "gnbf9m9",
+        "이름": "관 보호공(유입)",
+        "옵션": [
+          "inlet_type"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "g9lq9uk",
+        "이름": "관 보호공(유출)",
+        "옵션": [],
+        "형상": {}
+      }
+    ]
+  },
+  "배치": {},
+  "규칙": []
+}
diff --git a/resources/master_template/구조물정의_이력/판_4.json b/resources/master_template/구조물정의_이력/판_4.json
new file mode 100644
index 000000000..b97f93b9f
--- /dev/null
+++ b/resources/master_template/구조물정의_이력/판_4.json
@@ -0,0 +1,3299 @@
+{
+  "판": 4,
+  "schema_version": 1,
+  "comment": "B05 구조물 타입 레지스트리 정본. 근거·옵션 상세는 PLAN.md 구조물 리스트와 resources/knowledge/technical_info/01_임도 참조. 2026-08-17 선택지 재편: B군(종단배수)·F군(생태/녹화)·G군(노면공)은 enabled:false 보존 — B05 선택지에서 빠지고 B06 개별 횡단도 옵션으로 재사용한다. 바닥막이(bed_sill)·생태연못(eco_pond)은 임도 미사용 확정으로 삭제. 배관·BOX암거·물넘이·세월교는 pipe_points.json 정본 관리(managed_by) — structures.json에 저장하지 않으며, 배관 부속(유형/집수정/기슭막이/돌붙임)·날개벽 옵션 정의는 B06/B07 필수 승격의 선언 근거다. ★기본값 원칙(2026-08-16 크로스체크 2차): default를 두는 것은 ①법정이 등급과 무관하게 못박은 단일 수치 ②사용자가 개발 단계에서 확정한 값 ③도메인 수치가 아닌 표시용 문자열, 이 셋뿐이다. 재료·형식 같은 설계자 판단 선택지와 미확정 제원은 default 없이 required로 두어 사용자가 직접 고르게 한다 (pipe_diameter_mm 1000 = 별표2 원칙값+사용자 확정 — 화이트리스트 등재). BOX암거 본체 2.0×2.0·날개벽 유입/유출 있음·짧은쪽 높이 1m·길이 2m·각도 45°는 2026-08-17 사용자 확정값이다 — 본체 규격은 실무 관측 규격(2.0×2.0·3.0×3.0)을 폼에서 프리셋 select로 받고 필요 시 사용자 지정으로 자유 입력하되, 저장 키는 body_width_m·body_height_m 숫자 그대로다(프리셋 전용 키를 만들지 않는다). 이 값들은 B05 서브폼이 실제로 받으므로 phase를 detail로 두지 않는다. ★보호공 개편(2026-08-17 사용자 지시): 구 `*_pitching`(있음/없음) + `*_pitching_finish`(찰/메) 두 축을 `*_protection` 한 축(돌붙임(찰)·돌붙임(메)·도수로)으로 합쳤다 — 도수로·산비탈수로(B4)는 유출부에서 돌붙임 대신 쓰는 공종이라 별도 구조물이 아니라 보호공 선택지로 받는다. \"없음\"은 삭제(물이 흐르는 자리라 보호공 필수). 치수는 배타 — 돌붙임이면 `*_protection_area_m2`(10㎡), 도수로면 `*_protection_width_m`(1m, 지식DB 수치 근거 없음·사용자 확정, 실무 확인 후 개선). 구 저장분은 `common_util_drainage_pipes.parse_pipe_points`가 새 키로 옮긴다.",
+  "구조물군": {
+    "A": "A 횡단배수",
+    "B": "B 종단배수",
+    "C": "C 사면안정",
+    "D": "D 계류·사방",
+    "E": "E 안전·부대·용지",
+    "F": "F 생태·녹화",
+    "G": "G 노면공",
+    "호환": "기타"
+  },
+  "동작": {
+    "계곡통과시설": "관 지점 정본(pipe_points.json) 시설 — 부속 옵션 서브폼을 손코딩으로 그림 · 저장은 폼이 아는 칸만 갈아 끼움",
+    "유입유출_묶음": "관 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹",
+    "기슭막이_한벌": "기슭막이 형태 · 길이 · 높이 · 바닥 보호공 한 벌 — 관 유입 · 유출 · 독립 기슭막이가 같은 조각",
+    "BOX_본체규격": "BOX암거 본체 규격 프리셋 고르기(폭 × 높이 한 칸)",
+    "날개벽": "날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 조각",
+    "월류단면": "월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 줄 · 필요 수심 미만은 되돌림",
+    "포장_물넘이_겹침": "포장 구간이 물넘이포장을 품으면 앞 · 뒤로 나눔 · 끝만 걸치면 저장 멈춤"
+  },
+  "types": [
+    {
+      "type_id": "pipe",
+      "group": "A",
+      "name": "배관",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#4f8ef7",
+        "abbr": "배수관"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false,
+          "enabled": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "inlet_type",
+          "label": "유입구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이",
+            "집수정"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "wing_wall_type",
+          "label": "관보호공 날개벽",
+          "input": "select",
+          "choices": [
+            "A-TYPE",
+            "C-TYPE",
+            "A-TYPE+집수정"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 날개벽을 안 셈 — 고르면 그 형식의 개소당 원단위로 한 줄이 섬(Ø800·Ø1000 만 있음)"
+        },
+        {
+          "key": "inlet_basin_form",
+          "label": "집수정 형식",
+          "input": "select",
+          "choices": [
+            "동물이동형",
+            "□형(기본형)",
+            "돌집수정 ㄴ형",
+            "돌집수정 ㄷ형"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_material",
+          "label": "집수정 형태",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "조립식 주철맨홀",
+            "돌쌓기(찰)",
+            "돌쌓기(메)"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_length_m",
+          "label": "집수정 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_before_m",
+          "label": "집수정 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_after_m",
+          "label": "집수정 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_form",
+          "label": "유입 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(찰)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_length_m",
+          "label": "유입 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "inlet_revet_before_m",
+          "label": "유입 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_after_m",
+          "label": "유입 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_height_m",
+          "label": "유입 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "outlet_type",
+          "label": "유출구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "outlet_revet_form",
+          "label": "유출 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_length_m",
+          "label": "유출 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "outlet_revet_before_m",
+          "label": "유출 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_after_m",
+          "label": "유출 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_height_m",
+          "label": "유출 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "box_culvert",
+      "group": "A",
+      "name": "BOX암거",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#3b6fd4",
+        "abbr": "암거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "body_width_m",
+          "label": "본체 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "body_height_m",
+          "label": "본체 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "length_m",
+          "label": "연장(계류 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 수량이 안 섬 — 구체 길이는 설계자 입력(기본값 없음 · 2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wall_thickness_m",
+          "label": "측벽 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 벽 0.3 · KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "slab_thickness_m",
+          "label": "상·저판 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.25,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 판 0.25 — ⚠ KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ 에 못 미침(임도 예제 0.25 · KDS 도로 최소 300㎜) · 설계자가 고름",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "haunch_m",
+          "label": "헌치(모따기) 크기",
+          "input": "number",
+          "unit": "m",
+          "default": 0.2,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 0.2×0.2 · 실무 울진 기번3 구조도 2×2 도 0.2 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "blinding_thickness_m",
+          "label": "기초(버림) 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.1,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 기초 0.1(양쪽 0.1 여유) · 실무 울진 기번3 구조도 2×2 버림 0.1 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "trench_depth_m",
+          "label": "평균 터파기고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 구체 터파기·되메우기가 안 섬 — 원지반에서 터파기 바닥(기초잡석 밑)까지 · 토공집계로 감(2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "ford_pavement",
+      "group": "A",
+      "name": "물넘이포장",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#2f9e8f",
+        "abbr": "물넘이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "물넘이 월류 폭 기본 5m — 사용자 확정값(엔진 FORD_PAVEMENT_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "ford_slope_pct",
+          "label": "바닥 경사(유입→유출)",
+          "input": "number",
+          "unit": "%",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "thickness_cm",
+          "label": "포장 두께",
+          "input": "number",
+          "unit": "㎝",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 표가 안 서고 「두께를 적어야 섬」 사유가 뜸 — 두께로 관측 원단위(울진 20㎝)를 고름(2026-09-14 A3)"
+        },
+        {
+          "key": "length_m",
+          "label": "포장 길이(노폭 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 면적(월류 폭 × 길이)이 0 이라 표가 안 서고 사유가 뜸 — 노견까지 전폭을 적음(2026-09-14 A3)"
+        }
+      ]
+    },
+    {
+      "type_id": "ford_bridge",
+      "group": "A",
+      "name": "세월교",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#28857a",
+        "abbr": "세월교"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "pipe_count",
+          "label": "배관 수량",
+          "input": "number",
+          "unit": "련",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "세월교 월류 폭 기본 10m — 사용자 확정값(엔진 FORD_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "cross_drain_exposed",
+      "group": "A",
+      "name": "노출형 횡단수로",
+      "placement": "point",
+      "style": {
+        "color": "#5aa7e8",
+        "abbr": "횡수로"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "open_ditch",
+      "group": "A",
+      "name": "개거(겉도랑)",
+      "placement": "point",
+      "style": {
+        "color": "#6d9bd1",
+        "abbr": "개거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ditch_spec",
+          "label": "규격",
+          "input": "select",
+          "choices": [
+            "콘크리트 개거 150×200",
+            "L형수로 H=0.2"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 붙박이(콘크리트 개거)로 돎"
+        },
+        {
+          "key": "length_m",
+          "label": "연장",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 표가 안 서고 「연장을 적어야 섬」 사유가 뜸 — 개거는 m당 원단위라 연장이 곧 밑수(2026-09-14 A2)"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_side",
+      "enabled": false,
+      "group": "B",
+      "name": "측구(옆도랑)",
+      "design_owner": "횡단 설계",
+      "placement": "interval",
+      "style": {
+        "color": "#2eaadc",
+        "abbr": "측구"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "일반형(제형)",
+            "L형",
+            "U형",
+            "J형"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "depth_cm",
+          "label": "깊이",
+          "input": "number",
+          "unit": "cm",
+          "default": 30
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_ridge",
+      "enabled": false,
+      "group": "B",
+      "name": "산마루측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2e8bdc",
+        "abbr": "산마루"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_berm",
+      "enabled": false,
+      "group": "B",
+      "name": "소단측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2ec5dc",
+        "abbr": "소단구"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "사면 쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "chute",
+      "enabled": false,
+      "group": "B",
+      "name": "도수로·산비탈수로",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9bb8",
+        "abbr": "도수로"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌",
+            "콘크리트",
+            "블록판",
+            "벤치플륨관",
+            "반원관"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "section",
+          "label": "단면형",
+          "input": "select",
+          "choices": [
+            "반달꼴",
+            "U자형",
+            "사다리꼴"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "slope_drain",
+      "enabled": false,
+      "group": "B",
+      "name": "절토사면 배수로",
+      "placement": "interval",
+      "style": {
+        "color": "#28b1a1",
+        "abbr": "사면로"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "underdrain",
+      "enabled": false,
+      "group": "B",
+      "name": "맹암거",
+      "placement": "interval",
+      "style": {
+        "color": "#1f7fb8",
+        "abbr": "맹암거"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "note",
+          "label": "규격",
+          "input": "text",
+          "default": ""
+        }
+      ]
+    },
+    {
+      "type_id": "retaining_wall",
+      "group": "C",
+      "name": "옹벽",
+      "placement": "interval",
+      "style": {
+        "color": "#e07a2e",
+        "abbr": "옹벽"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "default_basis": "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음",
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "중력식",
+            "반중력식",
+            "캔틸레버식",
+            "부벽식",
+            "식생옹벽블럭"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_wet",
+      "group": "C",
+      "name": "돌쌓기(찰)",
+      "placement": "interval",
+      "style": {
+        "color": "#d0692a",
+        "abbr": "찰쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤3.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_dry",
+      "group": "C",
+      "name": "돌쌓기(메)",
+      "placement": "interval",
+      "style": {
+        "color": "#c25d2c",
+        "abbr": "메쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)",
+          "warn_above": 2,
+          "warn_message": "메쌓기 높이 기준을 넘음 — 임도기술교본 7-3:27 「메쌓기는 2.0m 이하」 · 품셈 13-4-4 [주]⑪(원문 L7192) 「높이 3m 이상이면 전부 또는 하부를 찰쌓기」 · 막지 않음(설계자 확인)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "soil_guard",
+      "group": "C",
+      "name": "흙막이",
+      "placement": "interval",
+      "style": {
+        "color": "#b8742e",
+        "abbr": "흙막이"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌(찰)",
+            "돌(메)",
+            "블록쌓기",
+            "돌망태",
+            "흙포대",
+            "통나무쌓기",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 올리지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 옮기지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 돌쌓기 기본값으로 서고 「기본값으로 섰음」이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "default_basis": "「채집」 — 별표2 「야면석 등은 가급적 현장에서 채취·사용」 권고. 구조물마다 바꿀 수 있음",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        }
+      ]
+    },
+    {
+      "type_id": "boulder_masonry",
+      "group": "C",
+      "name": "큰돌쌓기",
+      "placement": "interval",
+      "style": {
+        "color": "#a86a2a",
+        "abbr": "큰돌"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_cm",
+          "label": "돌규격",
+          "input": "select",
+          "choices": [
+            "40~60",
+            "60~80",
+            "80~100"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bond",
+          "label": "쌓기 방식",
+          "input": "select",
+          "choices": [
+            "메쌓기",
+            "찰쌓기"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 채움 콘크리트를 품에 포함 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "berm",
+      "group": "C",
+      "name": "소단",
+      "placement": "interval",
+      "style": {
+        "color": "#7f9a63",
+        "abbr": "소단"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "안쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "erosion_check",
+      "group": "D",
+      "name": "골막이",
+      "placement": "point",
+      "style": {
+        "color": "#7a52c7",
+        "abbr": "골막이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "돌",
+            "돌망태",
+            "콘크리트",
+            "통나무",
+            "바자",
+            "흙"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "spillway",
+          "label": "방수로",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이 ℓ3",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "top_length_m",
+          "label": "상장 ⓐ (윗변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bottom_length_m",
+          "label": "하장 ⓑ (아랫변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 4.5
+        },
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "bed_sill",
+      "group": "D",
+      "name": "바닥막이",
+      "placement": "point",
+      "style": {
+        "color": "#7c5f3b",
+        "abbr": "바닥"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌붙임(찰)",
+            "돌붙임(메)"
+          ],
+          "default": "돌붙임(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 평면적(돌붙임 ㎡)이라 기울기 몫이 없음 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "check_dam_small",
+      "group": "D",
+      "name": "소형사방댐(복합형)",
+      "placement": "point",
+      "style": {
+        "color": "#6b46b8",
+        "abbr": "사방댐"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revetment",
+      "group": "D",
+      "name": "기슭막이",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#9b6bdc",
+        "abbr": "기슭"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "양쪽",
+            "좌",
+            "우"
+          ],
+          "default": "양쪽",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「좌」는 셀렉트 첫 항목일 뿐 도메인 확정값이 아님 — 측점마다 사용자가 고름"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 13-4-4 [주]⑩ 뒷길이 표준 하한(높이·찰/메로 · 범위 안 가장 작은 규격 — 예 메쌓기 1.5~3m 는 36~45㎝ 라 45㎝)으로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "설계자 입력 — 계획홍수위 + 0.5~0.7m(사방기술교본 2-나:141 · 3-가:181 · 사방(계류) 교본 기준). 비우면 줄만 서고 미확정이라 금액에 안 들어감 · 옛 기본 2.5 는 근거 없어 걷음(2026-09-14 브레인 판정)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "refuge",
+      "group": "E",
+      "name": "대피소",
+      "placement": "interval",
+      "style": {
+        "color": "#2fa84f",
+        "abbr": "대피소"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 15
+        }
+      ]
+    },
+    {
+      "type_id": "work_yard",
+      "group": "E",
+      "name": "정차·작업장",
+      "placement": "interval",
+      "style": {
+        "color": "#268f43",
+        "abbr": "작업장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 7
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 20
+        }
+      ]
+    },
+    {
+      "type_id": "turnaround",
+      "group": "E",
+      "name": "차돌림곳",
+      "placement": "site",
+      "style": {
+        "color": "#37b95a",
+        "abbr": "차돌림"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        }
+      ]
+    },
+    {
+      "type_id": "mirror",
+      "group": "E",
+      "name": "반사경",
+      "placement": "point",
+      "style": {
+        "color": "#43c76b",
+        "abbr": "반사경"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": [
+        {
+          "key": "facing",
+          "label": "방향",
+          "input": "select",
+          "choices": [
+            "좌",
+            "우",
+            "양면"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "guardrail",
+      "group": "E",
+      "name": "가드레일·경계석·위험표지",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9e46",
+        "abbr": "가드"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "kind",
+          "label": "종류",
+          "input": "select",
+          "choices": [
+            "가드레일",
+            "경계석",
+            "위험표지"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "position_sign",
+      "group": "E",
+      "name": "국가지점번호판",
+      "placement": "point",
+      "style": {
+        "color": "#53a832",
+        "abbr": "번호판"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "barrier_gate",
+      "group": "E",
+      "name": "차단기",
+      "placement": "point",
+      "style": {
+        "color": "#3f9e2e",
+        "abbr": "차단기"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "completion_sign",
+      "group": "E",
+      "name": "준공표지판",
+      "placement": "point",
+      "style": {
+        "color": "#66b344",
+        "abbr": "준공"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "spoil_bank",
+      "group": "E",
+      "name": "유용토운반작업장(구 사토장)",
+      "placement": "interval",
+      "style": {
+        "color": "#8c9a2e",
+        "abbr": "사토장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "쌓는 쪽",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「자동(성토 쪽)」 — 흙은 성토 쪽에 쌓는다는 지금까지의 동작을 이어받는 표식. 측점마다 좌·우로 바꿈"
+        },
+        {
+          "key": "fill_slope_ratio",
+          "label": "비탈 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 그 측점의 노선 성토 기울기를 그대로 씀 — 지식DB 가 「기본 비탈기울기는 근거에 없다」고 못 박은 자리"
+        },
+        {
+          "key": "extra_distance_m",
+          "label": "추가 운반거리",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "0 = 「추가 없음」 — 노선 안 사토장은 측점 누가거리로 거리가 나오므로 이 칸은 외부 사토장 대비 여벌"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "borrow_pit",
+      "group": "E",
+      "name": "토사채취장(토취장)",
+      "placement": "site",
+      "style": {
+        "color": "#7d8a2a",
+        "abbr": "토취장"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "wildlife_path",
+      "enabled": false,
+      "group": "F",
+      "name": "야생동물 이동통로",
+      "placement": "point",
+      "style": {
+        "color": "#3aa88f",
+        "abbr": "동물길"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "경사로",
+            "자연형계단"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revegetation",
+      "enabled": false,
+      "group": "F",
+      "name": "비탈면 녹화",
+      "placement": "interval",
+      "style": {
+        "color": "#4cb84c",
+        "abbr": "녹화"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "method",
+          "label": "공법",
+          "input": "select",
+          "choices": [
+            "씨뿌리기(줄파종)",
+            "새심기",
+            "선떼붙이기",
+            "줄떼",
+            "평떼",
+            "비탈덮기",
+            "녹생토 뿜어붙이기",
+            "조공",
+            "편책",
+            "나무심기"
+          ],
+          "default": null,
+          "default_basis": "「초류종자 살포」는 여기 없음 — 토공집계에서 사면 전체로 섬(품셈 5-24 · 두 곳에 두면 이중계상 · 2026-09-15 브레인)",
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "face",
+          "label": "대상 면",
+          "input": "select",
+          "choices": [
+            "절토면",
+            "성토면",
+            "양쪽"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "cover_kind",
+          "label": "덮개(비탈덮기)",
+          "input": "select",
+          "choices": [
+            "거적",
+            "짚망",
+            "방초·야자섬유매트"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비탈덮기일 때만 고름 — 비면 비탈덮기 줄이 안 섬(품셈 5-25 거적덮기 ㎡ · 5-28-1 짚망 · 5-28-2 매트 · 재료가 공종을 가름)"
+        },
+        {
+          "key": "step_height_m",
+          "label": "단 직고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기·조공의 단 사이 직고 — 교본은 범위로만 줌(선떼 직고 1~2m · 조공 1.0~1.2m) · 기본값 없음 · 비면 선떼 연장(품셈 5-16-1 [주]② 대상지 직고 ÷ 단 직고 × 연장)이 안 섬"
+        },
+        {
+          "key": "sod_grade",
+          "label": "선떼 급수",
+          "input": "select",
+          "choices": [
+            "1급",
+            "2급",
+            "3급",
+            "4급",
+            "5급",
+            "6급",
+            "7급",
+            "8급",
+            "9급"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기의 급수 — 교본은 1~9급 범위만(6~7급을 많이 씀) · 기본값 없음 · 비면 m당 떼 매수(사방기술교본 표 2-2-6)가 안 섬"
+        },
+        {
+          "key": "sod_size",
+          "label": "선떼 떼 크기",
+          "input": "select",
+          "choices": [
+            "대형 40×40",
+            "소형 18×18"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "사방기술교본 표 2-2-6 이 대형(40×40)·소형(18×18) 두 줄을 나란히 줌 — 우리가 고를 자리가 아니라 기본값 없음 · 비면 선떼 떼 매수가 안 섬"
+        },
+        {
+          "key": "cutting_soil",
+          "label": "단끊기 토질",
+          "input": "select",
+          "choices": [
+            "보통토사",
+            "경질ㆍ고사점토 및 자갈섞인 점토",
+            "호박돌 섞인 토사"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "품셈 5-16-1 단끊기 표의 토질 셋 — B06 지반(토사/암)과 다른 축이라 자동으로 안 고름 · 비면 단끊기 조각만 막힘"
+        }
+      ]
+    },
+    {
+      "type_id": "pavement_concrete",
+      "group": "G",
+      "name": "콘크리트 포장",
+      "placement": "interval",
+      "style": {
+        "color": "#8a8f98",
+        "abbr": "포장"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 포장층 두께(표준 횡단면 설정 · 기본 0.2m = 임도기술교본 3-2 「두께 0.2m」)를 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "width_m",
+          "label": "포장 폭",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 노폭(구간 측점의 차도 표준 폭 · 교본 3-2 「포장 폭 3.0m」 · 실무 관측 3.5~4.0)을 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "widening_area_m2",
+          "label": "확폭 면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 곡선부 확폭을 측점 사이 평균 × 거리로 더함(교본 3-2 「곡선부에는 확폭」) — 확폭이 없으면 0 을 적을 것"
+        },
+        {
+          "key": "joint_spacing_m",
+          "label": "수축줄눈 간격",
+          "input": "number",
+          "unit": "m",
+          "default": 6,
+          "default_basis": "제안값 · 임도기술교본 부록 4-7 7-1 3.5.1 「수축줄눈의 간격은 4-6m를 기준」 · 실무 소광 6m 관측 · 바꿀 수 있음",
+          "phase": "detail"
+        },
+        {
+          "key": "separation_sheet",
+          "label": "비닐(깔기·양생)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 비닐 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「양생 재료비(비닐 등)는 별도 계상」이라 설계자가 고름(기본값 없음)"
+        },
+        {
+          "key": "wire_mesh",
+          "label": "철망",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 철망 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「철망재료비는 별도 계상」 · 교본 부록 7-1 3.4 「설계도서에 따라」 · 실무 소광 「철망포함」 관측"
+        }
+      ]
+    },
+    {
+      "type_id": "gravel_surfacing",
+      "enabled": false,
+      "group": "G",
+      "name": "쇄석(자갈) 포설",
+      "placement": "interval",
+      "style": {
+        "color": "#9aa0a8",
+        "abbr": "쇄석"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "etc",
+      "group": "호환",
+      "name": "기타",
+      "placement": "point",
+      "style": {
+        "color": "#98a2b3",
+        "abbr": "기타"
+      },
+      "drawing_views": [
+        "profile"
+      ],
+      "options": [
+        {
+          "key": "name",
+          "label": "이름",
+          "input": "text",
+          "default": "기타 구조물"
+        }
+      ]
+    }
+  ],
+  "종류": {
+    "pipe": {
+      "동작": [
+        "계곡통과시설",
+        "유입유출_묶음",
+        "기슭막이_한벌"
+      ]
+    },
+    "box_culvert": {
+      "동작": [
+        "계곡통과시설",
+        "BOX_본체규격",
+        "날개벽"
+      ]
+    },
+    "ford_pavement": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면"
+      ]
+    },
+    "ford_bridge": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면",
+        "날개벽"
+      ]
+    },
+    "revetment": {
+      "동작": [
+        "계곡통과시설",
+        "기슭막이_한벌"
+      ]
+    },
+    "pavement_concrete": {
+      "동작": [
+        "포장_물넘이_겹침"
+      ]
+    }
+  },
+  "표시": {},
+  "그룹": {
+    "pipe": [
+      {
+        "id": "grv6lny",
+        "이름": "관",
+        "옵션": [
+          "pipe_kind",
+          "pipe_diameter_mm"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "gnbf9m9",
+        "이름": "관 보호공(유입)",
+        "옵션": [
+          "inlet_type"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "g9lq9uk",
+        "이름": "관 보호공(유출)",
+        "옵션": [],
+        "형상": {}
+      }
+    ]
+  },
+  "배치": {},
+  "규칙": []
+}
diff --git a/resources/master_template/구조물정의_이력/판_5.json b/resources/master_template/구조물정의_이력/판_5.json
new file mode 100644
index 000000000..ce30d572d
--- /dev/null
+++ b/resources/master_template/구조물정의_이력/판_5.json
@@ -0,0 +1,3303 @@
+{
+  "판": 5,
+  "schema_version": 1,
+  "comment": "B05 구조물 타입 레지스트리 정본. 근거·옵션 상세는 PLAN.md 구조물 리스트와 resources/knowledge/technical_info/01_임도 참조. 2026-08-17 선택지 재편: B군(종단배수)·F군(생태/녹화)·G군(노면공)은 enabled:false 보존 — B05 선택지에서 빠지고 B06 개별 횡단도 옵션으로 재사용한다. 바닥막이(bed_sill)·생태연못(eco_pond)은 임도 미사용 확정으로 삭제. 배관·BOX암거·물넘이·세월교는 pipe_points.json 정본 관리(managed_by) — structures.json에 저장하지 않으며, 배관 부속(유형/집수정/기슭막이/돌붙임)·날개벽 옵션 정의는 B06/B07 필수 승격의 선언 근거다. ★기본값 원칙(2026-08-16 크로스체크 2차): default를 두는 것은 ①법정이 등급과 무관하게 못박은 단일 수치 ②사용자가 개발 단계에서 확정한 값 ③도메인 수치가 아닌 표시용 문자열, 이 셋뿐이다. 재료·형식 같은 설계자 판단 선택지와 미확정 제원은 default 없이 required로 두어 사용자가 직접 고르게 한다 (pipe_diameter_mm 1000 = 별표2 원칙값+사용자 확정 — 화이트리스트 등재). BOX암거 본체 2.0×2.0·날개벽 유입/유출 있음·짧은쪽 높이 1m·길이 2m·각도 45°는 2026-08-17 사용자 확정값이다 — 본체 규격은 실무 관측 규격(2.0×2.0·3.0×3.0)을 폼에서 프리셋 select로 받고 필요 시 사용자 지정으로 자유 입력하되, 저장 키는 body_width_m·body_height_m 숫자 그대로다(프리셋 전용 키를 만들지 않는다). 이 값들은 B05 서브폼이 실제로 받으므로 phase를 detail로 두지 않는다. ★보호공 개편(2026-08-17 사용자 지시): 구 `*_pitching`(있음/없음) + `*_pitching_finish`(찰/메) 두 축을 `*_protection` 한 축(돌붙임(찰)·돌붙임(메)·도수로)으로 합쳤다 — 도수로·산비탈수로(B4)는 유출부에서 돌붙임 대신 쓰는 공종이라 별도 구조물이 아니라 보호공 선택지로 받는다. \"없음\"은 삭제(물이 흐르는 자리라 보호공 필수). 치수는 배타 — 돌붙임이면 `*_protection_area_m2`(10㎡), 도수로면 `*_protection_width_m`(1m, 지식DB 수치 근거 없음·사용자 확정, 실무 확인 후 개선). 구 저장분은 `common_util_drainage_pipes.parse_pipe_points`가 새 키로 옮긴다.",
+  "구조물군": {
+    "A": "A 횡단배수",
+    "B": "B 종단배수",
+    "C": "C 사면안정",
+    "D": "D 계류·사방",
+    "E": "E 안전·부대·용지",
+    "F": "F 생태·녹화",
+    "G": "G 노면공",
+    "호환": "기타"
+  },
+  "동작": {
+    "계곡통과시설": "관 지점 정본(pipe_points.json) 시설 — 부속 옵션 서브폼을 손코딩으로 그림 · 저장은 폼이 아는 칸만 갈아 끼움",
+    "유입유출_묶음": "관 유입구(집수정 · 기슭막이 택일) · 유출구(기슭막이) 소그룹",
+    "기슭막이_한벌": "기슭막이 형태 · 길이 · 높이 · 바닥 보호공 한 벌 — 관 유입 · 유출 · 독립 기슭막이가 같은 조각",
+    "BOX_본체규격": "BOX암거 본체 규격 프리셋 고르기(폭 × 높이 한 칸)",
+    "날개벽": "날개벽 유입 · 유출 · 짧은쪽 높이 · 길이 · 각도 조각",
+    "월류단면": "월류 폭 · 높이 · 바닥 경사 · 포장 두께 + 개략 단면 줄 · 필요 수심 미만은 되돌림",
+    "포장_물넘이_겹침": "포장 구간이 물넘이포장을 품으면 앞 · 뒤로 나눔 · 끝만 걸치면 저장 멈춤"
+  },
+  "types": [
+    {
+      "type_id": "pipe",
+      "group": "A",
+      "name": "배관",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#4f8ef7",
+        "abbr": "배수관"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false,
+          "enabled": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "inlet_type",
+          "label": "유입구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이",
+            "집수정"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "wing_wall_type",
+          "label": "관보호공 날개벽",
+          "input": "select",
+          "choices": [
+            "A-TYPE",
+            "C-TYPE",
+            "A-TYPE+집수정"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 날개벽을 안 셈 — 고르면 그 형식의 개소당 원단위로 한 줄이 섬(Ø800·Ø1000 만 있음)"
+        },
+        {
+          "key": "inlet_basin_form",
+          "label": "집수정 형식",
+          "input": "select",
+          "choices": [
+            "동물이동형",
+            "□형(기본형)",
+            "돌집수정 ㄴ형",
+            "돌집수정 ㄷ형"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_material",
+          "label": "집수정 형태",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "조립식 주철맨홀",
+            "돌쌓기(찰)",
+            "돌쌓기(메)"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_length_m",
+          "label": "집수정 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_before_m",
+          "label": "집수정 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_basin_after_m",
+          "label": "집수정 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_form",
+          "label": "유입 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(찰)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_length_m",
+          "label": "유입 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "inlet_revet_before_m",
+          "label": "유입 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_after_m",
+          "label": "유입 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "inlet_revet_height_m",
+          "label": "유입 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "outlet_type",
+          "label": "유출구 구조",
+          "input": "select",
+          "choices": [
+            "기슭막이"
+          ],
+          "default": "기슭막이",
+          "required": false
+        },
+        {
+          "key": "outlet_revet_form",
+          "label": "유출 기슭막이 형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_length_m",
+          "label": "유출 기슭막이 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false
+        },
+        {
+          "key": "outlet_revet_before_m",
+          "label": "유출 기슭막이 기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_after_m",
+          "label": "유출 기슭막이 기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "outlet_revet_height_m",
+          "label": "유출 기슭막이 높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 관경 기준 최소 높이(관경 + 여유 0.5 를 0.1m 로 올림 + 근입 0.5)로 그리고 셈 — 횡단도·구조물도·표가 같은 값 · 최소라 수량은 미확정(금액 밖) · 2026-09-14 브레인 판정(옛 기본 2.5 걷음)"
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "box_culvert",
+      "group": "A",
+      "name": "BOX암거",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#3b6fd4",
+        "abbr": "암거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "body_width_m",
+          "label": "본체 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "revet_foundation",
+          "label": "기슭막이 기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "body_height_m",
+          "label": "본체 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "length_m",
+          "label": "연장(계류 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 수량이 안 섬 — 구체 길이는 설계자 입력(기본값 없음 · 2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wall_thickness_m",
+          "label": "측벽 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 벽 0.3 · KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "slab_thickness_m",
+          "label": "상·저판 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.25,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 판 0.25 — ⚠ KDS 44 90 00 4.5.2 도로암거 부재 최소두께 300㎜ 에 못 미침(임도 예제 0.25 · KDS 도로 최소 300㎜) · 설계자가 고름",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "haunch_m",
+          "label": "헌치(모따기) 크기",
+          "input": "number",
+          "unit": "m",
+          "default": 0.2,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 0.2×0.2 · 실무 울진 기번3 구조도 2×2 도 0.2 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "blinding_thickness_m",
+          "label": "기초(버림) 두께",
+          "input": "number",
+          "unit": "m",
+          "default": 0.1,
+          "default_basis": "제안값 · 산림과임업기술(임도) 5장 수량산출 예제 기초 0.1(양쪽 0.1 여유) · 실무 울진 기번3 구조도 2×2 버림 0.1 · 바꿀 수 있음",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "trench_depth_m",
+          "label": "평균 터파기고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 구체 터파기·되메우기가 안 섬 — 원지반에서 터파기 바닥(기초잡석 밑)까지 · 토공집계로 감(2026-09-15 브레인 판정 ③)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "ford_pavement",
+      "group": "A",
+      "name": "물넘이포장",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#2f9e8f",
+        "abbr": "물넘이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "물넘이 월류 폭 기본 5m — 사용자 확정값(엔진 FORD_PAVEMENT_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "ford_slope_pct",
+          "label": "바닥 경사(유입→유출)",
+          "input": "number",
+          "unit": "%",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "thickness_cm",
+          "label": "포장 두께",
+          "input": "number",
+          "unit": "㎝",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 표가 안 서고 「두께를 적어야 섬」 사유가 뜸 — 두께로 관측 원단위(울진 20㎝)를 고름(2026-09-14 A3)"
+        },
+        {
+          "key": "length_m",
+          "label": "포장 길이(노폭 방향)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 면적(월류 폭 × 길이)이 0 이라 표가 안 서고 사유가 뜸 — 노견까지 전폭을 적음(2026-09-14 A3)"
+        }
+      ]
+    },
+    {
+      "type_id": "ford_bridge",
+      "group": "A",
+      "name": "세월교",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#28857a",
+        "abbr": "세월교"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "pipe_kind",
+          "label": "관종",
+          "input": "select",
+          "choices": [
+            "흄관",
+            "VR관",
+            "파형강관"
+          ],
+          "default": "파형강관",
+          "required": false
+        },
+        {
+          "key": "pipe_diameter_mm",
+          "label": "관경",
+          "input": "select",
+          "choices": [
+            "800",
+            "1000",
+            "1200",
+            "1500"
+          ],
+          "unit": "mm",
+          "default": "1000",
+          "required": false
+        },
+        {
+          "key": "pipe_count",
+          "label": "배관 수량",
+          "input": "number",
+          "unit": "련",
+          "default": null,
+          "required": false
+        },
+        {
+          "key": "ford_width_m",
+          "label": "월류 폭",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "세월교 월류 폭 기본 10m — 사용자 확정값(엔진 FORD_DEFAULT_WIDTH_M 과 같음)"
+        },
+        {
+          "key": "wing_in",
+          "label": "날개벽(유입)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_in_height_m",
+          "label": "유입 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_in_length_m",
+          "label": "유입 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_in_angle_deg",
+          "label": "유입 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        },
+        {
+          "key": "wing_out",
+          "label": "날개벽(유출)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": "있음",
+          "required": false
+        },
+        {
+          "key": "wing_out_height_m",
+          "label": "유출 날개벽 짧은쪽 높이",
+          "input": "number",
+          "unit": "m",
+          "default": 1,
+          "required": false
+        },
+        {
+          "key": "wing_out_length_m",
+          "label": "유출 날개벽 길이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "required": false
+        },
+        {
+          "key": "wing_out_angle_deg",
+          "label": "유출 날개벽 각도",
+          "input": "number",
+          "unit": "°",
+          "default": 45,
+          "required": false
+        }
+      ]
+    },
+    {
+      "type_id": "cross_drain_exposed",
+      "group": "A",
+      "name": "노출형 횡단수로",
+      "placement": "point",
+      "style": {
+        "color": "#5aa7e8",
+        "abbr": "횡수로"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "open_ditch",
+      "group": "A",
+      "name": "개거(겉도랑)",
+      "placement": "point",
+      "style": {
+        "color": "#6d9bd1",
+        "abbr": "개거"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "ditch_spec",
+          "label": "규격",
+          "input": "select",
+          "choices": [
+            "콘크리트 개거 150×200",
+            "L형수로 H=0.2"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 붙박이(콘크리트 개거)로 돎"
+        },
+        {
+          "key": "length_m",
+          "label": "연장",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "empty_means": "비우면 표가 안 서고 「연장을 적어야 섬」 사유가 뜸 — 개거는 m당 원단위라 연장이 곧 밑수(2026-09-14 A2)"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_side",
+      "enabled": false,
+      "group": "B",
+      "name": "측구(옆도랑)",
+      "design_owner": "횡단 설계",
+      "placement": "interval",
+      "style": {
+        "color": "#2eaadc",
+        "abbr": "측구"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "일반형(제형)",
+            "L형",
+            "U형",
+            "J형"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "depth_cm",
+          "label": "깊이",
+          "input": "number",
+          "unit": "cm",
+          "default": 30
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_ridge",
+      "enabled": false,
+      "group": "B",
+      "name": "산마루측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2e8bdc",
+        "abbr": "산마루"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "ditch_berm",
+      "enabled": false,
+      "group": "B",
+      "name": "소단측구",
+      "placement": "interval",
+      "style": {
+        "color": "#2ec5dc",
+        "abbr": "소단구"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "사면 쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "chute",
+      "enabled": false,
+      "group": "B",
+      "name": "도수로·산비탈수로",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9bb8",
+        "abbr": "도수로"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌",
+            "콘크리트",
+            "블록판",
+            "벤치플륨관",
+            "반원관"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "section",
+          "label": "단면형",
+          "input": "select",
+          "choices": [
+            "반달꼴",
+            "U자형",
+            "사다리꼴"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "slope_drain",
+      "enabled": false,
+      "group": "B",
+      "name": "절토사면 배수로",
+      "placement": "interval",
+      "style": {
+        "color": "#28b1a1",
+        "abbr": "사면로"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "material",
+          "label": "재료",
+          "input": "select",
+          "choices": [
+            "떼",
+            "돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "underdrain",
+      "enabled": false,
+      "group": "B",
+      "name": "맹암거",
+      "placement": "interval",
+      "style": {
+        "color": "#1f7fb8",
+        "abbr": "맹암거"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "note",
+          "label": "규격",
+          "input": "text",
+          "default": ""
+        }
+      ]
+    },
+    {
+      "type_id": "retaining_wall",
+      "group": "C",
+      "name": "옹벽",
+      "placement": "interval",
+      "style": {
+        "color": "#e07a2e",
+        "abbr": "옹벽"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2,
+          "default_basis": "기본값 · 소광리 도면 H=2.0 · 바꿀 수 있음",
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "중력식",
+            "반중력식",
+            "캔틸레버식",
+            "부벽식",
+            "식생옹벽블럭"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_wet",
+      "group": "C",
+      "name": "돌쌓기(찰)",
+      "placement": "interval",
+      "style": {
+        "color": "#d0692a",
+        "abbr": "찰쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤3.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "masonry_dry",
+      "group": "C",
+      "name": "돌쌓기(메)",
+      "placement": "interval",
+      "style": {
+        "color": "#c25d2c",
+        "abbr": "메쌓기"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)",
+          "warn_above": 2,
+          "warn_message": "메쌓기 높이 기준을 넘음 — 임도기술교본 7-3:27 「메쌓기는 2.0m 이하」 · 품셈 13-4-4 [주]⑪(원문 L7192) 「높이 3m 이상이면 전부 또는 하부를 찰쌓기」 · 막지 않음(설계자 확인)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "soil_guard",
+      "group": "C",
+      "name": "흙막이",
+      "placement": "interval",
+      "style": {
+        "color": "#b8742e",
+        "abbr": "흙막이"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "콘크리트",
+            "돌(찰)",
+            "돌(메)",
+            "블록쌓기",
+            "돌망태",
+            "흙포대",
+            "통나무쌓기",
+            "떼"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 올리지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로 — 옮기지 않음을 뜻함(기슭막이와 같은 벌)"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 돌쌓기 기본값으로 서고 「기본값으로 섰음」이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "default_basis": "「채집」 — 별표2 「야면석 등은 가급적 현장에서 채취·사용」 권고. 구조물마다 바꿀 수 있음",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 흙막이는 「떼」만 서고 치수가 정본 평균 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        }
+      ]
+    },
+    {
+      "type_id": "boulder_masonry",
+      "group": "C",
+      "name": "큰돌쌓기",
+      "placement": "interval",
+      "style": {
+        "color": "#a86a2a",
+        "abbr": "큰돌"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 2.5,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "비워도 놓임 — 줄만 서고 미확정이라 금액에 안 들어감(높이를 적으면 섬 · 2026-09-14 브레인 판정 ①)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_cm",
+          "label": "돌규격",
+          "input": "select",
+          "choices": [
+            "40~60",
+            "60~80",
+            "80~100"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bond",
+          "label": "쌓기 방식",
+          "input": "select",
+          "choices": [
+            "메쌓기",
+            "찰쌓기"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기(13-6)는 채움 콘크리트를 품에 포함 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "default_basis": "「자동(성토 쪽)」 — 칸이 생기기 전의 동작을 이어받는 표식"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」",
+          "not_in_table": "아직 표에 안 쓰임 — 큰돌쌓기는 물빼기 관을 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "berm",
+      "group": "C",
+      "name": "소단",
+      "placement": "interval",
+      "style": {
+        "color": "#7f9a63",
+        "abbr": "소단"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "width_m",
+          "label": "폭",
+          "input": "number",
+          "unit": "m",
+          "default": 0.5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "interval_m",
+          "label": "간격(사면길이)",
+          "input": "number",
+          "unit": "m",
+          "default": 3,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "slope_deg",
+          "label": "안쪽 기울기",
+          "input": "number",
+          "unit": "°",
+          "default": 0,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "erosion_check",
+      "group": "D",
+      "name": "골막이",
+      "placement": "point",
+      "style": {
+        "color": "#7a52c7",
+        "abbr": "골막이"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "돌",
+            "돌망태",
+            "콘크리트",
+            "통나무",
+            "바자",
+            "흙"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "spillway",
+          "label": "방수로",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이 두께는 정본 식(ℓ3+0.1H · ℓ3+0.4H)으로만 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이 ℓ3",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 골막이는 계수 열을 아직 안 가름 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "top_length_m",
+          "label": "상장 ⓐ (윗변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "bottom_length_m",
+          "label": "하장 ⓑ (아랫변)",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 4.5
+        },
+        {
+          "key": "height_m",
+          "label": "높이(≤2.0)",
+          "input": "number",
+          "unit": "m",
+          "default": 2
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        }
+      ]
+    },
+    {
+      "type_id": "bed_sill",
+      "group": "D",
+      "name": "바닥막이",
+      "placement": "point",
+      "style": {
+        "color": "#7c5f3b",
+        "abbr": "바닥"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌붙임(찰)",
+            "돌붙임(메)"
+          ],
+          "default": "돌붙임(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 채집석 공제를 아직 안 셈 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이 원단위는 돌붙임 정본 표 붙박이 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김",
+          "not_in_table": "아직 표에 안 쓰임 — 바닥막이는 평면적(돌붙임 ㎡)이라 기울기 몫이 없음 · 넣어도 수량·금액이 안 바뀜(2026-09-14)"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": 0.3,
+          "required": false,
+          "phase": "b05"
+        }
+      ]
+    },
+    {
+      "type_id": "check_dam_small",
+      "group": "D",
+      "name": "소형사방댐(복합형)",
+      "placement": "point",
+      "style": {
+        "color": "#6b46b8",
+        "abbr": "사방댐"
+      },
+      "drawing_views": [
+        "plan",
+        "profile",
+        "detail",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revetment",
+      "group": "D",
+      "name": "기슭막이",
+      "placement": "point",
+      "managed_by": "pipe_points",
+      "style": {
+        "color": "#9b6bdc",
+        "abbr": "기슭"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "설치 측",
+          "input": "select",
+          "choices": [
+            "양쪽",
+            "좌",
+            "우"
+          ],
+          "default": "양쪽",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「좌」는 셀렉트 첫 항목일 뿐 도메인 확정값이 아님 — 측점마다 사용자가 고름"
+        },
+        {
+          "key": "tiers",
+          "label": "단 수(다단)",
+          "input": "number",
+          "unit": "단",
+          "default": 1,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "1 = 다단 없음 — 도메인 수치가 아니라 「단이 하나」라는 표식"
+        },
+        {
+          "key": "lift_m",
+          "label": "기준 올림(사면 위로)",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "shift_m",
+          "label": "기준 좌우 이동",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "b05",
+          "default_basis": "0 = 자동 자리 그대로"
+        },
+        {
+          "key": "form",
+          "label": "형태",
+          "input": "select",
+          "choices": [
+            "돌쌓기(찰)",
+            "돌쌓기(메)",
+            "콘크리트",
+            "돌망태",
+            "통나무·목재틀",
+            "바자"
+          ],
+          "default": "돌쌓기(메)",
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "thickness_top_m",
+          "label": "상부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 실무 구조물도 식으로 돎(뒷길이 + 0.30) — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "thickness_bottom_m",
+          "label": "하부 두께",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 상부 + 0.30×(H−1) 로 돎 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "back_len_cm",
+          "label": "뒷길이",
+          "input": "select",
+          "choices": [
+            "25",
+            "30",
+            "35",
+            "45",
+            "55",
+            "60",
+            "75"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 13-4-4 [주]⑩ 뒷길이 표준 하한(높이·찰/메로 · 범위 안 가장 작은 규격 — 예 메쌓기 1.5~3m 는 36~45㎝ 라 45㎝)으로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_kind",
+          "label": "돌 종류",
+          "input": "select",
+          "choices": [
+            "야면석·호박돌",
+            "깬잡석",
+            "깬돌",
+            "견치돌"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 야면석 계수 열로 서고 그 사실이 줄로 뜸 — 돌이 아닌 형태도 있어 필수로 못 검"
+        },
+        {
+          "key": "stone_supply",
+          "label": "조달",
+          "input": "select",
+          "choices": [
+            "채집",
+            "구입"
+          ],
+          "default": "채집",
+          "required": false,
+          "phase": "detail"
+        },
+        {
+          "key": "stone_coeff_basis",
+          "label": "야면석 계수",
+          "input": "select",
+          "choices": [
+            "품셈",
+            "실무 관행"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 열로 돎 — 실무 관행 열은 골라야 씀"
+        },
+        {
+          "key": "fill_concrete_mpa",
+          "label": "채움 강도",
+          "input": "select",
+          "choices": [
+            "180",
+            "210"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 계산 쪽 기준 강도로 돎"
+        },
+        {
+          "key": "face_slope_ratio",
+          "label": "전면 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 품셈 표준경사로 자동 판정 — 값을 넣으면 그 값이 이김"
+        },
+        {
+          "key": "face_role",
+          "label": "성토/절토",
+          "input": "select",
+          "choices": [
+            "성토",
+            "절토"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 측점 단면유형 + 설치 측으로 자동 판정(계산이지 기본값이 아님) — 품셈 13-4-4 [주]⑪ 표준경사(원문 L7185~7191)가 성토/절토로 갈림 · 고르면 그 값이 이김"
+        },
+        {
+          "key": "foundation",
+          "label": "기초",
+          "input": "select",
+          "choices": [
+            "기초유",
+            "기초버림"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "height_m",
+          "label": "높이",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "b05",
+          "empty_means": "설계자 입력 — 계획홍수위 + 0.5~0.7m(사방기술교본 2-나:141 · 3-가:181 · 사방(계류) 교본 기준). 비우면 줄만 서고 미확정이라 금액에 안 들어감 · 옛 기본 2.5 는 근거 없어 걷음(2026-09-14 브레인 판정)"
+        },
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5,
+          "required": false,
+          "phase": "b05"
+        },
+        {
+          "key": "weep_hole_diameter_mm",
+          "label": "물빼기 구멍 지름",
+          "input": "number",
+          "unit": "㎜",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 Ø50 으로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "weep_hole_area_m2",
+          "label": "물빼기 구멍 1개당 벽면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 국가기준 2㎡당 1개로 돎 — 사용자 확정 「국가기준 + 숫자 변경 가능하게」"
+        },
+        {
+          "key": "blinding_concrete",
+          "label": "버림 콘크리트",
+          "input": "select",
+          "choices": [
+            "넣음",
+            "안 넣음"
+          ],
+          "default": "넣음",
+          "default_basis": "사용자 확정 ⑭ 「기본은 넣음」 — 두께는 KDS 44 90 00 의 100㎜",
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비워도 넣음 — 「안 넣음」을 골라야 그 줄이 빠짐(B08 `wants_blinding`)"
+        }
+      ]
+    },
+    {
+      "type_id": "refuge",
+      "group": "E",
+      "name": "대피소",
+      "placement": "interval",
+      "style": {
+        "color": "#2fa84f",
+        "abbr": "대피소"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 15
+        }
+      ]
+    },
+    {
+      "type_id": "work_yard",
+      "group": "E",
+      "name": "정차·작업장",
+      "placement": "interval",
+      "style": {
+        "color": "#268f43",
+        "abbr": "작업장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 7
+        },
+        {
+          "key": "length_m",
+          "label": "유효길이",
+          "input": "number",
+          "unit": "m",
+          "default": 20
+        }
+      ]
+    },
+    {
+      "type_id": "turnaround",
+      "group": "E",
+      "name": "차돌림곳",
+      "placement": "site",
+      "style": {
+        "color": "#37b95a",
+        "abbr": "차돌림"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "width_m",
+          "label": "너비",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        }
+      ]
+    },
+    {
+      "type_id": "mirror",
+      "group": "E",
+      "name": "반사경",
+      "placement": "point",
+      "style": {
+        "color": "#43c76b",
+        "abbr": "반사경"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": [
+        {
+          "key": "facing",
+          "label": "방향",
+          "input": "select",
+          "choices": [
+            "좌",
+            "우",
+            "양면"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "guardrail",
+      "group": "E",
+      "name": "가드레일·경계석·위험표지",
+      "placement": "interval",
+      "style": {
+        "color": "#1f9e46",
+        "abbr": "가드"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "kind",
+          "label": "종류",
+          "input": "select",
+          "choices": [
+            "가드레일",
+            "경계석",
+            "위험표지"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "position_sign",
+      "group": "E",
+      "name": "국가지점번호판",
+      "placement": "point",
+      "style": {
+        "color": "#53a832",
+        "abbr": "번호판"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "barrier_gate",
+      "group": "E",
+      "name": "차단기",
+      "placement": "point",
+      "style": {
+        "color": "#3f9e2e",
+        "abbr": "차단기"
+      },
+      "drawing_views": [
+        "plan",
+        "detail"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "completion_sign",
+      "group": "E",
+      "name": "준공표지판",
+      "placement": "point",
+      "style": {
+        "color": "#66b344",
+        "abbr": "준공"
+      },
+      "drawing_views": [
+        "plan"
+      ],
+      "options": []
+    },
+    {
+      "type_id": "spoil_bank",
+      "group": "E",
+      "name": "유용토운반작업장(구 사토장)",
+      "placement": "interval",
+      "style": {
+        "color": "#8c9a2e",
+        "abbr": "사토장"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "side",
+          "label": "쌓는 쪽",
+          "input": "select",
+          "choices": [
+            "자동(성토 쪽)",
+            "좌",
+            "우"
+          ],
+          "default": "자동(성토 쪽)",
+          "required": false,
+          "phase": "b05",
+          "default_basis": "「자동(성토 쪽)」 — 흙은 성토 쪽에 쌓는다는 지금까지의 동작을 이어받는 표식. 측점마다 좌·우로 바꿈"
+        },
+        {
+          "key": "fill_slope_ratio",
+          "label": "비탈 기울기 (1:n 의 n)",
+          "input": "number",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 그 측점의 노선 성토 기울기를 그대로 씀 — 지식DB 가 「기본 비탈기울기는 근거에 없다」고 못 박은 자리"
+        },
+        {
+          "key": "extra_distance_m",
+          "label": "추가 운반거리",
+          "input": "number",
+          "unit": "m",
+          "default": 0,
+          "required": false,
+          "phase": "detail",
+          "default_basis": "0 = 「추가 없음」 — 노선 안 사토장은 측점 누가거리로 거리가 나오므로 이 칸은 외부 사토장 대비 여벌"
+        },
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "borrow_pit",
+      "group": "E",
+      "name": "토사채취장(토취장)",
+      "placement": "site",
+      "style": {
+        "color": "#7d8a2a",
+        "abbr": "토취장"
+      },
+      "drawing_views": [
+        "plan",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "area_m2",
+          "label": "면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "capacity_m3",
+          "label": "용량",
+          "input": "number",
+          "unit": "㎥",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "wildlife_path",
+      "enabled": false,
+      "group": "F",
+      "name": "야생동물 이동통로",
+      "placement": "point",
+      "style": {
+        "color": "#3aa88f",
+        "abbr": "동물길"
+      },
+      "drawing_views": [
+        "plan",
+        "cross_section"
+      ],
+      "options": [
+        {
+          "key": "form",
+          "label": "형식",
+          "input": "select",
+          "choices": [
+            "경사로",
+            "자연형계단"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "revegetation",
+      "enabled": false,
+      "group": "F",
+      "name": "비탈면 녹화",
+      "placement": "interval",
+      "style": {
+        "color": "#4cb84c",
+        "abbr": "녹화"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "method",
+          "label": "공법",
+          "input": "select",
+          "choices": [
+            "씨뿌리기(줄파종)",
+            "새심기",
+            "선떼붙이기",
+            "줄떼",
+            "평떼",
+            "비탈덮기",
+            "녹생토 뿜어붙이기",
+            "조공",
+            "편책",
+            "나무심기"
+          ],
+          "default": null,
+          "default_basis": "「초류종자 살포」는 여기 없음 — 토공집계에서 사면 전체로 섬(품셈 5-24 · 두 곳에 두면 이중계상 · 2026-09-15 브레인)",
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "face",
+          "label": "대상 면",
+          "input": "select",
+          "choices": [
+            "절토면",
+            "성토면",
+            "양쪽"
+          ],
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        },
+        {
+          "key": "cover_kind",
+          "label": "덮개(비탈덮기)",
+          "input": "select",
+          "choices": [
+            "거적",
+            "짚망",
+            "방초·야자섬유매트"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비탈덮기일 때만 고름 — 비면 비탈덮기 줄이 안 섬(품셈 5-25 거적덮기 ㎡ · 5-28-1 짚망 · 5-28-2 매트 · 재료가 공종을 가름)"
+        },
+        {
+          "key": "step_height_m",
+          "label": "단 직고",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기·조공의 단 사이 직고 — 교본은 범위로만 줌(선떼 직고 1~2m · 조공 1.0~1.2m) · 기본값 없음 · 비면 선떼 연장(품셈 5-16-1 [주]② 대상지 직고 ÷ 단 직고 × 연장)이 안 섬"
+        },
+        {
+          "key": "sod_grade",
+          "label": "선떼 급수",
+          "input": "select",
+          "choices": [
+            "1급",
+            "2급",
+            "3급",
+            "4급",
+            "5급",
+            "6급",
+            "7급",
+            "8급",
+            "9급"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "선떼붙이기의 급수 — 교본은 1~9급 범위만(6~7급을 많이 씀) · 기본값 없음 · 비면 m당 떼 매수(사방기술교본 표 2-2-6)가 안 섬"
+        },
+        {
+          "key": "sod_size",
+          "label": "선떼 떼 크기",
+          "input": "select",
+          "choices": [
+            "대형 40×40",
+            "소형 18×18"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "사방기술교본 표 2-2-6 이 대형(40×40)·소형(18×18) 두 줄을 나란히 줌 — 우리가 고를 자리가 아니라 기본값 없음 · 비면 선떼 떼 매수가 안 섬"
+        },
+        {
+          "key": "cutting_soil",
+          "label": "단끊기 토질",
+          "input": "select",
+          "choices": [
+            "보통토사",
+            "경질ㆍ고사점토 및 자갈섞인 점토",
+            "호박돌 섞인 토사"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "품셈 5-16-1 단끊기 표의 토질 셋 — B06 지반(토사/암)과 다른 축이라 자동으로 안 고름 · 비면 단끊기 조각만 막힘"
+        }
+      ]
+    },
+    {
+      "type_id": "pavement_concrete",
+      "group": "G",
+      "name": "콘크리트 포장",
+      "placement": "interval",
+      "style": {
+        "color": "#8a8f98",
+        "abbr": "포장"
+      },
+      "drawing_views": [
+        "profile",
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "length_m",
+          "label": "길이",
+          "input": "number",
+          "unit": "m",
+          "default": 10
+        },
+        {
+          "key": "before_m",
+          "label": "기준측점 전",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "after_m",
+          "label": "기준측점 후",
+          "input": "number",
+          "unit": "m",
+          "default": 5
+        },
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 포장층 두께(표준 횡단면 설정 · 기본 0.2m = 임도기술교본 3-2 「두께 0.2m」)를 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "width_m",
+          "label": "포장 폭",
+          "input": "number",
+          "unit": "m",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 노폭(구간 측점의 차도 표준 폭 · 교본 3-2 「포장 폭 3.0m」 · 실무 관측 3.5~4.0)을 이음 — 적으면 적은 값이 이김"
+        },
+        {
+          "key": "widening_area_m2",
+          "label": "확폭 면적",
+          "input": "number",
+          "unit": "㎡",
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 B06 곡선부 확폭을 측점 사이 평균 × 거리로 더함(교본 3-2 「곡선부에는 확폭」) — 확폭이 없으면 0 을 적을 것"
+        },
+        {
+          "key": "joint_spacing_m",
+          "label": "수축줄눈 간격",
+          "input": "number",
+          "unit": "m",
+          "default": 6,
+          "default_basis": "제안값 · 임도기술교본 부록 4-7 7-1 3.5.1 「수축줄눈의 간격은 4-6m를 기준」 · 실무 소광 6m 관측 · 바꿀 수 있음",
+          "phase": "detail"
+        },
+        {
+          "key": "separation_sheet",
+          "label": "비닐(깔기·양생)",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 비닐 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「양생 재료비(비닐 등)는 별도 계상」이라 설계자가 고름(기본값 없음)"
+        },
+        {
+          "key": "wire_mesh",
+          "label": "철망",
+          "input": "select",
+          "choices": [
+            "있음",
+            "없음"
+          ],
+          "default": null,
+          "required": false,
+          "phase": "detail",
+          "empty_means": "비우면 철망 재료가 안 서고 사유가 뜸 — 품셈 12-6 [주]② 「철망재료비는 별도 계상」 · 교본 부록 7-1 3.4 「설계도서에 따라」 · 실무 소광 「철망포함」 관측"
+        }
+      ]
+    },
+    {
+      "type_id": "gravel_surfacing",
+      "enabled": false,
+      "group": "G",
+      "name": "쇄석(자갈) 포설",
+      "placement": "interval",
+      "style": {
+        "color": "#9aa0a8",
+        "abbr": "쇄석"
+      },
+      "drawing_views": [
+        "cross_section",
+        "quantity"
+      ],
+      "options": [
+        {
+          "key": "thickness_cm",
+          "label": "두께",
+          "input": "number",
+          "unit": "cm",
+          "default": null,
+          "required": true,
+          "phase": "detail"
+        }
+      ]
+    },
+    {
+      "type_id": "etc",
+      "group": "호환",
+      "name": "기타",
+      "placement": "point",
+      "style": {
+        "color": "#98a2b3",
+        "abbr": "기타"
+      },
+      "drawing_views": [
+        "profile"
+      ],
+      "options": [
+        {
+          "key": "name",
+          "label": "이름",
+          "input": "text",
+          "default": "기타 구조물"
+        }
+      ]
+    }
+  ],
+  "종류": {
+    "pipe": {
+      "동작": [
+        "계곡통과시설",
+        "유입유출_묶음",
+        "기슭막이_한벌"
+      ]
+    },
+    "box_culvert": {
+      "동작": [
+        "계곡통과시설",
+        "BOX_본체규격",
+        "날개벽"
+      ]
+    },
+    "ford_pavement": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면"
+      ]
+    },
+    "ford_bridge": {
+      "동작": [
+        "계곡통과시설",
+        "월류단면",
+        "날개벽"
+      ]
+    },
+    "revetment": {
+      "동작": [
+        "계곡통과시설",
+        "기슭막이_한벌"
+      ]
+    },
+    "pavement_concrete": {
+      "동작": [
+        "포장_물넘이_겹침"
+      ]
+    }
+  },
+  "표시": {
+    "pipe": {
+      "pipe_kind": false
+    }
+  },
+  "그룹": {
+    "pipe": [
+      {
+        "id": "grv6lny",
+        "이름": "관",
+        "옵션": [
+          "pipe_kind",
+          "pipe_diameter_mm"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "gnbf9m9",
+        "이름": "관 보호공(유입)",
+        "옵션": [
+          "inlet_type"
+        ],
+        "형상": {}
+      },
+      {
+        "id": "g9lq9uk",
+        "이름": "관 보호공(유출)",
+        "옵션": [],
+        "형상": {}
+      }
+    ]
+  },
+  "배치": {},
+  "규칙": []
+}
diff --git a/resources/master_template/구조물집계표조합.json b/resources/master_template/구조물집계표조합.json
index 119f6b4be..2afe0f7a5 100644
--- a/resources/master_template/구조물집계표조합.json
+++ b/resources/master_template/구조물집계표조합.json
@@ -75,10 +75,9 @@
       "분류3": "aaa",
       "단위": "m",
       "일위대가": "UA000008",
-      "자재조합": null,
       "도번": "SD-000001",
+      "일위대가번": "SU-000001",
       "면적번": "SA-000001",
-      "재료번": "SM-000001",
       "바인딩": null,
       "펼침": null
     },
@@ -100,10 +99,9 @@
       "분류3": "aaa",
       "단위": "b",
       "일위대가": null,
-      "자재조합": null,
       "도번": "SD-000002",
+      "일위대가번": "SU-000002",
       "면적번": "SA-000002",
-      "재료번": "SM-000002",
       "바인딩": null,
       "펼침": null
     },
@@ -112,19 +110,18 @@
       "열": "item3",
       "경로": [
         "기슭막이",
-        "ㄴㄴ"
+        "ㄷ2ㄷ"
       ],
-      "이름": "기슭막이 ㄴㄴ",
+      "이름": "기슭막이 ㄷ2ㄷ",
       "종류": "기슭막이",
-      "분류1": "ㄴㄴ",
+      "분류1": "ㄷ2ㄷ",
       "분류2": null,
       "분류3": null,
       "단위": null,
       "일위대가": "UA000001",
-      "자재조합": null,
       "도번": "SD-000003",
+      "일위대가번": "SU-000003",
       "면적번": "SA-000003",
-      "재료번": "SM-000003",
       "바인딩": null,
       "펼침": null
     }
diff --git a/resources/tester/helper_52_structure_spec.cjs b/resources/tester/helper_52_structure_spec.cjs
new file mode 100644
index 000000000..0ff82723b
--- /dev/null
+++ b/resources/tester/helper_52_structure_spec.cjs
@@ -0,0 +1,87 @@
+/* 구조물 명세 공용 틀 · 배관 명세 단위검증 헬퍼(PLAN 52-1) — `design_structure_spec.ts` ·
+ * `design_structure_pipe.ts` 를 그 자리에서 트랜스파일해 Node 로 돌림(꼴만 import). 결과 = JSON 한 벌.
+ * 인자 `names` 면 배관 이름 표(정의 `종류.pipe.이름`)만 냄.
+ */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+const load = (file, deps = {}) => {
+  const src = fs.readFileSync(path.join(ROOT, "A00_Common", "design", file), "utf8");
+  const js = ts.transpileModule(src, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  new Function("exports", "module", "require", js)(box.exports, box, (m) => deps[m] ?? require(m));
+  return box.exports;
+};
+const s = load("design_structure_spec.ts");
+const { PIPE_SPEC } = load("design_structure_pipe.ts");
+
+if (process.argv[2] === "names") {
+  process.stdout.write(JSON.stringify(s.nameTable(PIPE_SPEC)));
+  process.exit(0);
+}
+
+const old = {
+  pipe_kind: "흄관",
+  wing_wall_type: "A-TYPE",
+  pipe_diameter_mm: 1000,
+  inlet_type: "집수정",
+  inlet_structure: "L",
+  inlet_basin_length_m: 2,
+  inlet_basin_before_m: 1,
+  inlet_basin_after_m: 1,
+  outlet_type: "기슭막이",
+  outlet_revet_form: "돌쌓기(메)",
+  outlet_revet_length_m: 10,
+  outlet_revet_height_m: 2.5,
+  soil_add_2_structure: "기슭막이",
+  soil_add_2_form: "바자",
+  soil_add_5_length_m: 4,
+  chute_add_1_structure: "도수로",
+};
+const state = s.readState(PIPE_SPEC, old);
+const back = s.writeOptions(PIPE_SPEC, state);
+// 흙막이로 바꿈 → 갈래 키가 기슭막이 쪽 · also(inlet_structure revet)
+const soil = JSON.parse(JSON.stringify(state));
+soil.inlet[0].structure = "기슭막이";
+soil.inlet[0].form = "콘크리트";
+soil.inlet[0].length = "6";
+const soilOut = s.writeOptions(PIPE_SPEC, soil);
+const inlet = PIPE_SPEC.containers.find((c) => c.id === "inlet");
+const form = inlet.items.find((i) => i.id === "form");
+const keys = s.specKeys(PIPE_SPEC);
+
+const out = {
+  containers: PIPE_SPEC.containers.map((c) => [c.id, c.title, c.required]),
+  state,
+  back,
+  soilOut,
+  formBasin: s.choicesOf(form, { structure: "집수정" }).map((c) => c.label),
+  formSoil: s.choicesOf(form, { structure: "기슭막이" }).map((c) => c.label),
+  formNone: s.branchOf(form, {}),
+  outletForms: s
+    .choicesOf(
+      PIPE_SPEC.containers.find((c) => c.id === "outlet").items.find((i) => i.id === "form"),
+      { structure: "기슭막이" },
+    )
+    .map((c) => c.label),
+  keys,
+  links: PIPE_SPEC.containers.map((c) => s.linkOf(c, 2)),
+  split: {
+    lengthFromSides: s.solveSplit({ length: "10", before: "3", after: "4" }, ["after", "before"]),
+    beforeFromLength: s.solveSplit({ length: "10", before: "3", after: "4" }, ["after", "length"]),
+    defaultKeepsLength: s.solveSplit({ length: "10", before: "3", after: "" }, ["before"]),
+    blankKept: s.solveSplit({ length: "", before: "3", after: "4" }, ["before", "length"]),
+    clamp: s.solveSplit({ length: "2", before: "", after: "5" }, ["after", "length"]),
+  },
+  names: {
+    renamed: s.itemLabel(inlet, form, { "inlet.form": "모양" }),
+    title: s.containerTitle(inlet, {}, "그룹 이름"),
+    titleOwn: s.containerTitle(inlet, { inlet: "유입 보호" }, "그룹 이름"),
+    choice: s.choiceLabel(inlet, form, { value: "U", label: "ㄷ형" }, {}),
+  },
+};
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_b05_structures_define.cjs b/resources/tester/helper_b05_structures_define.cjs
new file mode 100644
index 000000000..c4249162b
--- /dev/null
+++ b/resources/tester/helper_b05_structures_define.cjs
@@ -0,0 +1,99 @@
+/* 구조물 정의 → 칸 모양 단위검증 헬퍼(PLAN 48-3 · 48-4) — `B05_Profile_UI_Structures_Define.ts` 를
+ * 그 자리에서 트랜스파일해 Node 로 돌림(import 없는 파일). 결과는 표준출력에 JSON 한 벌.
+ * 판 1 정의(`resources/master_template/구조물정의.json`)도 읽어 지금 화면과 같은지(차례 · 2열) 봄.
+ */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+const src = fs.readFileSync(
+  path.join(ROOT, "B05_Profile", "B05_Profile_UI_Structures_Define.ts"),
+  "utf8",
+);
+const js = ts.transpileModule(src, {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+}).outputText;
+const box = { exports: {} };
+new Function("exports", "module", "require", js)(box.exports, box, require);
+const d = box.exports;
+
+const opt = (key, extra = {}) => ({
+  key,
+  label: key,
+  input: "select",
+  choices: ["a", "b", "c"],
+  default: null,
+  ...extra,
+});
+const type = {
+  options: [
+    opt("p"),
+    opt("q"),
+    opt("r", { enabled: false }),
+    opt("s", { visible: false }),
+    opt("t"),
+  ],
+  spots: { t: { 줄: 1, 칸: 1, 너비: 2 }, p: { 줄: 2, 칸: 2 } },
+  rules: [
+    {
+      종류: "x",
+      만약: { 옵션: "p", 값들: ["a"] },
+      그러면: { 옵션: "q", 선택지: ["b", "c"], 기본값: "c" },
+    },
+    { 종류: "x", 만약: { 옵션: "p", 값들: ["b"] }, 그러면: { 옵션: "q", 보이기: false } },
+    { 종류: "x", 만약: { 옵션: "q", 값들: ["c"] }, 그러면: { 옵션: "t", 보이기: false } },
+  ],
+};
+const plain = (states) => Object.fromEntries([...states].map(([k, v]) => [k, v]));
+
+const def = JSON.parse(
+  fs.readFileSync(path.join(ROOT, "resources", "master_template", "구조물정의.json"), "utf8"),
+);
+const merged = d.withDefinition(
+  def.types.map((t) => ({ ...t, groups: (def.그룹[t.type_id] ?? []).map((g) => ({ id: g.id })) })),
+  def,
+);
+const v1 = merged.map((t) => ({
+  id: t.type_id,
+  same:
+    JSON.stringify(d.orderedOptions(t).map((o) => o.key)) ===
+    JSON.stringify(t.options.filter((o) => o.enabled !== false).map((o) => o.key)),
+  columns: d.columnsOf(t),
+  anchor: d.showsAnchor(t),
+}));
+
+const out = {
+  order: d.orderedOptions(type).map((o) => o.key),
+  columns: d.columnsOf(type),
+  columnsNone: d.columnsOf({}),
+  placeT: d.gridPlace(type.spots.t, 2),
+  placeNone: d.gridPlace(undefined, 2),
+  stateA: plain(d.ruleStates(type, { p: "a", q: "c" })),
+  stateB: plain(d.ruleStates(type, { p: "b", q: "c" })),
+  defaultsA: d.ruleDefaults(type, "p", { p: "a" }),
+  defaultsB: d.ruleDefaults(type, "p", { p: "b" }),
+  stale: d.staleValues({ p: "a", old_key: 3, g1__length_m: 2 }, ["p", "g1__length_m"]),
+  shapes: d.shapeFields({
+    길이: { 받기: true, 뜻: "연장" },
+    높이: { 받기: false },
+    후: { 받기: true },
+  }),
+  shapeKey: d.shapeKey("g1", "length_m"),
+  withNull: d.withDefinition([{ type_id: "a", group: "A" }], null),
+  withDef: d.withDefinition([{ type_id: "a", group: "A", groups: [{ id: "g1" }] }], {
+    구조물군: { A: "가 군" },
+    종류: { a: { 기준측점: false, 동작: ["계곡통과시설"] } },
+    그룹: { a: [{ id: "g1", 형상: { 길이: { 받기: true } } }] },
+    배치: { a: { k: { 줄: 1, 칸: 1 } } },
+    규칙: [
+      { ...type.rules[0], 종류: "a" },
+      { ...type.rules[1], 종류: "b" },
+    ],
+  }),
+  v1Types: v1.length,
+  v1Same: v1.every((t) => t.same),
+  v1Columns: [...new Set(v1.map((t) => t.columns))],
+  v1Anchor: v1.every((t) => t.anchor),
+};
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_b05_structures_form_summary.cjs b/resources/tester/helper_b05_structures_form_summary.cjs
index f5e9f6ebb..0a548359e 100644
--- a/resources/tester/helper_b05_structures_form_summary.cjs
+++ b/resources/tester/helper_b05_structures_form_summary.cjs
@@ -355,8 +355,14 @@ async function saveWith({
     setTempPipeChainage() {},
     summary: () => summaryValue,
     setSummary: (value) => (summaryValue = value),
-    groupItems: () => ({}), // 옵션 그룹(PLAN 46-3) — 이 시험은 그룹 없음
-    setGroupItems() {},
+    // 옵션 그룹(PLAN 46-3) · 형상 칸(48-3) — 이 시험은 그룹 없음
+    groupBoxes: {
+      get: () => ({}),
+      set() {},
+      shapes: () => ({}),
+      shapeKeys: () => [],
+      setShapes() {},
+    },
   };
   if (summaryOnly) {
     const done = commitModule.commitSummaryOnly(ctx);
diff --git a/resources/tester/helper_m02_so_def_model.cjs b/resources/tester/helper_m02_so_def_model.cjs
new file mode 100644
index 000000000..92969f79c
--- /dev/null
+++ b/resources/tester/helper_m02_so_def_model.cjs
@@ -0,0 +1,112 @@
+/* M02 구조물 정의 편집 화면 자료 손질(`M02_SO_Def_Model.ts` · PLAN 48-2) 단위검증 헬퍼 —
+ * TS 를 그 자리에서 트랜스파일해 Node 로 돌리고 결과를 JSON 으로 냄(pytest 가 판정). */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const source = fs.readFileSync(
+  path.join(__dirname, "..", "..", "M02_MasterTemplete", "StructOptions", "M02_SO_Def_Model.ts"),
+  "utf8",
+);
+const js = ts.transpileModule(source, {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+}).outputText;
+const box = { exports: {} };
+new Function("exports", "module", "require", js)(box.exports, box, require);
+const m = box.exports;
+
+const sel = (key, choices) => ({ key, label: key, input: "select", choices: [...choices] });
+const type = () => ({
+  type_id: "k1",
+  group: "A",
+  name: "배수관",
+  options: [sel("a", ["x", "y"]), sel("b", ["p", "q"]), { key: "c", label: "c", input: "number" }],
+});
+const defOf = (over = {}) => ({
+  판: 3,
+  구조물군: { A: "A군", B: "B군" },
+  동작: {},
+  types: [
+    type(),
+    { ...type(), type_id: "k2", name: "둘째" },
+    { ...type(), type_id: "k3", group: "B", name: "셋째" },
+  ],
+  종류: {},
+  표시: {},
+  그룹: {},
+  배치: {},
+  규칙: [],
+  ...over,
+});
+const cells = (t, spots) => Object.fromEntries(m.placeAll(t.options, spots));
+
+const out = {};
+// 자리 안 정한 옵션 = 차례대로 채움 · 두 칸이면 셋째는 둘째 줄
+out.auto = cells(type());
+// 정한 자리 먼저 · 남은 것은 빈 칸으로 · 너비는 칸 수를 안 넘음
+out.fixed = cells(type(), { c: { 줄: 1, 칸: 1, 너비: 5 } });
+// 안 씀은 격자에서 빠짐
+const off = type();
+off.options[0].enabled = false;
+out.off = cells(off);
+// 겹침
+out.overlap = m
+  .overlaps(
+    m.placeAll(type().options, { a: { 줄: 1, 칸: 1, 너비: 2 }, b: { 줄: 1, 칸: 2, 너비: 1 } }),
+  )
+  .sort();
+// 규칙 — 맞는 줄 · 없는 값 · 자기 자신 · 없는 하위 선택지 · 그러면 비었음 · 고르기 아닌 상위
+const rd = defOf();
+const R = (만약, 그러면) => ({ 종류: "k1", 만약, 그러면 });
+out.rules = [
+  R({ 옵션: "a", 값들: ["x"] }, { 옵션: "b", 선택지: ["p"], 기본값: "p" }),
+  R({ 옵션: "a", 값들: ["zz"] }, { 옵션: "b", 보이기: false }),
+  R({ 옵션: "a", 값들: ["x"] }, { 옵션: "a", 보이기: false }),
+  R({ 옵션: "a", 값들: ["y"] }, { 옵션: "b", 선택지: ["nope"] }),
+  R({ 옵션: "a", 값들: ["x"] }, { 옵션: "b" }),
+  R({ 옵션: "c", 값들: ["3"] }, { 옵션: "b", 보이기: false }),
+  R({ 옵션: "a", 값들: ["x"] }, { 옵션: "b", 선택지: ["p"], 기본값: "q" }),
+].map((r) => m.ruleBad(rd, r));
+// 이름 — 빈 이름 · 겹침
+out.names = m.badNames(["가", " ", "가"]);
+// 저장 전 검사 — 깨끗한 정의는 빈 목록 · 겹침 · 이름 틀림 · 빈 선택지는 까닭
+out.clean = m.problems(defOf());
+const broken = defOf({
+  배치: { k1: { a: { 줄: 1, 칸: 1, 너비: 2 }, b: { 줄: 1, 칸: 2, 너비: 1 } } },
+});
+broken.types[0].options[1].label = "a";
+broken.types[1].options[0].choices = [];
+out.broken = m.problems(broken);
+// 선택지 이름 바꿈 · 뺌 — 기본값 · 규칙 같이
+const rn = defOf({
+  규칙: [R({ 옵션: "a", 값들: ["x", "y"] }, { 옵션: "b", 선택지: ["p"], 기본값: "p" })],
+});
+const a = rn.types[0].options[0];
+const b = rn.types[0].options[1];
+a.default = "x";
+m.renameChoice(rn, "k1", a, "x", "엑스");
+m.renameChoice(rn, "k1", b, "p", "피");
+out.rename = [
+  a.choices,
+  a.default,
+  rn.규칙[0].만약.값들,
+  rn.규칙[0].그러면.선택지,
+  rn.규칙[0].그러면.기본값,
+];
+m.dropChoice(rn, "k1", b, "피");
+out.drop = [b.choices, rn.규칙[0].그러면.선택지, "기본값" in rn.규칙[0].그러면];
+// 순서 — 구조물군 키 차례 · 종류는 같은 군 안에서만
+const od = defOf();
+out.family = [m.stepFamily(od, "A", -1), m.stepFamily(od, "A", 1), Object.keys(od.구조물군)];
+out.type = [m.stepType(od, "k2", 1), m.stepType(od, "k1", 1), od.types.map((t) => t.type_id)];
+out.base = [
+  m.baseShown(defOf(), "k1"),
+  m.baseShown(defOf({ 종류: { k1: { 기준측점: false } } }), "k1"),
+];
+// 목록 순서 바꿈 · 끝은 그대로
+const list = [1, 2, 3];
+out.step = [m.step(list, 0, -1), m.step(list, 0, 1), list];
+// 새 키 — 머리글 · 안 겹침 · 영문 소문자 숫자
+const k = m.newKey("opt_", ["opt_aaaaaa"]);
+out.newKey = [/^opt_[0-9a-z]{4,}$/.test(k), k !== "opt_aaaaaa"];
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/spreadsheet/harness_links.ts b/resources/tester/spreadsheet/harness_links.ts
index ea6b0ff85..6572337da 100644
--- a/resources/tester/spreadsheet/harness_links.ts
+++ b/resources/tester/spreadsheet/harness_links.ts
@@ -6,7 +6,10 @@ import { createSpreadsheet } from "../../../A00_Common/spreadsheet/spreadsheet";
 import type { LinkMaterial, Workbook } from "../../../A00_Common/spreadsheet/spreadsheet";
 
 const w = window as unknown as Record<string, unknown>;
-const mode = new URLSearchParams(location.search).get("mode") === "자재" ? "자재" : "입력";
+const q = new URLSearchParams(location.search);
+const mode = q.get("mode") === "자재" ? "자재" : "입력";
+// ?ghost=1 — 목록 확정 + 목록에 없는 연결 알약 X(B1) · 목록 알약 L(B2) / ?range=1 — 도면 보낸 범위 A1:B2
+const ghost = q.get("ghost") === "1";
 
 const book: Workbook = {
   종류: "통합문서",
@@ -29,6 +32,11 @@ const book: Workbook = {
   ],
   활성: "s1",
 };
+if (ghost)
+  book.시트[0].연결 = [
+    { 키: "X", 칸: "B1", 이름: "지운로직", 단위: "m" },
+    { 키: "L", 칸: "B2", 이름: "길이", 단위: "m" },
+  ];
 
 const MATERIALS: LinkMaterial[] = [
   { 코드: "M001", 이름: "레미콘", 규격: "25-21-12", 단위: "m³" },
@@ -59,6 +67,14 @@ w.ss = createSpreadsheet(document.getElementById("host")!, book, {
             { 키: "H", 이름: "높이", 단위: "m" },
             { 키: "A", 이름: "면적", 단위: "m²" },
           ],
+    ...(ghost ? { 확정: true } : {}),
+    ...(q.get("range") === "1"
+      ? {
+          표시범위: [
+            { 시트: "s1", 범위: "A1:B2", 이름: "T1 도면", 설명: "도면 표 T1 로 보낸 범위" },
+          ],
+        }
+      : {}),
     onItemsChange: (목록) => (w.ssItems as unknown[]).push(목록),
     자재찾기: async (글) => {
       asked.push(글);
diff --git a/resources/tester/test_52_structure_spec_pipe.py b/resources/tester/test_52_structure_spec_pipe.py
new file mode 100644
index 000000000..3f9abdf5c
--- /dev/null
+++ b/resources/tester/test_52_structure_spec_pipe.py
@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+"""구조물 명세 공용 틀 + 횡단배수 › 배관(표 01) — PLAN 52-1.
+
+순수 규칙은 Node 헬퍼(`helper_52_structure_spec.cjs`)가 돌림 · 화면은 ORCA `ui_checks/52-1_배관_컨테이너.js`.
+"""
+
+import json
+import os
+import subprocess
+
+import pytest
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(os.path.dirname(HERE))
+
+
+def _node(*args):
+    proc = subprocess.run(
+        ["node", os.path.join(HERE, "helper_52_structure_spec.cjs"), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+@pytest.fixture(scope="module")
+def out():
+    return _node()
+
+
+def test_컨테이너_다섯_필수_셋_선택_둘(out):
+    assert out["containers"] == [
+        ["pipe", "관", True],
+        ["inlet", "관 보호공 (유입)", True],
+        ["outlet", "관 보호공 (유출)", True],
+        ["soil_add", "흙막이 추가", False],
+        ["chute_add", "도수로/돌붙임", False],
+    ]
+
+
+def test_형태_선택지는_구조를_따름(out):
+    assert out["formBasin"] == ["I형", "L형", "ㄷ형"]
+    assert out["formSoil"] == [
+        "돌 쌓기(찰)",
+        "돌 쌓기(메)",
+        "콘크리트",
+        "돌망태",
+        "통나무/목재틀",
+        "바자",
+    ]
+    assert out["formNone"] is None  # 구조 안 고름 = 형태 칸 가림
+    assert out["outletForms"] == out["formSoil"]
+
+
+def test_옛_키로_읽고_같은_키로_씀_옛_칸은_안_씀(out):
+    back = out["back"]
+    assert back["pipe_diameter_mm"] == 1000
+    assert back["inlet_structure"] == "L" and back["inlet_basin_length_m"] == 2
+    assert back["outlet_revet_height_m"] == 2.5
+    # 표 01 에 없는 옛 칸은 폼이 안 적음(병합이 이어 붙임 = 지난 정의 값)
+    assert "pipe_kind" not in back and "wing_wall_type" not in back
+
+
+def test_선택_컨테이너는_인스턴스마다_차례대로_다시_매김(out):
+    assert [i["structure"] for i in out["state"]["soil_add"]] == ["기슭막이", ""]
+    assert out["back"]["soil_add_1_form"] == "바자"
+    assert "soil_add_2_form" not in out["back"]
+    assert out["back"]["chute_add_1_structure"] == "도수로"
+
+
+def test_흙막이로_바꾸면_기슭막이_키와_revet(out):
+    s = out["soilOut"]
+    assert s["inlet_type"] == "기슭막이" and s["inlet_structure"] == "revet"
+    assert s["inlet_revet_form"] == "콘크리트" and s["inlet_revet_length_m"] == 6
+    assert "inlet_basin_length_m" not in s
+
+
+def test_길이_전_후_맞물림_마지막에_고친_둘을_지킴(out):
+    sp = out["split"]
+    assert sp["lengthFromSides"]["length"] == "7"
+    assert sp["beforeFromLength"]["before"] == "6"
+    assert sp["defaultKeepsLength"]["after"] == "7"
+    assert sp["blankKept"]["length"] == ""  # 지킬 칸이 비면 안 셈
+    assert sp["clamp"]["before"] == "0"
+
+
+def test_잇기_키와_이름_바꿈(out):
+    assert out["links"] == ["grv6lny", "gnbf9m9", "g9lq9uk", "gsoiladd2", "gchuteadd2"]
+    assert out["names"] == {
+        "renamed": "모양",
+        "title": "그룹 이름",
+        "titleOwn": "유입 보호",
+        "choice": "ㄷ형",
+    }
+    assert {"soil_add_", "chute_add_"} == set(out["keys"]["prefixes"])
+
+
+def test_정의_파일에_이름_표가_올라_있음():
+    names = _node("names")
+    with open(
+        os.path.join(ROOT, "resources", "master_template", "구조물정의.json"), encoding="utf-8"
+    ) as f:
+        doc = json.load(f)
+    on_file = doc["종류"]["pipe"]["이름"]
+    assert set(names) == set(on_file)
+    assert on_file["inlet.structure=기슭막이"] == "흙막이"
diff --git a/resources/tester/test_b05_facility_options_merge.py b/resources/tester/test_b05_facility_options_merge.py
index 6b8880720..3370decec 100644
--- a/resources/tester/test_b05_facility_options_merge.py
+++ b/resources/tester/test_b05_facility_options_merge.py
@@ -96,7 +96,8 @@ def test_폼이_모르는_칸은_남고_폼이_아는_칸은_폼대로(merged) -
     assert options["revet_foundation"] == "기초유"  # 집계표 값이 살아남음
     assert "inlet_basin_before_m" not in options  # 폼 칸(24-4a) — 집수정을 걷으면 함께 지움
     assert options["pipe_diameter_mm"] == 800  # 폼 값이 이김
-    assert "inlet_basin_form" not in options  # 폼이 아는 칸을 폼이 비움 → 지움
+    # 표 01 명세(PLAN 52-1)가 뺀 옛 칸 = 폼이 모르는 칸 → 남음(지난 정의 값)
+    assert options["inlet_basin_form"] == "□형(기본형)"
     assert merged["out"][1]["options"] == {"side": "좌", "back_len_cm": "35"}
 
 
diff --git a/resources/tester/test_b05_structures_define.py b/resources/tester/test_b05_structures_define.py
new file mode 100644
index 000000000..1cb497663
--- /dev/null
+++ b/resources/tester/test_b05_structures_define.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""B05/B06 「구조물 배치」 칸 = 구조물 정의대로 — PLAN 48-3 · 48-4 (2026-10-05).
+
+정의(`구조물정의.json`)가 주는 차례 · 배치 격자 · 안 씀(`enabled:false`) · 규칙(상위 값 → 하위
+선택지 · 보이기 · 기본값) · 지난 정의 값 · 그룹 형상 칸 · 정의 덧칸 얹기를 본다.
+판 1 정의로는 지금 화면과 같음(차례 그대로 · 2열 · 기준 측점 보임).
+순수 규칙은 Node 헬퍼(`helper_b05_structures_define.cjs`)가 돌림 · 화면은 ORCA `ui_checks/48-3_구조물배치_정의그리기.js`.
+"""
+
+import json
+import os
+import subprocess
+
+import pytest
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+@pytest.fixture(scope="module")
+def out():
+    proc = subprocess.run(
+        ["node", os.path.join(HERE, "helper_b05_structures_define.cjs")],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def test_차례는_배치_줄_칸_뒤는_정의_차례_안씀_숨김_뺌(out):
+    assert out["order"] == ["t", "p", "q"]
+
+
+def test_격자_칸수와_자리(out):
+    assert out["columns"] == 2
+    assert out["columnsNone"] == 2
+    assert out["placeT"] == {"row": "1", "column": "1 / span 2"}
+    assert out["placeNone"] is None
+
+
+def test_규칙_선택지_보이기_사슬(out):
+    assert out["stateA"]["q"]["choices"] == ["b", "c"]
+    assert out["stateA"]["t"]["visible"] is False  # q=c → t 가림
+    assert out["stateB"]["q"]["visible"] is False  # p=b → q 가림
+    assert out["stateB"]["t"]["visible"] is True  # 가려진 q 에 매인 줄은 안 걸림
+
+
+def test_규칙_기본값(out):
+    assert out["defaultsA"] == {"q": "c"}
+    assert out["defaultsB"] == {}
+
+
+def test_지난_정의_값(out):
+    assert out["stale"] == [["old_key", 3]]
+
+
+def test_그룹_형상_칸(out):
+    assert [s["suffix"] for s in out["shapes"]] == ["length_m", "after_m"]
+    assert out["shapes"][0]["meaning"] == "연장"
+    assert out["shapeKey"] == "g1__length_m"
+
+
+def test_정의_덧칸_얹기(out):
+    assert out["withNull"] == [{"type_id": "a", "group": "A"}]
+    t = out["withDef"][0]
+    assert t["group_name"] == "가 군"
+    assert t["show_anchor"] is False
+    assert t["behaviors"] == ["계곡통과시설"]
+    assert t["spots"] == {"k": {"줄": 1, "칸": 1}}
+    assert [r["종류"] for r in t["rules"]] == ["a"]
+    assert t["groups"][0]["shape"] == {"길이": {"받기": True}}
+
+
+def test_판1_정의는_지금_화면과_같음(out):
+    assert out["v1Types"] == 37
+    assert out["v1Same"] is True
+    assert out["v1Columns"] == [2]
+    assert out["v1Anchor"] is True
diff --git a/resources/tester/test_b05_structures_repository.py b/resources/tester/test_b05_structures_repository.py
index 2f389d760..492ccad81 100644
--- a/resources/tester/test_b05_structures_repository.py
+++ b/resources/tester/test_b05_structures_repository.py
@@ -192,10 +192,11 @@ def test_placement_mismatching_registry_is_rejected(project_root):
         save_structures(project_root, [wall_as_point], base_revision=0)
 
 
-def test_undefined_option_key_is_rejected(project_root):
-    bad = _point(options={"form": "돌", "no_such_option": 1})
-    with pytest.raises(ValueError, match="옵션"):
-        save_structures(project_root, [bad], base_revision=0)
+def test_undefined_option_key_is_kept(project_root):
+    """지금 정의에 없는 키 = 지난 정의 값 — 오류 없이 그대로 남김(PLAN 48-1)."""
+    old = _point(options={"form": "돌", "no_such_option": 1})
+    assert save_structures(project_root, [old], base_revision=0) == 1
+    assert load_structures(project_root)[1][0].options["no_such_option"] == 1
 
 
 def test_negative_number_option_is_rejected(project_root):
diff --git a/resources/tester/test_b06_box_set.py b/resources/tester/test_b06_box_set.py
index c88753e6c..ca213b8a2 100644
--- a/resources/tester/test_b06_box_set.py
+++ b/resources/tester/test_b06_box_set.py
@@ -45,6 +45,14 @@ def test_box_wing_extends_slab() -> None:
     assert spec["wing_in"]["slab_extend_m"] == round(2 * math.cos(math.radians(45)), 3)
 
 
+def test_box_structure_choices() -> None:
+    """유입·유출 구조(표 02) — 날개벽 · 옛 값 있음만 날개벽을 세움 · 흙막이 · 없음은 안 세움."""
+    for value, installed in (("날개벽", True), ("있음", True), ("흙막이", False), ("없음", False)):
+        spec = _box_set({"wing_in": value, "wing_in_length_m": 2})
+        assert spec["wing_in"]["installed"] is installed
+        assert (spec["wing_in"]["slab_extend_m"] > 0) is installed
+
+
 def test_attach_box_only_owner_station(tmp_path: Path) -> None:
     """BOX암거는 **소유 측점 한 곳에만** `box` 키로 붙는다(2026-08-25 사용자 확정).
 
diff --git a/resources/tester/test_b06_box_thickness_registry.py b/resources/tester/test_b06_box_thickness_registry.py
index dfabe7746..198b6682a 100644
--- a/resources/tester/test_b06_box_thickness_registry.py
+++ b/resources/tester/test_b06_box_thickness_registry.py
@@ -18,7 +18,7 @@ ROOT = Path(__file__).resolve().parents[2]
 
 def _box_options() -> dict[str, dict]:
     registry = json.loads(
-        (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+        (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
     )
     types = registry if isinstance(registry, list) else registry.get("types") or []
     box = next(t for t in types if t["type_id"] == "box_culvert")
diff --git a/resources/tester/test_b06_culvert_sets_mirror.py b/resources/tester/test_b06_culvert_sets_mirror.py
index b92cc6499..9ddacc95d 100644
--- a/resources/tester/test_b06_culvert_sets_mirror.py
+++ b/resources/tester/test_b06_culvert_sets_mirror.py
@@ -58,7 +58,13 @@ POINTS = [
     {
         "chainage_m": 80.0,
         "facility": "box_culvert",
-        "options": {"body_width_m": 3.0, "body_height_m": 2.5, "wing_out_length_m": 2.0},
+        "options": {
+            "body_width_m": 3.0,
+            "body_height_m": 2.5,
+            "wing_in": "날개벽",
+            "wing_out": "흙막이",
+            "wing_out_length_m": 2.0,
+        },
     },
     {
         "chainage_m": 100.0,
diff --git a/resources/tester/test_b06_pipe_form_keys.py b/resources/tester/test_b06_pipe_form_keys.py
index 2314a3120..059016c5a 100644
--- a/resources/tester/test_b06_pipe_form_keys.py
+++ b/resources/tester/test_b06_pipe_form_keys.py
@@ -32,7 +32,7 @@ QUANTITY_ONLY = {
 
 def _pipe_option_keys() -> list[str]:
     payload = json.loads(
-        (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+        (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
     )
     types = payload if isinstance(payload, list) else payload["types"]
     pipe = next(item for item in types if item["type_id"] == "pipe")
diff --git a/resources/tester/test_b08_dry_height_face_role.py b/resources/tester/test_b08_dry_height_face_role.py
index 465478e13..280bcab9a 100644
--- a/resources/tester/test_b08_dry_height_face_role.py
+++ b/resources/tester/test_b08_dry_height_face_role.py
@@ -20,7 +20,7 @@ from B08_Quantity.B08_Quantity_Engine_UnitQuantity import expand, stone_masonry
 from common_util.common_util_structure_face_role import structure_face_role_of  # noqa: E402
 
 REGISTRY = json.loads(
-    (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+    (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
 )
 FIELDS = (ROOT / "B05_Profile" / "B05_Profile_UI_Structures_Fields.ts").read_text(encoding="utf-8")
 
diff --git a/resources/tester/test_b08_option_keys.py b/resources/tester/test_b08_option_keys.py
index ba9985dcf..d9847d684 100644
--- a/resources/tester/test_b08_option_keys.py
+++ b/resources/tester/test_b08_option_keys.py
@@ -30,7 +30,7 @@ KNOWN_ABSENT: dict[str, str] = {}
 
 def _registry_keys() -> set[str]:
     payload = json.loads(
-        (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+        (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
     )
     types = payload if isinstance(payload, list) else (payload.get("types") or [])
     return {option["key"] for item in types for option in item.get("options") or []}
diff --git a/resources/tester/test_b08_preparation.py b/resources/tester/test_b08_preparation.py
index 9d6ddb716..a77b15bb3 100644
--- a/resources/tester/test_b08_preparation.py
+++ b/resources/tester/test_b08_preparation.py
@@ -90,7 +90,7 @@ def test_사방_종류_이름이_레지스트리와_맞을것() -> None:
     import json
 
     registry = json.loads(
-        (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+        (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
     )
     types = registry if isinstance(registry, list) else (registry.get("types") or [])
     known = {t["type_id"] for t in types}
diff --git a/resources/tester/test_b08_structure_table_holes.py b/resources/tester/test_b08_structure_table_holes.py
index 5b6363f23..e38067bd0 100644
--- a/resources/tester/test_b08_structure_table_holes.py
+++ b/resources/tester/test_b08_structure_table_holes.py
@@ -68,7 +68,7 @@ def test_바닥막이는_제곱미터당() -> None:
 
 def test_개거_L형수로는_등록부_글자로_선다() -> None:
     registry = json.loads(
-        (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+        (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
     )
     choices = next(
         option["choices"]
diff --git a/resources/tester/test_b08_wing_wall.py b/resources/tester/test_b08_wing_wall.py
index a8d0bd619..c3e4cfadf 100644
--- a/resources/tester/test_b08_wing_wall.py
+++ b/resources/tester/test_b08_wing_wall.py
@@ -29,7 +29,7 @@ from B08_Quantity.B08_Quantity_Engine_UnitQuantity import (  # noqa: E402
 
 def _registry_choices() -> list[str]:
     payload = json.loads(
-        (ROOT / "B05_Profile" / "B05_Profile_Structure_Types.json").read_text(encoding="utf-8")
+        (ROOT / "resources" / "master_template" / "구조물정의.json").read_text(encoding="utf-8")
     )
     types = payload if isinstance(payload, list) else payload["types"]
     pipe = next(item for item in types if item["type_id"] == "pipe")
diff --git a/resources/tester/test_m01_logic_source.py b/resources/tester/test_m01_logic_source.py
index 75d2dab56..5c595c771 100644
--- a/resources/tester/test_m01_logic_source.py
+++ b/resources/tester/test_m01_logic_source.py
@@ -53,3 +53,54 @@ def test_route() -> None:
     app.include_router(router_module.router)
     got = TestClient(app).get("/api/m01/logic/source", params={"src": "산림품셈 3-1"}).json()
     assert got["found"][0]["matched"] == "3-1"
+
+
+def test_tables_split_and_br() -> None:
+    """빈 줄 · 주석이 붙은 표 둘을 가름(49-2) · 칸 안 `<br>` = 줄바꿈."""
+    one = make.source("건설품셈 공통 6-1-1")["found"][0]
+    tables = [b["table"] for b in one["blocks"] if "table" in b]
+    assert [len(t[0]) for t in tables] == [7, 2]
+    assert tables[0][2][0] == "인력운반\n타설"
+
+
+def test_markdown_stripped() -> None:
+    """역슬래시 · 인용 `>` 머리 · 글 안 주석을 벗김(50-2) — 모든 정본 출처 원문에 0."""
+    bad = 0
+    for path in store.FOLDER.glob("로직_*품셈_*.json"):
+        for row in json.loads(path.read_text(encoding="utf-8"))["줄"]:
+            for one in make.source(row.get("출처", ""))["found"]:
+                for b in one["blocks"]:
+                    t = b.get("p") or b.get("text") or ""
+                    bad += "\\" in t or "<!--" in t or t.startswith(">")
+    assert bad == 0
+    one = make.source("산림품셈 3-4-2 1")["found"][0]
+    assert any(b.get("p") == "Q = 3,600 × q × K × f × E / Cm" for b in one["blocks"])
+
+
+def test_item_marked() -> None:
+    """출처 항 · 주 번호 → 그 조각만 hit(절은 통째) · 못 찾으면 item 없음."""
+
+    def hits(src: str) -> list[str]:
+        one = make.source(src)["found"][0]
+        return [(b.get("p") or b.get("text") or "table")[:2] for b in one["blocks"] if b.get("hit")]
+
+    one = make.source("산림품셈 3-4-2 1")["found"][0]
+    assert one["item"] == "1" and one["blocks"][0].get("hit") is None
+    assert not any(b.get("hit") for b in one["blocks"] if b.get("p", "").startswith("2."))
+    assert hits("산림품셈 3-4-2 1")[0] == "1."
+    assert hits("산림품셈 9-7-1 주⑥") == ["⑥ "]
+    assert make.source("산림품셈 13-10-2 2")["found"][0]["item"] == "2"
+    assert "item" not in make.source("산림품셈 3-4-2")["found"][0]
+
+
+def test_item_all_marked() -> None:
+    """항 · 주 번호가 달린 정본 출처는 전부 표시가 붙음(전수)."""
+    total = missing = 0
+    for path in store.FOLDER.glob("로직_*품셈_*.json"):
+        for row in json.loads(path.read_text(encoding="utf-8"))["줄"]:
+            src = row.get("출처", "")
+            if not any(i for _n, i in make._NUMBER.findall(src)):
+                continue
+            total += 1
+            missing += not any(f.get("item") for f in make.source(src)["found"])
+    assert total >= 30 and missing == 0, (total, missing)
diff --git a/resources/tester/test_m02_area_marks.py b/resources/tester/test_m02_area_marks.py
new file mode 100644
index 000000000..f542edb8c
--- /dev/null
+++ b/resources/tester/test_m02_area_marks.py
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""50-1 면적산출 알약 · 보낸 범위 표시 — 원문 규칙 점검(화면 수치는 ui_checks/50-1_*.js 를 ORCA 로)."""
+
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.join(HERE, "..", "..")
+
+
+def _read(*parts: str) -> str:
+    with open(os.path.join(ROOT, *parts), encoding="utf-8") as f:
+        return f.read()
+
+
+def test_orphan_mark_only_when_list_confirmed():
+    # ⚠ 는 호스트가 목록을 확정했을 때만 — 알약 받기 실패(확정 없음)는 표시 안 함
+    links = _read("A00_Common", "spreadsheet", "spreadsheet_links.ts")
+    assert 'opts.모드 === "입력" && opts.확정 === true' in links
+    structure = _read("M02_MasterTemplete", "M02_MasterTemplete_Structure.ts")
+    assert "확정: true" in structure
+    assert structure.count("확정: true") == 1  # 실패 길(none)은 확정 없음
+
+
+def test_cell_pick_highlights_pill_and_range_is_unfilled():
+    links = _read("A00_Common", "spreadsheet", "spreadsheet_links.ts")
+    assert "is-here" in links and "scrollIntoView" in links
+    css = _read("A00_Common", "spreadsheet", "spreadsheet_links.css")
+    block = css.split(".ss-link-range {", 1)[1].split("}", 1)[0]
+    assert "dashed" in block and "background" not in block  # 채움 없음 = 알약 색과 안 겹침
+
+
+def test_sent_ranges_from_same_column_drawing():
+    src = _read("M02_MasterTemplete", "M02_MasterTemplete_AreaToDrawing.ts")
+    assert 'readTemplate(at.layer, "structure", at.name, at.projectId)' in src
+    assert '"{id} 도면"' in src
diff --git a/resources/tester/test_m02_card_shell.py b/resources/tester/test_m02_card_shell.py
index 7431f9b31..6b03b170e 100644
--- a/resources/tester/test_m02_card_shell.py
+++ b/resources/tester/test_m02_card_shell.py
@@ -79,9 +79,16 @@ def test_일위대가_카드는_상세_카드_갈래():
     assert "Labor_View" not in cards  # 한 줄 표(40-2) 안 씀
     detail = _text("M02_MasterTemplete_Labor_Detail.ts")
     assert "...(opt.card ? {} : { move })" in detail  # 순서 단추 없음 · 빼기는 그대로
-    assert "opt.card ? null : addLogic" in detail and "...(opt.card ? [] : [dgBox])," in detail
+    # 서고 모드(50-3 · lib)도 더하기 · 다이어그램 없음
+    # 51-11 사전조합 = 일위대가 상세와 같은 [로직 추가] · 같은 목록(걸러냄 없음)
+    assert "opt.card || promote ? null : addLogic" in detail
+    assert "only" not in _text("M02_MasterTemplete_Labor_Pick.ts")
+    assert "...(opt.card || lib ? [] : [dgBox])," in detail
+    assert "opt.card ? null : addMat" in detail  # 49-6 — 카드엔 [자재 추가] 없음 · 상세는 그대로
     rows = _text("M02_MasterTemplete_Labor_Rows.ts")
-    assert "const tools = !!(move || remove || option);" in rows and "compactTable" not in rows
+    assert (
+        "const tools = !!(move || remove || option || ref);" in rows and "compactTable" not in rows
+    )
     assert "compact" not in _text("M02_MasterTemplete_Labor_View.ts").split("*/", 1)[1]
 
 
@@ -122,7 +129,9 @@ def test_일위대가_줄_고름과_옵션_단추():
     단추 위로 · 아래로 · 옵션 · 삭제(빨강) · 묶음 간격 = 공용 `ui-btn-group`."""
     detail = _text("M02_MasterTemplete_Labor_Detail.ts")
     assert "open: pick," in detail and "option: openRow," in detail
-    assert "{ open: pick, option: openRow }" in detail  # 읽기만도 고름 · [옵션] = 보기 모달
+    assert (
+        "{ open: pick, option: openRow, ref: openRef }" in detail
+    )  # 읽기만도 고름 · [옵션] = 보기 모달
     assert "selected: picked" in detail
     rows = _text("M02_MasterTemplete_Labor_Rows.ts")
     up, down = rows.index('small(tc("Up")'), rows.index('small(tc("Down")')
@@ -136,3 +145,18 @@ def test_일위대가_줄_고름과_옵션_단추():
         assert t in text
     css = (ROOT / "ui_template" / "ui_template_general_layout.css").read_text(encoding="utf-8")
     assert ".ui-btn-group {" in css and "gap: var(--btn-group-gap);" in css
+
+
+def test_순서칸_2행_참조줄_옵션_수정():
+    """51-14 — 순서 칸 2행(위 [위로] [아래로] / 아래 [옵션]·[수정] [삭제]) · 단가승격 [옵션] · 일위조합 [수정] =
+    서고 원본 모달(저장 = 서고 저장 길 · 자기 층만 고침) · 닫으면 다시 셈."""
+    rows = _text("M02_MasterTemplete_Labor_Rows.ts")
+    assert 'className: "m02-labrow__tools"' in rows
+    assert '"SP-") ? "Labor_Option" : "Labor_Edit"' in rows
+    detail = _text("M02_MasterTemplete_Labor_Detail.ts")
+    assert "readOnly: !edit || ref.층 !== opt.layer," in detail
+    assert "closed: () => alive && recalc()," in detail
+    ref = _text("M02_MasterTemplete_Labor_RefEdit.ts")
+    assert "saveTemplate(layer, kind, opt.ref.키, null, 판, body)" in ref
+    assert 'mode: "precombo",' in ref and "showConfirmDialog" in ref
+    assert 'Labor_Edit: ["수정"' in _text("M02_MasterTemplete_Labor_Text.ts")
diff --git a/resources/tester/test_m02_combo_screen.py b/resources/tester/test_m02_combo_screen.py
index 929c47ea0..dcf3d396d 100644
--- a/resources/tester/test_m02_combo_screen.py
+++ b/resources/tester/test_m02_combo_screen.py
@@ -5,8 +5,7 @@
    빼고(30-7), [저장] 때 저장본 것을 다시 끼움(열 차례 = 저장본 · 보인 고침은 받음).
 ② 표 부품 `lockHead` — 열 더하기 · 지우기 · 머리 · 층 이름 고치기 없음(단위 · 조회 후 선택은
    그대로).
-③ 나무는 좌측 패널 「구조물 조합」 줄 아래(층 단추 + 나무 · PLAN 29-2) · 상세 위쪽 찾기 칸은
-   「구조물 조합」일 때만.
+③ 나무는 좌측 패널 「구조물 조합」 줄 아래(층 단추 + 나무 · PLAN 29-2) · 찾기 칸 없음(49-8).
 """
 
 from __future__ import annotations
@@ -101,21 +100,18 @@ def test_참조표는_열_머리를_못_고침():
     assert "getDoc: () => comboMerge(loaded, shown.getDoc())" in main
 
 
-def test_나무는_좌측_패널_찾기_칸은_상세_위쪽():
+def test_나무는_좌측_패널_찾기_칸_없음():
     side = _text(M02 / "M02_MasterTemplete_UI_Side.ts")
     assert "tree?: HTMLElement[];" in side and "children: opt.tree ?? []" in side
     assert 'info.이름 === STRUCTURE_TABLE ? L("M02_KindTable")' in side  # 좌측 줄 이름
     page = _text(M02 / "M02_MasterTemplete_UI_Page.ts")
     assert "createTreePanel({" in page and "tree.select(column)" in page
-    assert (
-        'layerBar("구조물조합", tree.add, () => void main.openTable(layer)),' in page
-        and "search: tree.search," in page
-    )
+    assert 'layerBar("구조물조합", tree.add, () => void main.openTable(layer)),' in page
     main = _text(M02 / "M02_MasterTemplete_UI_Main.ts")
     assert 'at.kind === "table" && at.name === STRUCTURE_TABLE && at.layer !== "project"' in main
     assert 'isCombo(next) ? L("M02_KindTable")' in main  # 상세 제목
     assert main.count("showAside();") == 3  # 열 때 · 양식 밖 화면 · 처음
-    assert "if (extras.search) extras.search.hidden = !combo;" in main
+    assert "extras.search" not in main and "tree.search" not in page  # 찾기 칸 없앰(49-8)
     locale = _text(ROOT / "ui_template" / "ui_template_locale_m2.ts")
     assert 'M02_KindTable: ["구조물 조합"' in locale
     assert ".m02-shell" not in _text(
diff --git a/resources/tester/test_m02_labor_doc.py b/resources/tester/test_m02_labor_doc.py
index a2a629fd0..c42ce06ed 100644
--- a/resources/tester/test_m02_labor_doc.py
+++ b/resources/tester/test_m02_labor_doc.py
@@ -90,6 +90,14 @@ def test_반영은_기준_곱_수량_나누기_배_돈_아닌_로직은_반영_
     assert got["반영합"]["계"] == pytest.approx(ten["반영"]["계"])
 
 
+def test_돈_로직_줄에_재료_노무_경비_줄_실림_합은_기준():
+    got = labor.calc(labor.clean(_doc(담은로직=[{"로직": TEN}, {"로직": PLAIN}])), {})
+    ten, plain = got["줄"]
+    assert ten["줄"] and all({"이름", "수량", "단위", "금액"} <= set(x) for x in ten["줄"])
+    assert sum(x["금액"] for x in ten["줄"]) == pytest.approx(ten["기준"]["계"])
+    assert "줄" not in plain
+
+
 def test_수량_손이_칸보다_앞섬_칸_값은_알약_키로():
     doc = labor.clean(
         _doc(
diff --git a/resources/tester/test_m02_labor_ref.py b/resources/tester/test_m02_labor_ref.py
new file mode 100644
index 000000000..5dc00d437
--- /dev/null
+++ b/resources/tester/test_m02_labor_ref.py
@@ -0,0 +1,436 @@
+"""일위대가 조합 서고(PLAN 50-3 · `M02_Labor_Ref`) — 단가승격 · 사전조합 · 참조 줄.
+
+펼침(재귀 · 순환 · 깊이) · 층 규칙(위 층만) · 쓰는 곳 지우기 409 · 층 사이 따라 복사 ·
+프로젝트 굳힘 · 로직 지우기 검사 · TS 짝 settle 거울. 층은 임시 폴더(마스터 · storage).
+"""
+
+import json
+from decimal import Decimal
+
+import pytest
+
+from M02_MasterTemplete import M02_Labor_Doc as labor
+from M02_MasterTemplete import M02_Labor_Ref as refs
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete import M02_Template_Layers as layers
+from resources.tester.test_m02_labor_calc_mirror import _same, _ts
+from resources.tester.test_m02_structure import write_sample_table
+
+TEN = "GC000421"  # 원/10㎡ — 배 10
+STONE = "GF000219"  # 원/㎡
+PLAIN = "GC000422"  # 돈 아닌 로직
+SYS = {"층": "system", "주인": None}
+COMPANY = {"층": "company", "주인": "7"}
+MINE = {"층": "personal", "주인": "7/42"}
+
+
+@pytest.fixture()
+def world(tmp_path, monkeypatch):
+    from config import config_system
+
+    system = tmp_path / "system"
+    system.mkdir()
+    write_sample_table(system)
+    monkeypatch.setattr(store, "FOLDER", system)
+    monkeypatch.setattr(layers, "SYSTEM_ROOT", system)
+    (tmp_path / "storage").mkdir()
+    monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(tmp_path / "storage"))
+    with store.at(system):
+        store.create_structure("rv")
+    return {
+        "system": system,
+        "company": layers.company_dir(7),
+        "personal": layers.personal_dir(7, 42),
+    }
+
+
+def _promote(folder, code=TEN, **extra):
+    with store.at(folder):
+        return refs.create("promote", {"담은로직": [{"로직": code, "입력값": {}}], **extra})["이름"]
+
+
+def _combo(folder, lines, name="조합"):
+    with store.at(folder):
+        return refs.create("precombo", {"이름": name, "담은로직": lines})["이름"]
+
+
+def _read(folder, kind, key):
+    return json.loads((folder / kind / f"{key}.json").read_bytes())
+
+
+def _base(code):
+    import M01_MasterData.M01_MasterData_Store as m01
+
+    return labor.run_line(m01.loaded()[1], code, {})["기준"]
+
+
+# ── 자료 틀 ────────────────────────────────────────────────────────────
+def test_승격은_로직_한_줄_단위_배_이름은_로직에서_키는_층마다_다음_번호(world):
+    assert _promote(world["system"]) == "SP-000001"
+    assert _promote(world["system"], STONE, 이름="돌") == "SP-000002"
+    assert _promote(world["personal"]) == "SP-000001"  # 층마다 셈
+    doc = _read(world["system"], "promote", "SP-000001")
+    assert (doc["종류"], doc["단위"], doc["배"]) == ("단가승격", "㎡", 10)
+    assert doc["이름"] and doc["담은로직"] == [{"로직": TEN, "입력값": {}}]
+    assert _read(world["system"], "promote", "SP-000002")["이름"] == "돌"
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        {"담은로직": []},
+        {"담은로직": [{"로직": TEN}, {"로직": STONE}]},
+        {"담은로직": [{"로직": "GF999999"}]},
+        {"담은로직": [{"참조": {**SYS, "키": "SP-000001"}}]},
+    ],
+)
+def test_틀린_승격은_400(world, body):
+    _promote(world["system"])
+    with store.at(world["system"]), pytest.raises(store.StoreError) as e:
+        refs.create("promote", body)
+    assert e.value.status == 400
+
+
+def test_사전조합_틀린_줄_400_순환_422(world):
+    sp = _promote(world["system"])
+    one = {"참조": {**SYS, "키": sp}}
+    for lines in (
+        [{"로직": "GF999999"}],  # 모르는 로직
+        [{"로직": TEN}, {"로직": TEN}],  # 같은 로직 두 번(51-11)
+        [{"로직": TEN, "입력값": [1]}],  # 입력값 꼴
+        [one, one],  # 같은 참조 두 번
+        [{"참조": {**SYS, "키": "SP-000009"}}],  # 없는 참조
+        [{"참조": {**SYS, "키": "SU-000001"}}],  # 서고 키 아님
+    ):
+        with pytest.raises(store.StoreError) as e:
+            _combo(world["system"], lines)
+        assert e.value.status == 400
+    a = _combo(world["system"], [one], "가")
+    b = _combo(world["system"], [{"참조": {**SYS, "키": a}}], "나")
+    with store.at(world["system"]):
+        have = store.read("precombo", a)
+        with pytest.raises(store.StoreError) as e:
+            store.write(
+                "precombo",
+                a,
+                have["판"],
+                {**have["문서"], "담은로직": [{"참조": {**SYS, "키": b}}]},
+            )
+    assert e.value.status == 422 and f"{a} → {b} → {a}" in e.value.detail
+
+
+def test_층_규칙은_위_층만(world):
+    _promote(world["system"])
+    _promote(world["company"])
+    _promote(world["personal"])
+    ok = [{"참조": {**s, "키": "SP-000001"}} for s in (SYS, COMPANY, MINE)]
+    assert _combo(world["personal"], ok) == "SC-000001"  # 개인 → 개인 · 회사 · 마스터
+    for folder, bad in (
+        (world["company"], MINE),  # 회사 → 개인 X
+        (world["system"], COMPANY),  # 마스터 → 회사 X
+        (world["personal"], {"층": "personal", "주인": "7/43"}),  # 남의 개인 X
+        (world["personal"], {"층": "company", "주인": "8"}),  # 남의 회사 X
+    ):
+        with pytest.raises(store.StoreError) as e:
+            _combo(folder, [{"참조": {**bad, "키": "SP-000001"}}])
+        assert e.value.status == 400 and "위 층만" in e.value.detail
+
+
+def test_일위대가_참조_줄_정리_같은_참조_두_번_400(world):
+    sp = _promote(world["system"])
+    line = {"참조": {**SYS, "키": sp}, "별칭": " 승격 ", "수량": {"손": 3}}
+    with store.at(world["system"]):
+        got = labor.clean({"열": "rv", "담은로직": [line]})["담은로직"]
+        assert got == [{"참조": {**SYS, "키": sp}, "별칭": "승격", "메모": None, "수량": {"손": 3}}]
+        with pytest.raises(store.StoreError) as e:
+            labor.clean({"열": "rv", "담은로직": [line, line]})
+    assert e.value.status == 400
+
+
+# ── 펼침(계산) ─────────────────────────────────────────────────────────
+def test_calc_는_참조를_펼침_승격은_기준_나누기_배_사전조합은_수량_곱(world):
+    sp = _promote(world["system"])
+    sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}, "수량": {"손": 2}}], "둘")
+    ref = {**SYS, "키": sc}
+    with store.at(world["system"]):
+        doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 5}}]})
+        got = labor.calc(doc, {})
+    one = got["줄"][0]
+    want = Decimal(str(_base(TEN)["계"])) / 10 * 2
+    assert one["기준"]["계"] == pytest.approx(float(want))
+    assert (one["분모"], one["배"], one["알약"]) == (None, 1, refs.ref_id(ref))
+    assert one["반영"]["계"] == pytest.approx(float(want * 5))
+    assert one["안"][0]["수량"] == 2 and one["안"][0]["참조"]["키"] == sp
+    pills = labor.pills(doc)
+    assert pills == [{"키": refs.ref_id(ref), "이름": "둘", "단위": "", "로직": [], "참조": ref}]
+
+
+def test_승격_줄_상세는_원_로직_키_표_사전조합은_안_줄만(world):
+    sp = _promote(world["system"])
+    sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}}], "하나")
+    with store.at(world["system"]):
+        doc = labor.clean({"열": "rv", "담은로직": [{"참조": {**SYS, "키": k}} for k in (sp, sc)]})
+        promote, combo = labor.calc(doc, {})["줄"]
+    assert promote["원로직"] == TEN and promote["줄"]
+    assert sum(x["금액"] for x in promote["줄"]) == pytest.approx(
+        promote["기준"]["계"]
+    )  # 1 단위(51-2)
+    assert "줄" not in combo and [x["참조"]["키"] for x in combo["안"]] == [sp]
+
+
+def test_펼침은_순환_깊이_없는_참조를_까닭으로_멈춤(world):
+    folder = world["system"] / "precombo"
+    for key, child in (("SC-000001", "SC-000002"), ("SC-000002", "SC-000001")):
+        body = {"이름": key, "담은로직": [{"참조": {**SYS, "키": child}}]}
+        (folder / f"{key}.json").write_text(json.dumps(body), encoding="utf-8")
+    import M01_MasterData.M01_MasterData_Store as m01
+
+    expand = refs.Expand(m01.loaded()[1])
+    got = expand({**SYS, "키": "SC-000001"})
+    assert got["기준"] is None and "순환" in got["까닭"]
+    assert "없는 참조" in expand({**SYS, "키": "SC-000009"})["까닭"]
+    deep = refs.Expand(
+        m01.loaded()[1], lambda r: {"담은로직": [{"참조": {**SYS, "키": "SC-000001"}}]}
+    )
+    assert deep.__call__({**SYS, "키": "SC-000001"}, ())["기준"] is None
+
+
+def test_돈_아닌_승격은_까닭(world):
+    sp = _promote(world["system"], PLAIN)
+    import M01_MasterData.M01_MasterData_Store as m01
+
+    got = refs.Expand(m01.loaded()[1])({**SYS, "키": sp})
+    assert got["기준"] is None and got["까닭"]
+
+
+def test_참조_줄_settle_파이썬과_TS_가_같은_답(world):
+    sp = _promote(world["system"])
+    ref = {**SYS, "키": sp}
+    with store.at(world["system"]):
+        doc = labor.clean(
+            {"열": "rv", "담은로직": [{"로직": STONE, "수량": None}, {"참조": ref, "수량": None}]}
+        )
+        answer = labor.calc(doc, {})
+    values = {refs.ref_id(ref): 4}
+    py = labor.settle(answer, doc, values)
+    assert py["줄"][1]["수량출처"] == "칸"
+    _same(py, _ts(answer, doc, values))
+
+
+# ── 지우기 · 복사 · 굳힘 · 로직 지우기 ─────────────────────────────────
+def test_쓰는_곳이_있으면_지우기_409_없으면_지움(world):
+    sp = _promote(world["system"])
+    with store.at(world["personal"]):
+        line = {"참조": {**SYS, "키": sp}}
+        store.write("labor", "x1", "", {"열": "x1", "담은로직": [line], "자재": []})
+    with store.at(world["system"]), pytest.raises(store.StoreError) as e:
+        store.delete("promote", sp)
+    assert e.value.status == 409 and "개인 7/42" in e.value.detail
+    (world["personal"] / "labor" / "x1.json").unlink()
+    with store.at(world["system"]):
+        store.delete("promote", sp)
+    assert not (world["system"] / "promote" / f"{sp}.json").exists()
+
+
+def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):
+    sp = _promote(world["personal"])
+    sys_sp = _promote(world["system"])
+    sc = _combo(
+        world["personal"],
+        [{"참조": {**MINE, "키": sp}}, {"참조": {**SYS, "키": sys_sp}, "수량": {"손": 2}}],
+    )
+    with store.at(world["personal"]):
+        doc = store.read("precombo", sc)["문서"]
+    with store.at(world["company"]):
+        made = refs.create(
+            "precombo", refs.carry({**doc, "본뜬": {**MINE, "키": sc}}, ("personal", "7/42"))
+        )
+    got = _read(world["company"], "precombo", made["이름"])
+    assert got["본뜬"] == {**MINE, "키": sc}
+    assert [one["참조"] for one in got["담은로직"]] == [
+        {**COMPANY, "키": "SP-000001"},  # 회사가 못 읽는 개인 승격 → 회사 층 새 키
+        {**SYS, "키": sys_sp},  # 마스터는 그대로
+    ]
+    assert _read(world["company"], "promote", "SP-000001")["본뜬"] == {**MINE, "키": sp}
+
+
+def test_길_새로_복사_권한(world):
+    from fastapi import FastAPI
+    from fastapi.testclient import TestClient
+
+    from common_util.common_util_auth import verify_session
+    from M02_MasterTemplete import M02_Labor_Router as labor_router
+
+    app = FastAPI()
+    app.include_router(labor_router.router)
+    app.dependency_overrides[verify_session] = lambda: {
+        "user_id": 42,
+        "company_id": 7,
+        "role": "USER",
+        "is_master": False,
+    }
+    client = TestClient(app)
+    url = "/api/m02/layers/{}/library/{}"
+    body = {"문서": {"담은로직": [{"로직": TEN}]}}
+    got = client.post(url.format("personal", "promote"), json=body).json()
+    assert got["이름"] == "SP-000001"
+    assert client.post(url.format("system", "promote"), json=body).status_code == 403
+    copy = {"본뜬": {**MINE, "키": "SP-000001"}}
+    assert client.post(url.format("personal", "promote"), json=copy).json()["이름"] == "SP-000002"
+    other = {"본뜬": {"층": "personal", "주인": "7/99", "키": "SP-000001"}}
+    assert client.post(url.format("personal", "promote"), json=other).status_code == 403
+
+
+def test_프로젝트는_참조사본으로_굳힘_원본을_지워도_같은_값(world):
+    from M02_MasterTemplete import M02_Item_Prices as prices
+    from M02_MasterTemplete import M02_Item_Source as source
+
+    sp = _promote(world["system"])
+    sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}, "수량": {"손": 2}}])
+    ref = {**SYS, "키": sc}
+    with store.at(world["system"]):
+        doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 1}}]})
+        live = labor.calc(doc, {})["줄"][0]["기준"]["계"]
+    rows = source.labor_doc_rows(doc)
+    assert set(rows["참조사본"]) == {refs.ref_id(ref), refs.ref_id({**SYS, "키": sp})}
+    assert refs.frozen_logics(rows["참조사본"]) == [TEN]
+    bundle = prices.to_json(prices.collect([TEN]))
+    for key in (sc, sp):  # 원본이 사라져도 프로젝트는 사본만 봄
+        kind = refs.kind_of(key)
+        (world["system"] / kind / f"{key}.json").unlink()
+    got = prices.calc(rows, bundle, {}, {}, None)
+    line = got["줄"][0]
+    assert line["ok"] and line["참조"] == ref
+    assert line["계"] == pytest.approx(live, rel=1e-9)
+    assert line["수량"] == 1 and line["반영"]["계"] == pytest.approx(live, rel=1e-9)
+
+
+def test_로직_지우기_검사는_단가승격도_보고_참조_줄은_건너뜀(world):
+    from M01_MasterData import M01_MasterData_Store_Cache as cache
+
+    sp = _promote(world["system"], STONE)
+    with store.at(world["system"]):
+        have = store.read("labor", "rv")
+        line = {"참조": {**SYS, "키": sp}}
+        store.write("labor", "rv", have["판"], {**have["문서"], "담은로직": [line]})
+
+    class Gone:  # STONE 을 지운 마스터
+        def logic(self, code):
+            if code == STONE:
+                raise cache.cm.mf.FormulaError("없음")
+
+    got = cache.labor_errors(Gone())
+    assert got == [f"단가승격 마스터 「{sp}」 이 로직 「{STONE}」 을 씀 — 거기서 먼저 뺌"]
+
+
+def test_새_프로젝트_씨앗은_서고를_안_가져감(world, tmp_path):
+    _promote(world["system"])
+    got = layers.seed_project(tmp_path / "p1")
+    assert not any(k.startswith(layers.LIBRARY_KINDS) for k in got["작업본"])
+
+
+def test_층_목록_서고_줄은_이름_단위_기준금액을_실음(world):
+    sp = _promote(world["system"])
+    sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}, "수량": {"손": 3}}], "셋")
+    rows = [
+        {"종류": "promote", "이름": sp},
+        {"종류": "precombo", "이름": sc},
+        {"종류": "labor", "이름": "rv"},
+    ]
+    refs.summaries(world["system"], rows)
+    one = float(Decimal(str(_base(TEN)["계"])) / 10)
+    assert rows[0]["기준금액"] == pytest.approx(one)
+    assert (rows[1]["제목"], rows[1]["기준금액"]) == ("셋", pytest.approx(one * 3))
+    assert "기준금액" not in rows[2]
+
+
+def test_사전조합_로직_줄_섞임_합은_손셈_지우기_409_굳힘(world):
+    from M01_MasterData import M01_MasterData_Store_Cache as cache
+    from M02_MasterTemplete import M02_Item_Prices as prices
+    from M02_MasterTemplete import M02_Item_Source as source
+
+    sp = _promote(world["system"])
+    lines = [
+        {"참조": {**SYS, "키": sp}, "수량": {"손": 2}},
+        {"로직": STONE, "입력값": {"없는칸": 1}, "수량": {"손": 3}, "메모": "돌"},
+        {"로직": TEN},
+    ]
+    sc = _combo(world["system"], lines, "섞음")
+    saved = _read(world["system"], "precombo", sc)["담은로직"]
+    assert saved[1:] == [
+        {"로직": STONE, "입력값": {}, "수량": {"손": 3}, "메모": "돌"},
+        {"로직": TEN, "입력값": {}, "수량": {"손": 1}, "메모": None},
+    ]
+    ten, stone = (Decimal(str(_base(c)["계"])) for c in (TEN, STONE))
+    want = ten / 10 * 2 + stone * 3 + ten / 10 * 1  # 손셈 — 승격 · TEN 은 원/10㎡(배 10)
+    ref = {**SYS, "키": sc}
+    with store.at(world["system"]):
+        doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 5}}]})
+        one = labor.calc(doc, {})["줄"][0]
+    assert one["기준"]["계"] == pytest.approx(float(want))
+    assert one["반영"]["계"] == pytest.approx(float(want * 5))
+    assert [x.get("로직") or x["참조"]["키"] for x in one["안"]] == [sp, STONE, TEN]
+    with store.at(world["system"]), pytest.raises(store.StoreError) as e:
+        store.delete("promote", sp)
+    assert e.value.status == 409 and "사전조합 마스터 「섞음」" in e.value.detail
+
+    class Gone:  # STONE 을 지운 마스터
+        def logic(self, code):
+            if code == STONE:
+                raise cache.cm.mf.FormulaError("없음")
+
+    got = cache.labor_errors(Gone())
+    assert f"사전조합 마스터 「{sc}」 이 로직 「{STONE}」 을 씀 — 거기서 먼저 뺌" in got
+    rows = source.labor_doc_rows(doc)
+    assert sorted(refs.frozen_logics(rows["참조사본"])) == sorted([TEN, STONE, TEN])
+    bundle = prices.to_json(prices.collect([TEN, STONE]))
+    for key in (sc, sp):  # 원본이 사라져도 굳힌 사본으로 같은 값
+        (world["system"] / refs.kind_of(key) / f"{key}.json").unlink()
+    got = prices.calc(rows, bundle, {}, {}, None)["줄"][0]
+    assert got["계"] == pytest.approx(float(want), rel=1e-9)
+
+
+def test_사전조합이_자기_자신을_담으면_422_수량_기본_1(world):
+    sp = _promote(world["system"])
+    a = _combo(world["system"], [{"참조": {**SYS, "키": sp}}], "가")
+    with store.at(world["system"]):
+        have = store.read("precombo", a)
+        assert have["문서"]["담은로직"][0]["수량"] == {"손": 1}
+        with pytest.raises(store.StoreError) as e:
+            store.write(
+                "precombo",
+                a,
+                have["판"],
+                {
+                    **have["문서"],
+                    "담은로직": [*have["문서"]["담은로직"], {"참조": {**SYS, "키": a}}],
+                },
+            )
+    assert e.value.status == 422 and "자기 자신" in e.value.detail
+
+
+def test_서고_구분_상세구분_연결_승격은_원_로직_사전조합은_고른_값_옛_문서는_읽을_때(world):
+    import M01_MasterData.M01_MasterData_Store as m01
+
+    row = m01.loaded()[1].logic(TEN)
+    sp = _promote(world["system"], 구분="틀림", 상세구분="틀림", 연결={"로직": "x"})
+    doc = _read(world["system"], "promote", sp)
+    assert row["구분"] and row["상세구분"]
+    assert (doc["구분"], doc["상세구분"]) == (row["구분"], row["상세구분"])  # 화면 값 안 받음
+    assert doc["연결"] == {"로직": TEN, "출처": row.get("출처") or ""}
+    sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}}])
+    assert (_read(world["system"], "precombo", sc)["구분"], "") == ("", "")
+    with store.at(world["system"]):
+        have = store.read("precombo", sc)
+        store.write("precombo", sc, have["판"], {**have["문서"], "구분": " 가 ", "상세구분": "나"})
+    got = _read(world["system"], "precombo", sc)
+    assert (got["구분"], got["상세구분"]) == ("가", "나")
+    # 옛 문서(칸 없음) — 승격은 원 로직 것 · 사전조합은 빈 글
+    old = {k: v for k, v in doc.items() if k not in ("구분", "상세구분", "연결")}
+    (world["system"] / "promote" / f"{sp}.json").write_text(json.dumps(old), encoding="utf-8")
+    assert refs.filled("promote", old)["연결"] == doc["연결"]
+    assert refs.filled("precombo", {"담은로직": []})["구분"] == ""
+    rows = [{"종류": "promote", "이름": sp}, {"종류": "precombo", "이름": sc}]
+    refs.summaries(world["system"], rows)
+    assert (rows[0]["구분"], rows[0]["상세구분"]) == (row["구분"], row["상세구분"])
+    assert (rows[1]["구분"], rows[1]["상세구분"], rows[1]["연결"]) == ("가", "나", None)
diff --git a/resources/tester/test_m02_labor_tree.py b/resources/tester/test_m02_labor_tree.py
index 4675902fc..ff2f7bb97 100644
--- a/resources/tester/test_m02_labor_tree.py
+++ b/resources/tester/test_m02_labor_tree.py
@@ -46,7 +46,7 @@ def test_좌측_하위_컨테이너와_전체_항목_길_없음():
     assert "buildAllItems" not in page and "onAll" not in page and "ALL_TITLE" not in page
     assert "buildAllItems" not in _text("M02_MasterTemplete_ItemList.ts")
     api = _text("M02_MasterTemplete_Api_Fetch.ts")
-    assert '| "labor";' in api and "일위대가번: string;" in api
+    assert '| "labor" |' in api and "일위대가번: string;" in api
     locale = (ROOT / "ui_template" / "ui_template_locale_m2.ts").read_text("utf-8")
     for gone in ("M02_ItemsAll", "M02_KindLabor", "M02_KindStructure", "M02_KindArea"):
         assert gone not in locale, gone
@@ -57,7 +57,9 @@ def test_좌측_하위_컨테이너와_전체_항목_길_없음():
 
 def test_층_단추는_구조물_조합_한_벌():
     page = _text("M02_MasterTemplete_UI_Page.ts")
-    assert page.count('layerBar("') == 1  # 구조물 조합 줄 아래 하나
+    # 구조물 조합 줄 아래 하나 + 일위대가 조합 서고(50-3) 하나
+    assert page.count('layerBar("') == 2
+    assert 'layerBar("일위대가조합", null, () => undefined)' in page
     assert 'layerBar("구조물조합", tree.add, () => void main.openTable(layer)),' in page
 
 
diff --git a/resources/tester/test_m02_layer_screen.py b/resources/tester/test_m02_layer_screen.py
index 17fcd6f02..963adb174 100644
--- a/resources/tester/test_m02_layer_screen.py
+++ b/resources/tester/test_m02_layer_screen.py
@@ -87,7 +87,7 @@ def test_주소_인자를_라우트에서_뗌():
     # 진입 해시 `?open=&root=&owner=`(PLAN 27-1d) · 옛 `?layer=` 도 root 로
     assert 'query.get("root") ?? query.get("layer")' in layer
     assert 'raw === "company" || raw === "personal" ? raw : "master"' in layer
-    assert '["구조물조합", "옵션", "도면"]' in layer  # 일위대가 = 구조물 조합 안(44-7)
+    assert '["구조물조합", "옵션", "도면", "일위대가조합"]' in layer  # 일위대가 조합 서고 = 50-3
     picker = _text(ROOT / "ui_template" / "ui_template_item_picker.ts")
     assert 'open: "구조물조합", root: "personal"' in picker and "layer=personal" not in picker
 
@@ -304,13 +304,17 @@ def test_구조물_조합_제목_줄_새_항목():
     구조물 조합일 때만 보임) · 누르면 나무 「항목 추가」와 같은 창(고른 폴더 안 · 없으면 맨 위)."""
     main = _text(M02 / "M02_MasterTemplete_UI_Main.ts")
     assert "export function newItemButton(" in main and 'classList.add("m02-main__new")' in main
-    assert (
-        "children: [back, title, slot, reload, save, ...(extras.newItem ? [extras.newItem] : [])]"
-        in main
+    assert re.search(
+        r"children: \[\s*back,\s*title,\s*helpSlot,\s*slot,\s*reload,\s*save,"
+        r"\s*\.\.\.\(extras\.newItem \? \[extras\.newItem\] : \[\]\),?\s*\]",
+        main,
     )
     assert "if (extras.newItem) extras.newItem.hidden = !combo;" in main
     page = _text(M02 / "M02_MasterTemplete_UI_Page.ts")
-    assert "...(canEdit(layer, isAdmin) ? { newItem: newItemButton(() => void openNew()) } : {})" in page
+    assert (
+        "...(canEdit(layer, isAdmin) ? { newItem: newItemButton(() => void openNew()) } : {})"
+        in page
+    )
     panel = _text(M02 / "M02_MasterTemplete_TreePanel.ts")
     assert 'return at?.kind === "folder" ? at.path : [];' in panel  # 고른 폴더(39-5 folder())
     assert "const newItem = (): void => void addItem(folder());" in panel
diff --git a/resources/tester/test_m02_so_def_model.py b/resources/tester/test_m02_so_def_model.py
new file mode 100644
index 000000000..6670f0937
--- /dev/null
+++ b/resources/tester/test_m02_so_def_model.py
@@ -0,0 +1,87 @@
+"""M02 구조물 정의 편집 화면 자료 손질(`M02_SO_Def_Model.ts` · PLAN 48-2) 단위검증.
+
+프론트에 JS 테스트 러너가 없어 Node 헬퍼(`helper_m02_so_def_model.cjs`)가 TS 를 트랜스파일해 돌리고
+pytest 는 그 결과(JSON)를 판정.
+
+못박는 것
+  - 배치 격자: 안 정한 옵션은 차례대로 · 정한 자리 먼저 · 너비 ≤ 칸 수 · 안 씀 빠짐 · 겹침 찾음.
+  - 규칙: 없는 값 · 자기 자신 · 없는 하위 선택지 · 그러면 비었음 · 좁힌 선택지 밖 기본값은 틀린 줄
+    (서버 `M02_SO_Definition._rule_errors` 와 같은 뜻) · 고르기 아닌 상위는 값 검사 안 함.
+  - 저장 전 검사: 깨끗한 정의 = 빈 목록 · 이름 겹침 · 배치 겹침 · 빈 선택지 = 까닭 글.
+  - 선택지 이름 바꿈 · 뺌은 그 옵션 기본값 · 같은 종류 규칙도 같이 고침.
+  - 순서: 구조물군 = 키 차례 · 종류 = 같은 군 안에서만.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+HERE = Path(__file__).resolve().parent
+
+
+@pytest.fixture(scope="module")
+def r() -> dict:
+    proc = subprocess.run(
+        ["node", str(HERE / "helper_m02_so_def_model.cjs")],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def test_배치_자동_채움(r) -> None:
+    assert r["auto"] == {
+        "a": {"줄": 1, "칸": 1, "너비": 1},
+        "b": {"줄": 1, "칸": 2, "너비": 1},
+        "c": {"줄": 2, "칸": 1, "너비": 1},
+    }
+
+
+def test_배치_정한_자리_먼저_너비는_칸수까지(r) -> None:
+    assert r["fixed"]["c"] == {"줄": 1, "칸": 1, "너비": 2}
+    assert r["fixed"]["a"] == {"줄": 2, "칸": 1, "너비": 1}
+    assert r["fixed"]["b"] == {"줄": 2, "칸": 2, "너비": 1}
+
+
+def test_안씀은_격자에서_빠짐(r) -> None:
+    assert set(r["off"]) == {"b", "c"}
+    assert r["off"]["b"] == {"줄": 1, "칸": 1, "너비": 1}
+
+
+def test_겹침(r) -> None:
+    assert r["overlap"] == ["a", "b"]
+
+
+def test_규칙_틀린_줄(r) -> None:
+    assert r["rules"] == [False, True, True, True, True, False, True]
+
+
+def test_이름_검사(r) -> None:
+    assert r["names"] == ["(빈 이름)", "가"]
+
+
+def test_저장_전_검사(r) -> None:
+    assert r["clean"] == []
+    assert any("옵션 이름" in t for t in r["broken"])
+    assert any("배치 겹침" in t for t in r["broken"])
+    assert any("선택지가 있어야" in t for t in r["broken"])
+
+
+def test_선택지_이름_바꿈_뺌은_기본값_규칙도_같이(r) -> None:
+    assert r["rename"] == [["엑스", "y"], "엑스", ["엑스", "y"], ["피"], "피"]
+    assert r["drop"] == [["q"], [], False]
+
+
+def test_순서_기준측점_새키(r) -> None:
+    assert r["family"] == [False, True, ["B", "A"]]
+    assert r["type"] == [False, True, ["k2", "k1", "k3"]]
+    assert r["base"] == [True, False]
+    assert r["step"] == [False, True, [2, 1, 3]]
+    assert r["newKey"] == [True, True]
diff --git a/resources/tester/test_m02_structure_def_screen.py b/resources/tester/test_m02_structure_def_screen.py
new file mode 100644
index 000000000..c344372c5
--- /dev/null
+++ b/resources/tester/test_m02_structure_def_screen.py
@@ -0,0 +1,123 @@
+"""M02 구조물 정의 편집 화면(PLAN 48-2) — 지난 판 길 · 화면이 보내는 꼴을 서버가 받음.
+
+못박는 것
+  - 지난 판 목록 `[{판, 저장일}]` 새 판부터 · 한 벌 읽기 · 없는 판 404 · 읽기는 누구나.
+  - 화면이 고친 정의(이름 · 순서 · 안 씀 · 기준측점 · 선택지 이름 · 배치 · 그룹 형상 · 규칙)를
+    그대로 PUT 하면 판 +1 · 같은 값으로 다시 읽힘.
+  - 시스템 관리자 아니면 PUT 403(화면은 읽기만).
+  - 마스터 정본은 안 씀(사본).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from B05_Profile import B05_Profile_Structures_Schema as schema
+from common_util.common_util_auth import verify_session
+from M02_MasterTemplete.StructOptions.M02_SO_Router import read_router
+
+URL = "/api/m02/structure-definition"
+ADMIN = {"role": "SYSTEM_ADMIN", "user_id": 1}
+USER = {"role": "USER", "user_id": 2, "company_id": 1}
+
+
+@pytest.fixture
+def copy(tmp_path: Path, monkeypatch) -> Path:
+    path = tmp_path / "구조물정의.json"
+    path.write_text(Path(schema.DEFINITION_PATH).read_text("utf-8"), "utf-8")
+    monkeypatch.setattr(schema, "DEFINITION_PATH", str(path))
+    return path
+
+
+def _client(session: dict) -> TestClient:
+    app = FastAPI()
+    app.include_router(read_router)
+    app.dependency_overrides[verify_session] = lambda: session
+    return TestClient(app)
+
+
+def _screen_edit(doc: dict) -> dict:
+    """화면이 하는 고침 한 벌 — `M02_SO_Def*.ts` 가 만드는 꼴 그대로."""
+    pipe = next(t for t in doc["types"] if t["type_id"] == "pipe")
+    pipe["name"] = "배수관(고침)"
+    kind = next(o for o in pipe["options"] if o["key"] == "pipe_kind")
+    kind["label"] = "관 종류"
+    kind["choices"] = ["흄관(고침)" if c == "흄관" else c for c in kind["choices"]]
+    pipe["options"].append(
+        {
+            "key": "opt_ab12cd",
+            "label": "새 옵션 1",
+            "input": "select",
+            "choices": ["새 선택지 1", "새 선택지 2"],
+            "default": None,
+        }
+    )
+    pipe["options"][1]["enabled"] = False  # 안 씀
+    first = list(doc["구조물군"])
+    doc["구조물군"] = {k: doc["구조물군"][k] for k in [first[1], first[0], *first[2:]]}
+    doc["종류"].setdefault("pipe", {})["기준측점"] = False
+    doc["배치"]["pipe"] = {"pipe_kind": {"줄": 1, "칸": 1, "너비": 2}}
+    doc["표시"]["pipe"] = {"inlet_type": False}
+    doc["그룹"]["pipe"][1]["형상"] = {
+        "길이": {"받기": True, "뜻": "유입 보호공 연장"},
+        "높이": {"받기": False, "뜻": ""},
+    }
+    doc["규칙"] = [
+        {
+            "종류": "pipe",
+            "만약": {"옵션": "pipe_kind", "값들": ["흄관(고침)"]},
+            "그러면": {"옵션": "opt_ab12cd", "선택지": ["새 선택지 2"], "기본값": "새 선택지 2"},
+        },
+        {
+            "종류": "pipe",
+            "만약": {"옵션": "inlet_type", "값들": ["집수정"]},
+            "그러면": {"옵션": "opt_ab12cd", "보이기": False},
+        },
+    ]
+    return doc
+
+
+def test_화면_고침을_그대로_받아_판_더하기_1_지난_판_길(copy) -> None:
+    admin = _client(ADMIN)
+    doc = admin.get(URL).json()
+    assert admin.get(f"{URL}/history").json() == []
+    sent = _screen_edit(json.loads(json.dumps(doc)))
+    res = admin.put(URL, json={"판": doc["판"], "정의": sent})
+    assert res.status_code == 200, res.text
+    got = res.json()
+    assert got["판"] == doc["판"] + 1
+    for key in ("구조물군", "종류", "배치", "표시", "그룹", "규칙", "types"):
+        assert got[key] == sent[key], key
+    assert list(got["구조물군"]) == list(sent["구조물군"])  # 순서 그대로
+    rows = admin.get(f"{URL}/history").json()
+    assert [r["판"] for r in rows] == [doc["판"]] and len(rows[0]["저장일"]) == 16
+    old = admin.get(f"{URL}/history/{doc['판']}").json()
+    assert old == doc
+    assert admin.get(f"{URL}/history/999").status_code == 404
+
+
+def test_지난_판은_누구나_읽고_쓰기는_시스템_관리자만(copy) -> None:
+    user = _client(USER)
+    doc = user.get(URL).json()
+    assert user.get(f"{URL}/history").status_code == 200
+    assert user.put(URL, json={"판": doc["판"], "정의": _screen_edit(doc)}).status_code == 403
+    assert json.loads(copy.read_text("utf-8"))["판"] == doc["판"]
+
+
+def test_화면이_못_거른_틀린_규칙은_422_안_씀(copy) -> None:
+    admin = _client(ADMIN)
+    doc = admin.get(URL).json()
+    doc["규칙"] = [
+        {
+            "종류": "pipe",
+            "만약": {"옵션": "pipe_kind", "값들": ["없음"]},
+            "그러면": {"옵션": "inlet_type"},
+        }
+    ]
+    assert admin.put(URL, json={"판": doc["판"], "정의": doc}).status_code == 422
+    assert json.loads(copy.read_text("utf-8"))["판"] == doc["판"]
diff --git a/resources/tester/test_m02_structure_definition.py b/resources/tester/test_m02_structure_definition.py
new file mode 100644
index 000000000..d4df44197
--- /dev/null
+++ b/resources/tester/test_m02_structure_definition.py
@@ -0,0 +1,158 @@
+"""M02 구조물 정의 한 벌(`/api/m02/structure-definition` · PLAN 48-1).
+
+못박는 것
+  - 판 1 = 옛 레지스트리 그대로 옮김(37종 · 옵션 235 · 키 그대로) · 검사 통과.
+  - 읽기 = 로그인 누구나 · 쓰기 = 시스템 관리자만(403).
+  - 저장마다 판 +1 · 앞 판은 `구조물정의_이력/판_N.json` · 낡은 판 409 · 틀린 정의 422(안 씀).
+  - 검사 = 키 겹침 · 꼴 · 규칙 대상 있음 · 그룹 형상.
+  - 저장한 정의를 `/structure-types` 가 바로 읽음 · 프로젝트 저장에 정의 판 · 없는 키 값 보존.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from B05_Profile import B05_Profile_Structures_Schema as schema
+from B05_Profile.B05_Profile_Structures_Repository import load_structures, save_structures
+from B05_Profile.B05_Profile_Structures_Router import router as b05_router
+from B05_Profile.B05_Profile_Structures_Schema import StructureInstance, load_structure_types
+from common_util.common_util_auth import verify_session
+from M02_MasterTemplete.StructOptions import M02_SO_Definition as definition
+from M02_MasterTemplete.StructOptions.M02_SO_Router import read_router
+
+URL = "/api/m02/structure-definition"
+TYPES = "/api/projects/structure-types"
+ADMIN = {"role": "SYSTEM_ADMIN", "user_id": 1}
+USER = {"role": "USER", "user_id": 2, "company_id": 1}
+
+
+@pytest.fixture
+def copy(tmp_path: Path, monkeypatch) -> Path:
+    """정의 사본 — 마스터 정본은 안 씀."""
+    path = tmp_path / "구조물정의.json"
+    path.write_text(Path(schema.DEFINITION_PATH).read_text("utf-8"), "utf-8")
+    monkeypatch.setattr(schema, "DEFINITION_PATH", str(path))
+    return path
+
+
+def _client(session: dict) -> TestClient:
+    app = FastAPI()
+    app.include_router(read_router)
+    app.include_router(b05_router)
+    app.dependency_overrides[verify_session] = lambda: session
+    return TestClient(app)
+
+
+def test_판1_은_옛_레지스트리_그대로_검사_통과() -> None:
+    doc = definition.read()
+    assert doc["판"] == 1 and len(doc["types"]) == 37
+    assert sum(len(t["options"]) for t in doc["types"]) == 235
+    assert len(load_structure_types()) == 37
+    assert sum(len(t.options) for t in load_structure_types()) == 235
+    assert definition.check(doc) == []
+    assert [g["이름"] for g in doc["그룹"]["pipe"]] == ["관", "관 보호공(유입)", "관 보호공(유출)"]
+    assert {t["group"] for t in doc["types"]} <= set(doc["구조물군"])
+
+
+def test_읽기는_누구나_쓰기는_시스템_관리자만(copy) -> None:
+    user = _client(USER)
+    got = user.get(URL)
+    assert got.status_code == 200 and got.json()["판"] == 1
+    assert user.put(URL, json={"판": 1, "정의": got.json()}).status_code == 403
+    assert json.loads(copy.read_text("utf-8"))["판"] == 1  # 안 씀
+
+
+def test_저장마다_판_더하기_1_앞_판은_이력_structure_types_가_바로_읽음(copy) -> None:
+    admin = _client(ADMIN)
+    doc = admin.get(URL).json()
+    tid = doc["types"][0]["type_id"]
+    doc["types"][0]["name"] = "이름 바꿈"
+    res = admin.put(URL, json={"판": 1, "정의": doc})
+    assert res.status_code == 200, res.text
+    assert res.json()["판"] == 2
+    old = json.loads((copy.parent / "구조물정의_이력" / "판_1.json").read_text("utf-8"))
+    assert old["판"] == 1 and old["types"][0]["name"] != "이름 바꿈"
+    seen = {t["type_id"]: t for t in admin.get(TYPES).json()["types"]}
+    assert seen[tid]["name"] == "이름 바꿈" and len(seen) == 37
+    assert admin.put(URL, json={"판": 1, "정의": doc}).status_code == 409  # 낡은 판
+    assert admin.put(URL, json={"판": 2, "정의": res.json()}).json()["판"] == 3
+    assert (copy.parent / "구조물정의_이력" / "판_2.json").is_file()
+
+
+def _rule(doc: dict) -> tuple[str, dict, dict]:
+    """고르기 옵션 둘 이상 가진 종류 — (종류 키, 상위 옵션, 하위 옵션)."""
+    for t in doc["types"]:
+        picks = [o for o in t["options"] if o["input"] == "select"]
+        if len(picks) >= 2:
+            return t["type_id"], picks[0], picks[1]
+    raise AssertionError("고르기 둘인 종류 없음")
+
+
+def test_검사_키_겹침_꼴_규칙_대상_형상(copy) -> None:
+    admin = _client(ADMIN)
+    base = admin.get(URL).json()
+    tid, up, down = _rule(base)
+    good = {
+        "종류": tid,
+        "만약": {"옵션": up["key"], "값들": [up["choices"][0]]},
+        "그러면": {"옵션": down["key"], "선택지": down["choices"][:1], "보이기": True},
+    }
+    assert definition.check({**base, "규칙": [good]}) == []
+
+    def bad(**change) -> dict:
+        return json.loads(json.dumps({**base, **change}))
+
+    dup = bad()
+    dup["types"].append(dup["types"][0])  # 종류 키 겹침
+    opt_dup = bad()
+    opt_dup["types"][0]["options"].append(opt_dup["types"][0]["options"][0])  # 옵션 키 겹침
+    shape = bad()
+    shape["types"][0]["options"][0]["input"] = "날짜"  # 없는 꼴
+    cases = [
+        dup,
+        opt_dup,
+        shape,
+        bad(규칙=[{**good, "그러면": {**good["그러면"], "옵션": "없는키"}}]),  # 대상 없음
+        bad(규칙=[{**good, "종류": "없는종류"}]),
+        bad(규칙=[{**good, "만약": {"옵션": up["key"], "값들": ["없는값"]}}]),
+        bad(규칙=[{**good, "그러면": {"옵션": down["key"], "선택지": ["없는값"]}}]),
+        bad(규칙=[{**good, "그러면": {"옵션": down["key"]}}]),  # 효과 없음
+        bad(배치={tid: {up["key"]: {"줄": 0, "칸": 1}}}),
+        bad(배치={tid: {"없는키": {"줄": 1}}}),
+        bad(종류={tid: {"동작": ["없는동작"]}}),
+        bad(종류={"없는종류": {"기준측점": False}}),
+        bad(표시={tid: {"없는키": False}}),
+        bad(
+            그룹={"pipe": [{"id": "g1", "이름": "가", "옵션": [], "형상": {"폭": {"받기": True}}}]}
+        ),
+        bad(모르는칸=1),
+    ]
+    for i, doc in enumerate(cases):
+        res = admin.put(URL, json={"판": 1, "정의": doc})
+        assert res.status_code == 422, (i, res.text)
+    assert json.loads(copy.read_text("utf-8"))["판"] == 1  # 거절되면 안 씀
+    assert not (copy.parent / "구조물정의_이력").exists()
+    shaped = bad(종류={tid: {"기준측점": False}})
+    shaped["그룹"]["pipe"][0]["형상"] = {"길이": {"받기": True, "뜻": "관 길이"}}
+    assert admin.put(URL, json={"판": 1, "정의": shaped}).status_code == 200
+
+
+def test_프로젝트_저장에_정의_판_없는_키_값은_남김(copy, tmp_path) -> None:
+    root = str(tmp_path / "project")
+    item = StructureInstance.model_validate(
+        {
+            "type_id": "mirror",
+            "placement": "point",
+            "chainage_m": 10.0,
+            "options": {"지난정의키": "옛값"},
+        }
+    )
+    assert save_structures(root, [item], base_revision=0) == 1
+    raw = json.loads(Path(root, "B05_Profile", "route", "structures.json").read_text("utf-8"))
+    assert raw["definition_version"] == 1
+    assert load_structures(root)[1][0].options["지난정의키"] == "옛값"
diff --git a/resources/tester/test_m02_structure_option_groups.py b/resources/tester/test_m02_structure_option_groups.py
index 660fc9c6c..144ac9314 100644
--- a/resources/tester/test_m02_structure_option_groups.py
+++ b/resources/tester/test_m02_structure_option_groups.py
@@ -1,12 +1,11 @@
-"""M02 구조물 옵션 그룹(`/api/m02/structure-option-groups` · `구조물옵션그룹.json` · PLAN 46-2).
+"""M02 구조물 옵션 그룹(`/api/m02/structure-option-groups` · 정의 「그룹」 칸 · PLAN 46-2).
 
 못박는 것
-  - 시드 = `{}` · 파일이 없으면 그룹 없음 · `/structure-types` 종류마다 `groups: []`.
+  - 「그룹」 이 `{}` 면 그룹 없음 · `/structure-types` 종류마다 `groups: []`.
   - 저장한 그룹이 `/structure-types` `groups` 에 그대로(차례 · 이름 · 옵션) · 빈 그룹도 나감.
   - 옵션 없는 종류도 그룹을 둘 수 있음(관리 목록 `종류` 는 레지스트리 전부).
   - 없는 종류 · 키 · id 틀림 · 겹침 · 이름 빔 · 겹침 · 옵션 두 그룹은 422 · 낡은 판 409 ·
     거절되면 안 씀.
-  - 파일이 깨져도 폼 응답은 그룹 없음(죽지 않음) · 관리 화면은 500.
   - 좌측 「구조물 옵션 보이기」 는 시스템 관리자만(화면 코드).
 """
 
@@ -19,10 +18,10 @@ import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 
+from B05_Profile import B05_Profile_Structures_Schema as schema
 from B05_Profile.B05_Profile_Structures_Router import router as b05_router
 from B05_Profile.B05_Profile_Structures_Schema import load_structure_types
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
-from M02_MasterTemplete.StructOptions import M02_SO_Groups as groups
 from M02_MasterTemplete.StructOptions.M02_SO_Router import router as m02_router
 
 ROOT = Path(__file__).resolve().parents[2]
@@ -32,7 +31,12 @@ TYPES = "/api/projects/structure-types"
 
 @pytest.fixture
 def client(tmp_path: Path, monkeypatch) -> TestClient:
+    """정의 사본(표시 · 그룹 빈 칸 · 판 1)으로 — 마스터 정본은 안 씀(PLAN 48-1)."""
     monkeypatch.setattr(store, "FOLDER", tmp_path)
+    doc = json.loads(Path(schema.DEFINITION_PATH).read_text("utf-8"))
+    copy = tmp_path / "구조물정의.json"
+    copy.write_text(json.dumps({**doc, "판": 1, "표시": {}, "그룹": {}}), "utf-8")
+    monkeypatch.setattr(schema, "DEFINITION_PATH", str(copy))
     app = FastAPI()
     app.include_router(m02_router)
     app.include_router(b05_router)
@@ -48,11 +52,9 @@ def _groups(client: TestClient) -> dict[str, list[dict]]:
     return {t["type_id"]: t["groups"] for t in client.get(TYPES).json()["types"]}
 
 
-def test_시드는_빈_표_없으면_그룹_없음(client) -> None:
-    seed = ROOT / "resources/master_template/구조물옵션그룹.json"
-    assert json.loads(seed.read_text("utf-8")) == {}
+def test_빈_그룹_칸은_그룹_없음(client) -> None:
     got = client.get(URL).json()
-    assert got["판"] == "" and got["그룹"] == {}
+    assert got["판"] == "1" and got["그룹"] == {}
     assert len(got["종류"]) == len(load_structure_types())  # 옵션 없는 종류도
     assert all(v == [] for v in _groups(client).values())
 
@@ -67,7 +69,7 @@ def test_저장한_그룹이_폼_응답에_차례대로_빈_그룹도(client) ->
         ],
         empty: [{"id": "gx", "이름": "부속", "옵션": []}],
     }
-    res = client.put(URL, json={"판": "", "그룹": body})
+    res = client.put(URL, json={"판": "1", "그룹": body})
     assert res.status_code == 200, res.text
     assert res.json()["그룹"][tid][1]["이름"] == "빈 그룹"  # 앞뒤 빈칸 지움
     seen = _groups(client)
@@ -92,22 +94,18 @@ def test_틀린_그룹은_422_낡은_판은_409(client) -> None:
         {tid: [ok, {"id": "g2", "이름": "나", "옵션": [a]}]},  # 옵션 두 그룹
         {tid: {"g1": ok}},
     ):
-        assert client.put(URL, json={"판": "", "그룹": bad}).status_code == 422, bad
-    assert not (store.FOLDER / groups.FILE).exists()  # 거절되면 안 씀
-    v1 = client.put(URL, json={"판": "", "그룹": {tid: [ok]}}).json()["판"]
+        assert client.put(URL, json={"판": "1", "그룹": bad}).status_code == 422, bad
+    assert json.loads(Path(schema.DEFINITION_PATH).read_text("utf-8"))["판"] == 1  # 거절되면 안 씀
+    v1 = client.put(URL, json={"판": "1", "그룹": {tid: [ok]}}).json()["판"]
     assert client.put(URL, json={"판": "낡음", "그룹": {}}).status_code == 409
     res = client.put(URL, json={"판": v1, "그룹": {}})
     assert res.status_code == 200 and res.json()["그룹"] == {}
 
 
-def test_파일이_깨져도_폼_응답은_그룹_없음(client) -> None:
-    (store.FOLDER / groups.FILE).write_text("{깨짐", encoding="utf-8")
-    assert all(v == [] for v in _groups(client).values())
-    assert client.get(URL).status_code == 500
-
-
-def test_좌측_옵션_보이기는_시스템_관리자만() -> None:
+def test_좌측_정의_줄은_시스템_층에_늘_고쳐_씀은_시스템_관리자만() -> None:
+    """PLAN 48-2 — 다른 역할은 읽기만(화면이 칸을 잠금 · 서버 PUT 403)."""
     side = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts").read_text("utf-8")
-    assert "옵션: canEdit(layer, opt.isAdmin) ? section(options.title, options.body) : null" in side
-    ui = (ROOT / "M02_MasterTemplete/StructOptions/M02_SO_Options.ts").read_text("utf-8")
-    assert "buildGroupBlock(" in ui and "buildPlaceSelect(" in ui
+    assert "옵션: section(options.title, options.body)," in side
+    folder = ROOT / "M02_MasterTemplete/StructOptions"
+    assert "buildGroupBlock(" in (folder / "M02_SO_Def.ts").read_text("utf-8")
+    assert "buildPlaceSelect(" in (folder / "M02_SO_Def_Options.ts").read_text("utf-8")
diff --git a/resources/tester/test_m02_structure_options.py b/resources/tester/test_m02_structure_options.py
index 670c84f23..0bf9bd334 100644
--- a/resources/tester/test_m02_structure_options.py
+++ b/resources/tester/test_m02_structure_options.py
@@ -1,10 +1,9 @@
-"""M02 구조물 옵션 보이기(`/api/m02/structure-options` · 정본 `구조물옵션표시.json`).
+"""M02 구조물 옵션 보이기(`/api/m02/structure-options` · 정의 「표시」 칸 · PLAN 48-1).
 
 못박는 것
-  - 파일이 없거나 `{}` 면 `GET /api/projects/structure-types` 옵션이 모두 visible.
+  - 「표시」 가 `{}` 면 `GET /api/projects/structure-types` 옵션이 모두 visible.
   - 저장한 숨김이 그 응답 visible 에 반영 · 다른 종류 · 옵션은 그대로 · 옵션 정의는 안 바뀜.
   - 저장은 숨김(false)만 남김 · [모두 보임] = `{}` · 없는 종류 · 키 · 참거짓 아님 422 · 낡은 판 409.
-  - 파일이 깨져도 폼 응답은 모두 보임(죽지 않음).
 """
 
 from __future__ import annotations
@@ -16,10 +15,10 @@ import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 
+from B05_Profile import B05_Profile_Structures_Schema as schema
 from B05_Profile.B05_Profile_Structures_Router import router as b05_router
 from B05_Profile.B05_Profile_Structures_Schema import load_structure_types
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
-from M02_MasterTemplete.StructOptions import M02_SO_Options as opt
 from M02_MasterTemplete.StructOptions.M02_SO_Router import router as m02_router
 
 ROOT = Path(__file__).resolve().parents[2]
@@ -33,7 +32,12 @@ def structure_type(type_id):
 
 @pytest.fixture
 def client(tmp_path: Path, monkeypatch) -> TestClient:
+    """정의 사본(표시 · 그룹 빈 칸 · 판 1)으로 — 마스터 정본은 안 씀(PLAN 48-1)."""
     monkeypatch.setattr(store, "FOLDER", tmp_path)
+    doc = json.loads(Path(schema.DEFINITION_PATH).read_text("utf-8"))
+    copy = tmp_path / "구조물정의.json"
+    copy.write_text(json.dumps({**doc, "판": 1, "표시": {}, "그룹": {}}), "utf-8")
+    monkeypatch.setattr(schema, "DEFINITION_PATH", str(copy))
     app = FastAPI()
     app.include_router(m02_router)
     app.include_router(b05_router)
@@ -51,13 +55,9 @@ def _visible(client: TestClient) -> dict[str, dict[str, bool]]:
     return {t["type_id"]: {o["key"]: o["visible"] for o in t["options"]} for t in types}
 
 
-def test_시드_파일은_빈_표이고_없어도_모두_보임(client) -> None:
-    assert (
-        json.loads((ROOT / "resources/master_template/구조물옵션표시.json").read_text("utf-8"))
-        == {}
-    )
+def test_빈_표시는_모두_보임(client) -> None:
     got = client.get(URL).json()
-    assert got["판"] == "" and got["표시"] == {}  # 파일 없음
+    assert got["판"] == "1" and got["표시"] == {}
     assert all(all(v.values()) for v in _visible(client).values())
     assert client.get(TYPES).json()["schema_version"] == 1
 
@@ -65,7 +65,7 @@ def test_시드_파일은_빈_표이고_없어도_모두_보임(client) -> None:
 def test_숨김을_저장하면_폼_응답에_반영_정의는_그대로(client) -> None:
     tid, off, on = _pick()
     before = client.get(TYPES).json()["types"]
-    res = client.put(URL, json={"판": "", "표시": {tid: {off: False, on: True}}})
+    res = client.put(URL, json={"판": "1", "표시": {tid: {off: False, on: True}}})
     assert res.status_code == 200, res.text
     assert res.json()["표시"] == {tid: {off: False}}  # 숨김만 남김
     seen = _visible(client)
@@ -83,10 +83,10 @@ def test_숨김을_저장하면_폼_응답에_반영_정의는_그대로(client)
 
 def test_모두_보임은_빈_표_판은_저장마다_바뀜(client) -> None:
     tid, off, _ = _pick()
-    v1 = client.put(URL, json={"판": "", "표시": {tid: {off: False}}}).json()["판"]
+    v1 = client.put(URL, json={"판": "1", "표시": {tid: {off: False}}}).json()["판"]
     res = client.put(URL, json={"판": v1, "표시": {}})
     assert res.status_code == 200 and res.json()["표시"] == {} and res.json()["판"] != v1
-    assert json.loads((store.FOLDER / opt.FILE).read_text("utf-8")) == {}
+    assert json.loads(Path(schema.DEFINITION_PATH).read_text("utf-8"))["표시"] == {}
     assert all(all(v.values()) for v in _visible(client).values())
 
 
@@ -98,21 +98,15 @@ def test_없는_종류_키_참거짓_아님은_422_낡은_판은_409(client) ->
         {tid: {off: "no"}},
         {tid: [off]},
     ):
-        assert client.put(URL, json={"판": "", "표시": bad}).status_code == 422, bad
-    assert client.put(URL, json={"판": "", "표시": []}).status_code == 422  # 묶음 아님(요청 모양)
-    assert not (store.FOLDER / opt.FILE).exists()  # 거절되면 안 씀
-    v1 = client.put(URL, json={"판": "", "표시": {tid: {off: False}}}).json()["판"]
+        assert client.put(URL, json={"판": "1", "표시": bad}).status_code == 422, bad
+    assert client.put(URL, json={"판": "1", "표시": []}).status_code == 422  # 묶음 아님(요청 모양)
+    assert json.loads(Path(schema.DEFINITION_PATH).read_text("utf-8"))["판"] == 1  # 거절되면 안 씀
+    v1 = client.put(URL, json={"판": "1", "표시": {tid: {off: False}}}).json()["판"]
     assert client.put(URL, json={"판": "낡음", "표시": {}}).status_code == 409
-    assert client.put(URL, json={"판": "", "표시": {}}).status_code == 409  # 처음 판으로 또 쓰기
+    assert client.put(URL, json={"판": "1", "표시": {}}).status_code == 409  # 처음 판으로 또 쓰기
     assert client.get(URL).json()["판"] == v1
 
 
-def test_파일이_깨져도_폼_응답은_모두_보임(client) -> None:
-    (store.FOLDER / opt.FILE).write_text("{깨짐", encoding="utf-8")
-    assert all(all(v.values()) for v in _visible(client).values())
-    assert client.get(URL).status_code == 500  # 관리 화면은 까닭을 그대로 올림
-
-
 def test_좌측_줄은_구조물_집계_양식_아래_한_줄_같은_한_곳에서_지움() -> None:
     side = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts").read_text("utf-8")
     assert "section(options.title, options.body)" in side
@@ -129,12 +123,10 @@ def test_좌측_줄은_구조물_집계_양식_아래_한_줄_같은_한_곳에
     assert "matset" not in side
     paint = side.split("function paint(): void {")[1].split("\n  }\n")[0]
     assert "if (opt.getOpen()) options.clear();" in paint  # 양식을 열면 이 줄 고름 지움
+    # 화면은 정의 한 벌로 읽고 씀(PLAN 48-2) · 보이기 체크는 정의 화면 옵션 줄
     api = (ROOT / "M02_MasterTemplete/StructOptions/M02_SO_Api.ts").read_text("utf-8")
-    assert (
-        'call("/layers/system/structure-options")' in api
-        and 'call("/structure-options", { method: "PUT"' in api
-    )
-    ui = (ROOT / "M02_MasterTemplete/StructOptions/M02_SO_Options.ts").read_text("utf-8")
+    assert 'call("/structure-definition")' in api
+    ui = (ROOT / "M02_MasterTemplete/StructOptions/M02_SO_Def_Options.ts").read_text("utf-8")
     assert 'o.phase === "detail"' in ui  # B06 전용 표시
 
 
@@ -165,7 +157,7 @@ def test_숨긴_옵션은_필수_아님_저장이_안_막힘(client, tmp_path, m
     root = str(tmp_path / "project")
     with pytest.raises(ValueError, match="필수"):
         repo.save_structures(root, [item({})], base_revision=0)  # 보임 = 필수 그대로
-    (store.FOLDER / opt.FILE).write_text('{"fake_hide": {"a": false}}', encoding="utf-8")
+    monkeypatch.setattr(repo, "hidden_keys", lambda: {"fake_hide": {"a"}})
     with pytest.raises(ValueError, match="필수"):  # a 는 숨겨 통과 · b 는 여전히 필수
         repo.save_structures(root, [item({})], base_revision=0)
     assert (
diff --git a/resources/tester/test_m02_structure_panel.py b/resources/tester/test_m02_structure_panel.py
index 1ac3f4d7b..f2771090c 100644
--- a/resources/tester/test_m02_structure_panel.py
+++ b/resources/tester/test_m02_structure_panel.py
@@ -77,7 +77,10 @@ def test_sub2_가_부르는_이름과_모양():
         r"interface StructureNumbers \{\s*도번: string;\s*면적번: string;\s*/\*\* 일위대가[^*]*\*/\s*일위대가번: string;\s*\}",
         body,
     )
-    assert re.search(r'export type Kind = [^;]*"area" \| "labor";', body)  # 재료산출 없앰
+    assert re.search(r'export type Kind = [^;]*"area" \| "labor"', body)  # 재료산출 없앰
+    assert '"material"' not in re.search(r"export type Kind = [^;]*;", body).group(
+        0
+    )  # 50-3 서고 종류 더함
 
 
 def test_집계표만_컨테이너를_붙임():
@@ -211,7 +214,8 @@ def test_표_도구_막대에_줄_더하기_줄_지우기_손_입력_열_없음(
 
 def test_상세_화면_돌아가기는_집계표로_그_열_고른_채():
     main = _text(MAIN)
-    assert "children: [back, title, slot, reload, save, " in main  # M01 꼴 — 제목 앞(39-5)
+    # M01 꼴 — 제목 앞(39-5) · 49-7 [?] 칸(helpSlot)이 제목 바로 뒤
+    assert re.search(r"children: \[\s*back,\s*title,\s*helpSlot,\s*slot,\s*reload,\s*save,", main)
     assert "!(sel.kind in NUMBER_FIELD)" in main  # 구조물 도면 · 일위대가 · 면적산출만
     body = main.split('back.addEventListener("click"')[1]
     assert "confirmLeave()" in body and "STRUCTURE_TABLE" in body
diff --git a/resources/tester/ui_checks/43-4_일위대가_카드.js b/resources/tester/ui_checks/43-4_일위대가_카드.js
index bc992ab31..10c6db239 100644
--- a/resources/tester/ui_checks/43-4_일위대가_카드.js
+++ b/resources/tester/ui_checks/43-4_일위대가_카드.js
@@ -4,7 +4,7 @@
  * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌 · 20초 안 — 길면 ORCA 가 끊음)
  * 기대 수치:
  *   - sections = ["단가산출 로직", "자재목록"] · diagram = 0 · info = 0(단위 · 본뜬 칸 없음)
- *   - addLogic = 0 · up = down = 0 · remove = 로직 줄 수 · addMat = 1 · rows = 담은 로직 수(item1 = 14)
+ *   - addLogic = 0 · up = down = 0 · remove = 로직 줄 수 · addMat = 0(49-6) · rows = 담은 로직 수(item1 = 14)
  *   - money2 = true(금액 칸이 두 줄 — 위 기준 · 아래 반영)
  *   - scroll.overflowX = "auto" · scroll.wide = 참(item1 표 ≈ 870px > 카드 ≈ 310px · 표 감싸개 안 가로 스크롤)
  *   - rowModal = 「넣을 값 — …」 · qtyModal = 모달 뜸(수량 · 43-1) · 둘 다 닫기 뒤 dirty = false
diff --git a/resources/tester/ui_checks/48-1_구조물정의_읽기.js b/resources/tester/ui_checks/48-1_구조물정의_읽기.js
new file mode 100644
index 000000000..b66fdfe35
--- /dev/null
+++ b/resources/tester/ui_checks/48-1_구조물정의_읽기.js
@@ -0,0 +1,60 @@
+/* 48-1 — 구조물 정의 한 벌(resources/master_template/구조물정의.json)로 옮긴 뒤 화면 변화 0
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?root=master) · 시스템 관리자 · 저장 안 함
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 기대 수치:
+ *   - def = { 판 ≥ 1, types: 37, options: 235 }(GET /api/m02/structure-definition)
+ *   - types = { types: 37, options: 235, visibleAll: true, pipeGroups: ["관", "관 보호공(유입)", "관 보호공(유출)"] }
+ *     (GET /api/projects/structure-types — 옛 꼴 그대로)
+ *   - 좌측 「구조물 옵션 정의」 → 종류 단추 kinds = 37(옵션 없는 종류도 · 48-2 정의 화면)
+ *     · pipe 단추에 그룹 표지 「3」
+ */
+(async () => {
+  const W = (ms) => new Promise((r) => setTimeout(r, ms));
+  const $ = (s, root = document) => root.querySelector(s);
+  const $$ = (s, root = document) => [...root.querySelectorAll(s)];
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await W(150);
+    }
+    return null;
+  };
+  const get = async (url) => {
+    const r = await fetch(url, { credentials: "include" });
+    return r.ok ? r.json() : { status: r.status };
+  };
+  const out = {};
+  const def = await get("/api/m02/structure-definition");
+  if (!def.types) return JSON.stringify({ error: "정의 못 읽음", def });
+  out.def = {
+    판: def.판,
+    types: def.types.length,
+    options: def.types.reduce((n, t) => n + t.options.length, 0),
+  };
+  const st = await get("/api/projects/structure-types");
+  const pipe = st.types.find((t) => t.type_id === "pipe");
+  out.types = {
+    types: st.types.length,
+    options: st.types.reduce((n, t) => n + t.options.length, 0),
+    visibleAll: st.types.every((t) => t.options.every((o) => typeof o.visible === "boolean")),
+    pipeGroups: pipe.groups.map((g) => g.name),
+  };
+  const row = await until(() => $("[data-options-row]"));
+  if (!row) return JSON.stringify({ ...out, error: "정의 줄 없음" });
+  row.click();
+  await until(() => $$("[data-sod-kind]").length);
+  const kinds = $$("[data-sod-kind]");
+  out.screen = {
+    kinds: kinds.length,
+    withOptions: def.types.filter((t) => t.options.length).length,
+    pipeTag: $('[data-sod-kind="pipe"]')?.innerText.replace(/\s+/g, " ").trim() ?? null,
+  };
+  out.ok =
+    out.def.types === 37 &&
+    out.def.options === 235 &&
+    out.types.types === 37 &&
+    out.types.options === 235 &&
+    out.types.pipeGroups.length === 3;
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/48-2_M02_구조물정의_화면.js b/resources/tester/ui_checks/48-2_M02_구조물정의_화면.js
new file mode 100644
index 000000000..c5f3b47fd
--- /dev/null
+++ b/resources/tester/ui_checks/48-2_M02_구조물정의_화면.js
@@ -0,0 +1,145 @@
+/* 48-2 — M02 구조물 옵션 정의 편집 화면(군 · 종류 · 옵션 · 선택지 · 배치 격자 · 그룹 형상 · 규칙 · 지난 판)
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌 · 20초 안)
+ * 쓰는 것: 없음 — 화면 사본만 고치고 [저장] 안 누름(저장 길은 test_m02_structure_def_screen.py 가 사본으로) ·
+ *   끝에 판이 그대로인지 GET 으로 봄 · 화면을 다시 띄우면 고침은 사라짐
+ * 기대 수치:
+ *   - families = 구조물군 수 · kinds = 37 · pipe 줄 options = pipe 옵션 수 · cells = 쓰는 옵션 수 · base = true
+ *   - 이름 바꿈 → 왼쪽 단추 글 따라감 · [저장] 켜짐
+ *   - 선택지 펼침 = 3(흄관 · VR관 · 파형강관) · 「흄관」 → 「흄관X」 = 기본값 고르기에도 「흄관X」
+ *   - 너비 2 → 미리보기 span 2 · 겹치게 두면 issues 에 「배치 겹침」 · [저장] 꺼짐 · 되돌리면 사라짐
+ *   - 기준 측점 끔 → 미리보기 기준 측점 칸 0
+ *   - 그룹 형상 「길이」 켬 → 뜻 칸 열림
+ *   - [규칙 더함] → 규칙 줄 1 · 빨강 아님 · 지우기 → 0
+ *   - [지난 판] → 목록 칸(판 단추 또는 「지난 판 없음」)
+ *   - 끝 판 = 처음 판(저장 안 함)
+ */
+(async () => {
+  const W = (ms) => new Promise((r) => setTimeout(r, ms));
+  const $ = (s, root = document) => root.querySelector(s);
+  const $$ = (s, root = document) => [...root.querySelectorAll(s)];
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 120) {
+      const v = fn();
+      if (v) return v;
+      await W(120);
+    }
+    return null;
+  };
+  /** 칸 값 바꿈 — 글자 넣음(input) + 떠남(change) */
+  const put = (box, value) => {
+    box.value = value;
+    box.dispatchEvent(new Event("input", { bubbles: true }));
+    box.dispatchEvent(new Event("change", { bubbles: true }));
+  };
+  const tick = (box, on) => {
+    if (box.checked !== on) box.click();
+  };
+  const def = await (
+    await fetch("/api/m02/structure-definition", { credentials: "include" })
+  ).json();
+  if (!def.types) return JSON.stringify({ error: "정의 못 읽음" });
+  const pipe = def.types.find((t) => t.type_id === "pipe");
+  const out = { 판: def.판 };
+
+  const row = await until(() => $("[data-options-row]"));
+  if (!row) return JSON.stringify({ error: "정의 줄 없음" });
+  row.click();
+  if (!(await until(() => $$("[data-sod-kind]").length)))
+    return JSON.stringify({ error: "종류 목록 없음" });
+  out.families = [$$("[data-sod-family]").length, Object.keys(def.구조물군).length];
+  out.kinds = $$("[data-sod-kind]").length;
+  $('[data-sod-kind="pipe"]').click();
+  await until(() => $('[data-sod-option="pipe_kind"]'));
+  const liveOpts = pipe.options.filter((o) => o.enabled !== false).length;
+  out.pipe = {
+    options: [$$("[data-sod-option]").length, pipe.options.length],
+    cells: [$$("[data-sod-cell]").length, liveOpts],
+    base: !!$(".m02-sod__cell.is-base"),
+  };
+
+  // 이름 바꿈 → 왼쪽 단추 · [저장] 켜짐
+  put($("[data-sod-kind-name]"), "배수관(시험)");
+  out.rename = {
+    left: $('[data-sod-kind="pipe"]').innerText.includes("배수관(시험)"),
+    save: !$("[data-sod-save]").disabled,
+  };
+
+  // 선택지 펼침 · 이름 바꿈 → 기본값 고르기에도
+  $('[data-sod-choices="pipe_kind"]').click();
+  await until(() => $$("[data-sod-choice]").length);
+  out.choices = $$("[data-sod-choice]").map((r) => $("input", r).value);
+  put($('[data-sod-choice="흄관"] [data-sod-choice-name]'), "흄관X");
+  const defaultPick = $('[data-sod-option="pipe_kind"] [data-sod-default]');
+  out.choiceRename = [...defaultPick.options].some((o) => o.value === "흄관X");
+
+  // 배치 — 너비 2 · 겹침 · 되돌림
+  put($('[data-sod-place-row="pipe_kind"] [data-sod-width]'), "2");
+  const cell = $('[data-sod-cell="pipe_kind"]');
+  out.width2 = cell.style.gridColumn.replace(/\s+/g, " ");
+  const other = pipe.options.filter((o) => o.enabled !== false)[1].key;
+  put($(`[data-sod-place-row="${other}"] [data-sod-row]`), "1");
+  put($(`[data-sod-place-row="${other}"] [data-sod-col]`), "2");
+  out.overlap = {
+    issue: $("[data-sod-issues]").innerText.includes("배치 겹침"),
+    red: $$(".m02-sod__cell.is-bad").length,
+    saveOff: $("[data-sod-save]").disabled,
+  };
+  put($('[data-sod-place-row="pipe_kind"] [data-sod-width]'), "1");
+  out.overlapGone = !$("[data-sod-issues]").innerText.includes("배치 겹침");
+
+  // 기준 측점 끔
+  tick($("[data-sod-base]"), false);
+  out.baseOff = $$(".m02-sod__cell.is-base").length;
+
+  // 그룹 형상 「길이」 켬 → 뜻 칸 열림
+  const shape = $("[data-sog-shape]");
+  const meanBefore = $(".m02-sog__mean", shape).disabled;
+  tick($("[data-sog-shape-0]", shape), true);
+  out.shape = { before: meanBefore, after: $(".m02-sog__mean", $("[data-sog-shape]")).disabled };
+
+  // 규칙 더함 · 지우기
+  $("[data-sod-rule-add]").click();
+  const rule = await until(() => $("[data-sod-rule]"));
+  out.rule = {
+    rows: $$("[data-sod-rule]").length,
+    bad: rule.classList.contains("is-bad"),
+    top: $("[data-sod-rule-top]", rule).value,
+    target: $("[data-sod-rule-target]", rule).value,
+  };
+  [...$$("button", rule)].find((b) => b.innerText.trim() === "지우기").click();
+  out.ruleGone = $$("[data-sod-rule]").length;
+
+  // 지난 판 목록
+  $("[data-sod-history-toggle]").click();
+  await until(() => $("[data-sod-history]").children.length);
+  out.history = $("[data-sod-history]").innerText.replace(/\s+/g, " ").trim().slice(0, 80);
+
+  const after = await (
+    await fetch("/api/m02/structure-definition", { credentials: "include" })
+  ).json();
+  out.판그대로 = after.판 === def.판;
+  out.ok =
+    out.families[0] === out.families[1] &&
+    out.kinds === 37 &&
+    out.pipe.options[0] === out.pipe.options[1] &&
+    out.pipe.cells[0] === out.pipe.cells[1] &&
+    out.pipe.base &&
+    out.rename.left &&
+    out.rename.save &&
+    out.choices.length === 3 &&
+    out.choiceRename &&
+    out.width2.includes("span 2") &&
+    out.overlap.issue &&
+    out.overlap.saveOff &&
+    out.overlapGone &&
+    out.baseOff === 0 &&
+    out.shape.before === true &&
+    out.shape.after === false &&
+    out.rule.rows === 1 &&
+    !out.rule.bad &&
+    out.ruleGone === 0 &&
+    out.history.length > 0 &&
+    out.판그대로;
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/48-3_구조물배치_정의그리기.js b/resources/tester/ui_checks/48-3_구조물배치_정의그리기.js
new file mode 100644
index 000000000..1d40bb1a3
--- /dev/null
+++ b/resources/tester/ui_checks/48-3_구조물배치_정의그리기.js
@@ -0,0 +1,168 @@
+/* 48-3 · 48-4 — B05 · B06 좌측 「구조물 배치」 칸 = 구조물 정의대로 그림
+ * 시작 화면: B05 종단설계(#/b05-profile) · 구조물 목록이 있는 프로젝트 · 폼 비어 있음(아무것도 안 고름)
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌 · 60초 안)
+ * 쓰는 것: 없음 — 목록 항목은 고르고 다시 눌러 풀기만 · 정의 사본은 **메모리 안 종류 객체만** 고침
+ *   (파일 · 서버 쓰기 없음) · 끝나면 화면을 다시 읽어(reload) 사본을 버림
+ * 기대 수치:
+ *   - 판 1 전후 대조(목록 항목마다): 칸 키 차례 = 정의 옵션 차례(B05 몫 · 보임만) · 격자 = 2열 기본 ·
+ *     규칙 가림 0 · 숨긴 보기 0 · 「지난 정의 값」 상자 숨김 · 기준 측점 보임 · 선택지 밖 옛 값 0 → sameAll = true
+ *   - 정의 사본(레지스트리 종류): 이름 바꿈 · 순서(배치 줄) · 안 씀 · 선택지 줄임 · 규칙(보이기 · 선택지 · 기본값)이
+ *     칸에 그대로 → copy.* = true
+ *   - 정의 사본(배수관 · 손코딩 시설 폼): 규칙 선택지 · 기본값 · 가림 → pipe.* = true
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const sec = document.querySelector(".b05-structure-section");
+  if (!sec) return JSON.stringify({ error: "구조물 배치 칸 없음" });
+  const url = performance
+    .getEntriesByType("resource")
+    .map((e) => e.name)
+    .filter((n) => n.includes("/B05_Profile/B05_Profile_Api_Structures.ts"))
+    .pop();
+  const api = await import(url);
+  const types = await api.fetchStructureTypes(true);
+  const byId = new Map(types.map((t) => [t.type_id, t]));
+  const [groupSel, typeSel] = sec.querySelectorAll(".b05-structure__grid select");
+  const optionRow = [...sec.querySelectorAll(".b05-structure__grid")][1];
+  const vis = (n) => n && n.offsetParent !== null;
+  const facility = sec.querySelector(".b05-drainage__facility");
+  const stale = sec.querySelector(".b05-structure__stale");
+  const capture = () => {
+    const typeId = typeSel.value;
+    const t = byId.get(typeId);
+    const keys = [...optionRow.querySelectorAll("[data-option-keys]")]
+      .filter((n) => !n.classList.contains("is-rule-hidden"))
+      .map((n) => n.dataset.optionKeys);
+    const groupKeys = [...sec.querySelectorAll(".b05-structure__optgroup [data-option-keys]")].map(
+      (n) => n.dataset.optionKeys,
+    );
+    const want = t.managed_by
+      ? []
+      : t.options
+          .filter((o) => o.phase !== "detail" && o.visible !== false && o.enabled !== false)
+          .map((o) => o.key)
+          .filter((k) => !groupKeys.includes(k));
+    return {
+      typeId,
+      keysSame: JSON.stringify(keys) === JSON.stringify(want),
+      grid: optionRow.style.gridTemplateColumns === "",
+      ruleHidden: sec.querySelectorAll(".is-rule-hidden").length,
+      hiddenOptions: sec.querySelectorAll("option[hidden]").length,
+      stale: !stale.hidden,
+      anchor: !sec.querySelectorAll(".b05-structure__position-row > label")[2].hidden,
+      facility: !!t.managed_by && vis(facility),
+      // 같은 값 — 정의 선택지 밖 옛 값을 남겨 보인 칸 수(판 1 이면 0 = 옛 화면과 같은 값)
+      keptOld: [...optionRow.querySelectorAll("[data-option-keys] select")].filter((s) => {
+        const o = t.options.find(
+          (x) => x.key === s.closest("[data-option-keys]").dataset.optionKeys,
+        );
+        return s.value && o && !o.choices.includes(s.value);
+      }).length,
+    };
+  };
+  const out = { items: [], copy: {}, pipe: {} };
+  // ── 판 1 전후 대조 — 목록 항목마다 고르고 · 재고 · 다시 눌러 풂 ──
+  const items = [...document.querySelectorAll(".b05-route__irregular-list li")];
+  for (const li of items) {
+    (li.querySelector("button") ?? li).click();
+    await w(250);
+    if (typeSel.value) out.items.push(capture());
+    (li.querySelector("button") ?? li).click(); // 재선택 = 해제
+    await w(150);
+  }
+  out.count = out.items.length;
+  out.sameAll = out.items.every(
+    (r) =>
+      r.keysSame &&
+      r.grid &&
+      !r.ruleHidden &&
+      !r.hiddenOptions &&
+      !r.stale &&
+      r.anchor &&
+      !r.keptOld,
+  );
+  out.bad = out.items.filter(
+    (r) => !(r.keysSame && r.grid && !r.ruleHidden && !r.hiddenOptions && !r.stale && r.anchor),
+  );
+  // ── 정의 사본 — 레지스트리 종류(고르기 칸 둘 이상) · 새 폼에서만(저장 없음) ──
+  const pickType = (t) => {
+    groupSel.value = t.group;
+    groupSel.dispatchEvent(new Event("change", { bubbles: true }));
+    typeSel.value = t.type_id;
+    typeSel.dispatchEvent(new Event("change", { bubbles: true }));
+  };
+  // 흙막이 — 고르기 칸 하나(설치 측) + 숫자 칸 여럿
+  const reg = byId.get("soil_guard");
+  const opt = (k) => reg.options.find((o) => o.key === k);
+  const side = opt("side");
+  opt("tiers").label = "바꾼 이름";
+  opt("shift_m").enabled = false;
+  side.choices = side.choices.slice(0, 2);
+  reg.spots = { tiers: { 줄: 1, 칸: 1, 너비: 2 } };
+  reg.rules = [
+    {
+      종류: "soil_guard",
+      만약: { 옵션: "side", 값들: [side.choices[0]] },
+      그러면: { 옵션: "tiers", 기본값: 3 },
+    },
+    {
+      종류: "soil_guard",
+      만약: { 옵션: "side", 값들: [side.choices[1]] },
+      그러면: { 옵션: "lift_m", 보이기: false },
+    },
+  ];
+  pickType(reg);
+  await w(250);
+  const wrapOf = (k) => sec.querySelector(`[data-option-keys="${k}"]`);
+  const first = optionRow.querySelector("[data-option-keys]");
+  out.copy.type = reg.type_id;
+  out.copy.rename = wrapOf("tiers")?.querySelector("span")?.textContent.startsWith("바꾼 이름");
+  out.copy.order = first?.dataset.optionKeys === "tiers" && first.style.gridColumn === "1 / span 2";
+  out.copy.unused = !wrapOf("shift_m");
+  const c1 = wrapOf("side").querySelector("select");
+  out.copy.choices =
+    [...c1.children]
+      .slice(1)
+      .map((o) => o.value)
+      .join(",") === side.choices.join(",");
+  c1.value = side.choices[0];
+  c1.dispatchEvent(new Event("change", { bubbles: true }));
+  await w(100);
+  out.copy.ruleDefault = wrapOf("tiers").querySelector("input").value === "3";
+  c1.value = side.choices[1];
+  c1.dispatchEvent(new Event("change", { bubbles: true }));
+  await w(100);
+  out.copy.ruleHide = wrapOf("lift_m").classList.contains("is-rule-hidden");
+  // ── 정의 사본 — 배수관(손코딩 시설 폼 · 동작 계곡통과시설) ──
+  const pipe = byId.get("pipe");
+  pipe.rules = [
+    {
+      종류: "pipe",
+      만약: { 옵션: "pipe_kind", 값들: ["흄관"] },
+      그러면: { 옵션: "pipe_diameter_mm", 선택지: ["800", "1000"], 기본값: "800" },
+    },
+    {
+      종류: "pipe",
+      만약: { 옵션: "pipe_kind", 값들: ["VR관"] },
+      그러면: { 옵션: "wing_wall_type", 보이기: false },
+    },
+  ];
+  pickType(pipe);
+  await w(300);
+  const pk = sec.querySelector('[data-option-keys="pipe_kind"] select');
+  const pd = () => sec.querySelector('[data-option-keys="pipe_diameter_mm"] select');
+  pk.value = "흄관";
+  pk.dispatchEvent(new Event("change", { bubbles: true }));
+  await w(150);
+  out.pipe.choices = [...pd().options].filter((o) => o.value && !o.hidden).map((o) => o.value);
+  out.pipe.defaultOk = pd().value === "800";
+  pk.value = "VR관";
+  pk.dispatchEvent(new Event("change", { bubbles: true }));
+  await w(150);
+  out.pipe.wingHidden = sec
+    .querySelector('[data-option-keys="wing_wall_type"]')
+    .classList.contains("is-rule-hidden");
+  out.pipe.temp =
+    document.querySelectorAll(".b05-route__irregular-list li").length === items.length;
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/49-6_카드_자재추가_숨김.js b/resources/tester/ui_checks/49-6_카드_자재추가_숨김.js
new file mode 100644
index 000000000..5cd5c7167
--- /dev/null
+++ b/resources/tester/ui_checks/49-6_카드_자재추가_숨김.js
@@ -0,0 +1,46 @@
+/* 49-6 — 구조물 조합 일위대가 카드엔 [자재 추가] 없음 · 일위대가 상세엔 그대로
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item1(일위대가 담은 로직 있는 열)이 있음
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 기대 수치: card.addMat = 0 · card.addLogic = 0 · card.mats = 1(자재목록 구역은 있음) · detail.addMat = 1
+ * 하는 일: 카드 읽기 → 카드 [수정] 상세 읽기(저장 안 함 · item1 다시 눌러 상세에서 나옴)
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 6000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const vis = (b) => b && !b.hidden && b.offsetParent !== null;
+  const count = (root, t) =>
+    [...root.querySelectorAll("button")].filter((b) => vis(b) && b.textContent.trim() === t).length;
+  document.querySelector('[data-node="i|item1"]').click();
+  const ed = await until(() => {
+    const e = document.querySelector(".m02-struct__labor .m02-labor__edit");
+    return e && e.querySelector("tbody tr[data-labor-logic]") ? e : null;
+  });
+  if (!ed) return JSON.stringify({ error: "카드 몸 없음" });
+  const card = ed.closest(".m02-struct > *");
+  const out = {
+    card: {
+      addMat: count(card, "자재 추가"),
+      addLogic: count(card, "로직 추가"),
+      mats: [...ed.querySelectorAll(".m01-logic__section-head h3")].filter(
+        (h) => h.textContent === "자재목록",
+      ).length,
+    },
+  };
+  // 일위대가 상세 = 카드 [수정]
+  [...card.querySelectorAll(".m02-struct__card-tools button")]
+    .find((b) => b.innerText.trim() === "수정")
+    ?.click();
+  await until(() => document.querySelector(".ui-side-panels-row .m02-labor__edit"));
+  await w(300);
+  out.detail = { addMat: count(document, "자재 추가") };
+  document.querySelector('[data-node="i|item1"]')?.click();
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/49-7_상세_도움말.js b/resources/tester/ui_checks/49-7_상세_도움말.js
new file mode 100644
index 000000000..90fe7ca76
--- /dev/null
+++ b/resources/tester/ui_checks/49-7_상세_도움말.js
@@ -0,0 +1,98 @@
+/* 49-7 — 구조물 조합 상세 셋(도면 정보 · 일위대가 · 면적산출) 머리 [?] = 제목 바로 옆 · 도움말 네 절 · 카드와 같은 글
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item1(구조물 조합)이 있음
+ * 부르는 법: orca eval --page <탭> --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌 · 40초 안)
+ * 쓰는 것: 없음(누르기 · 보기만 · 도움말 상자는 닫고 끝 · 상세에서 [돌아가기])
+ * 기대 수치(상세 셋 모두):
+ *   - nextToTitle = true(? 가 제목 글 바로 다음) · headOk = true(돌아가기 · 제목 · ? 가 한 줄 · 제목 줄 안 접힘) ·
+ *     parts = ["about","keys","features","steps"] · opened = true · closed = true ·
+ *     sameText = true(설명 · 단축키 · 사용법 = 카드와 같은 글 · 기능 = 카드 줄 그대로 + 상세 줄) ·
+ *     detailOnly = 상세에만 있는 줄 이름들(도면 = 파일 불러오기 · 돌아가기 / 면적 = 도면으로 보내기 · 돌아가기 / 일위대가 = 돌아가기) · back = true
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const vis = (b) => b && !b.hidden && b.offsetParent !== null;
+  const textOf = (box, part) =>
+    [...(box?.querySelector(`[data-help-part="${part}"]`)?.children ?? [])]
+      .slice(1)
+      .map((n) => n.textContent)
+      .join("|");
+  const rows = (box, part) =>
+    [...(box?.querySelectorAll(`[data-help-part="${part}"] dt`) ?? [])].map(
+      (dt) => `${dt.textContent}=${dt.nextElementSibling?.textContent}`,
+    );
+  const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+  if (!node) return JSON.stringify({ error: "item1 없음 — 폴더를 펼쳐 둘 것" });
+  node.click();
+  await until(() => document.querySelector(".m02-struct__preview iframe"));
+  await w(2500);
+  const out = { each: [] };
+  const hash = location.hash;
+  for (let i = 0; i < 3; i++) {
+    const cards = [...document.querySelectorAll(".m02-struct > .m02-struct__card")].filter(vis);
+    const card = cards[i];
+    if (!card) return JSON.stringify({ ...out, error: `카드 ${i} 없음` });
+    const cardBox = card.querySelector(":scope > .m02-struct__keys");
+    const cardSnap = {
+      about: textOf(cardBox, "about"),
+      keys: rows(cardBox, "keys"),
+      features: rows(cardBox, "features"),
+      steps: textOf(cardBox, "steps"),
+    };
+    const edit = [...card.querySelectorAll(".m02-struct__card-tools button")].find(
+      (b) => vis(b) && b.innerText.trim() === "수정",
+    );
+    if (!edit) return JSON.stringify({ ...out, error: `카드 ${i} [수정] 없음` });
+    edit.click();
+    const head = await until(() => {
+      const h = document.querySelector(".m02-main__head");
+      return h && !h.parentElement.hidden && h.querySelector(".m02-struct__help") ? h : null;
+    }, 12000);
+    const row = { card: card.querySelector(":scope > h3").firstElementChild.textContent };
+    if (!head) {
+      out.each.push({ ...row, error: "상세 ? 없음" });
+      continue;
+    }
+    await w(800);
+    const title = head.querySelector(".m02-main__title");
+    const help = head.querySelector(".m02-struct__help");
+    const box = head.querySelector(".m02-struct__keys");
+    const back = [...head.querySelectorAll("button")].find((b) => b.innerText.trim() === "돌아가기");
+    const tb = title.getBoundingClientRect();
+    const hb = help.getBoundingClientRect();
+    row.detailTitle = title.textContent;
+    row.nextToTitle = title.nextElementSibling?.contains(help) && vis(help);
+    row.headOk = !!back && vis(back) && Math.abs(tb.top + tb.height / 2 - (hb.top + hb.height / 2)) < 24 && hb.left >= tb.right - 1 && head.getBoundingClientRect().height < 80;
+    row.parts = [...box.querySelectorAll("[data-help-part]")].map((s) => s.dataset.helpPart);
+    help.click();
+    await w(150);
+    const bb = box.getBoundingClientRect();
+    row.opened = !box.hidden && bb.width > 100 && bb.right <= window.innerWidth + 1;
+    const features = rows(box, "features");
+    row.sameText =
+      textOf(box, "about") === cardSnap.about &&
+      textOf(box, "steps") === cardSnap.steps &&
+      JSON.stringify(rows(box, "keys")) === JSON.stringify(cardSnap.keys) &&
+      JSON.stringify(features.slice(0, cardSnap.features.length)) === JSON.stringify(cardSnap.features);
+    row.detailOnly = features.slice(cardSnap.features.length).map((f) => f.split("=")[0]);
+    help.click();
+    await w(100);
+    row.closed = box.hidden;
+    out.each.push(row);
+    back?.click();
+    row.back = !!(await until(
+      () => location.hash === hash && document.querySelector(".m02-struct__card"),
+      10000,
+    ));
+    await w(1500);
+  }
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/49-8_찾기칸_없앰.js b/resources/tester/ui_checks/49-8_찾기칸_없앰.js
new file mode 100644
index 000000000..6ae4f3e93
--- /dev/null
+++ b/resources/tester/ui_checks/49-8_찾기칸_없앰.js
@@ -0,0 +1,24 @@
+/* 49-8 — M02 구조물 조합 상세: 위쪽 찾기 칸 없앰 · 제목 줄 ~ 분류 표 간격
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 기대 수치:
+ *   - search.count = 0 (상세 안 찾기 칸 없음)
+ *   - gap.px = 제목 줄 아래 ~ 분류 표(첫 표 칸) 위 간격 — 전 대비 줄어듦
+ */
+(async () => {
+  const main = document.querySelector(".m02-main");
+  const head = main?.querySelector(".m02-main__head");
+  const table = main?.querySelector(".m02-struct__sheet, .ss-root, table");
+  const searchCount = main
+    ? main.querySelectorAll(".m02-tree__search, input[type=search]").length
+    : -1;
+  const headBottom = head?.getBoundingClientRect().bottom ?? null;
+  const tableTop = table?.getBoundingClientRect().top ?? null;
+  return JSON.stringify({
+    search: { count: searchCount },
+    gap: {
+      px: headBottom !== null && tableTop !== null ? +(tableTop - headBottom).toFixed(1) : null,
+      table: table?.className || table?.tagName || null,
+    },
+  });
+})();
diff --git a/resources/tester/ui_checks/49_오른쪽패널_양식.js b/resources/tester/ui_checks/49_오른쪽패널_양식.js
new file mode 100644
index 000000000..0b38e149f
--- /dev/null
+++ b/resources/tester/ui_checks/49_오른쪽패널_양식.js
@@ -0,0 +1,194 @@
+/* 49 — 오른쪽 접는 패널 = 좌측 패널과 같은 손잡이 양식 · 패널 몸만 따로 스크롤 · M01 원문 표 칸 수 = M02
+ * 시작 화면: M01 마스터 데이터(#/m01-master-data) · 시스템 관리자 · 나무 item1(구조물 조합)이 M02 마스터 층에 있음
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌) · 저장 안 함 · 끝에 열린 패널 되돌림
+ * 하는 일: M01 로직 GC000198 상세(흐름도 · 원문) → M02 일위대가 상세(원문 · 같은 GC000198 줄) → M02 면적산출 상세(일위대가 · 도면)
+ * 기대 수치(화면마다):
+ *   - handleClass = 좌측 패널 손잡이와 같은 클래스(ui-workflow-overlay__handle ui-workflow-overlay__handle--side is-labeled)
+ *   - handles = 패널 수(M01 2 · 일위대가 1 · 면적 2) · 손잡이 x < 패널 x(왼쪽 가장자리 밖)
+ *   - steps[i].open = 누른 패널 하나만 · width 모두 같음(폭 공유) · none.open = [] · none.rootW = 0(손잡이만 남음)
+ *   - sticky.tops = [0 · 250 · 400 굴렸을 때 패널 top] — 머리띠(head) 아래 8 에 닿으면 그 자리에 멈춤(250 = 400) · 본문이 짧으면 덜 굴러감(scrolled) · inView = 패널 위아래 끝이 창 안
+ *   - ownScroll: 패널 몸을 굴리면 몸 scrollTop 만 바뀌고 본문 스크롤 그대로(mainMoved 0)
+ *   - m01Cells = m02Cells(같은 로직 GC000198 원문 표 칸 수) · 표 둘(7칸 · 2칸)
+ *   - m01Look = m02Look(sameLook true) — 같은 클래스 · 글자 크기(16px) · 표 칸 꼴 · tableFit 모두 true(표 높이 = 내용 · 자체 세로 스크롤 없음)
+ */
+(async () => {
+  const W = (ms) => new Promise((r) => setTimeout(r, ms));
+  const $ = (s, root = document) => root.querySelector(s);
+  const $$ = (s, root = document) => [...root.querySelectorAll(s)];
+  const until = async (fn, ms = 10000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await W(150);
+    }
+    return null;
+  };
+  const shown = (n) => !!n && n.getBoundingClientRect().height > 0;
+  const LEFT = "ui-workflow-overlay__handle ui-workflow-overlay__handle--side is-labeled";
+
+  /** 한 패널 묶음 — 손잡이 꼴 · 하나만 열림 · 폭 공유 · 모두 접힘 · sticky · 몸 스크롤 */
+  const check = async (sp, scrollId) => {
+    const handles = $$(".ui-side-panels__handles > button", sp);
+    const ids = handles.map((h) => h.dataset.panel);
+    const was =
+      ids.find((id) => shown($(`.ui-side-panels__panel[data-panel="${id}"]`, sp))) ?? null;
+    const box = (id) => $(`.ui-side-panels__panel[data-panel="${id}"]`, sp);
+    const state = () => ({
+      open: ids.filter((id) => shown(box(id))),
+      expanded: handles.map((h) => h.getAttribute("aria-expanded")),
+    });
+    const out = {
+      handles: handles.length,
+      handleClass: handles.every((h) => h.className === LEFT),
+      labels: handles.map((h) => h.innerText.replace(/\s/g, "")),
+      steps: [],
+    };
+    for (const h of handles) {
+      if (h.getAttribute("aria-expanded") !== "true") h.click();
+      await W(300);
+      const b = box(h.dataset.panel);
+      out.steps.push({
+        ...state(),
+        width: Math.round(b.getBoundingClientRect().width),
+        handleOutside: Math.round(b.getBoundingClientRect().left - h.getBoundingClientRect().right),
+      });
+    }
+    // sticky · 몸 스크롤 — 고른 패널을 펴고 봄
+    const pick = handles.find((h) => h.dataset.panel === scrollId);
+    if (pick.getAttribute("aria-expanded") !== "true") pick.click();
+    await W(400);
+    const panel = box(scrollId);
+    const body = $(".ui-side-panels__body", panel);
+    // 본문 스크롤 칸 — 위 칸 중 굴러가는 것 · 없으면 창 · 숨은 탭은 scroll 알림이 안 와 직접 보냄
+    let sc = null;
+    for (let n = sp.parentElement; n && !sc; n = n.parentElement) {
+      const oy = getComputedStyle(n).overflowY;
+      if ((oy === "auto" || oy === "scroll") && n.scrollHeight > n.clientHeight + 1) sc = n;
+    }
+    const roll = async (y) => {
+      if (sc) sc.scrollTop = y;
+      else window.scrollTo(0, y);
+      (sc ?? window).dispatchEvent(new Event("scroll"));
+      await W(200);
+    };
+    const pos = () => (sc ? sc.scrollTop : window.scrollY);
+    await roll(0);
+    const t0 = panel.getBoundingClientRect().top;
+    await roll(250);
+    const t1 = panel.getBoundingClientRect().top;
+    await roll(400);
+    const r1 = panel.getBoundingClientRect();
+    const head = Math.round($(".app-header").getBoundingClientRect().bottom);
+    out.sticky = {
+      scroller: sc ? sc.className.split(" ")[0] : "window",
+      scrolled: Math.round(pos()),
+      tops: [t0, t1, r1.top].map(Math.round),
+      head,
+    };
+    out.inView = Math.round(r1.bottom) <= innerHeight && Math.round(r1.top) >= 0;
+    const y = pos();
+    body.scrollTop = 0;
+    body.scrollTop = 300;
+    body.dispatchEvent(new Event("scroll"));
+    await W(150);
+    out.ownScroll = {
+      bodyOverflow: body.scrollHeight > body.clientHeight,
+      bodyTop: Math.round(body.scrollTop),
+      mainMoved: Math.round(pos() - y),
+    };
+    body.scrollTop = 0;
+    await roll(0);
+    // 모두 접힘
+    $$(".ui-side-panels__handles > button[aria-expanded=true]", sp).forEach((h) => h.click());
+    await W(300);
+    out.none = { ...state(), rootW: Math.round(sp.getBoundingClientRect().width) };
+    // 되돌림
+    if (was) handles.find((h) => h.dataset.panel === was).click();
+    await W(300);
+    out.restored = (ids.find((id) => shown(box(id))) ?? null) === was;
+    return out;
+  };
+  const cells = (root) =>
+    $$(".m01lab-src__table", root).map((t) => [...t.rows].map((r) => r.cells.length).join(","));
+  /** 원문 꼴 — 클래스 · 글자 크기 · 표 칸 꼴 · 표 감싸개 높이 = 내용(자체 세로 스크롤 없음) */
+  const look = (root) => {
+    const src = $(".m01lab-src", root);
+    const fs = (sel) => (sel ? getComputedStyle(sel).fontSize : null);
+    const td = $(".m01lab-src__table td", src);
+    return {
+      classes: [...new Set($$("*", src).map((n) => n.className.toString()))].sort().join(" "),
+      font: [fs(src), fs($(".m01lab-src__p", src)), fs($(".m01lab-src__head", src)), fs(td)],
+      td: td ? ["padding", "whiteSpace", "borderBottom"].map((k) => getComputedStyle(td)[k]) : null,
+      tableFit: $$(".m01lab-src__table", src).map((t) => {
+        const box = t.parentElement;
+        return box.scrollHeight <= box.clientHeight;
+      }),
+    };
+  };
+  const result = {};
+
+  // ① M01 로직 상세 — 흐름도 · 원문
+  sessionStorage.setItem("m01.logic.pending", "GC000198");
+  const tab = $$(".ui-collapsible__title").find((h) => h.innerText.trim() === "단가산출 로직");
+  if (!tab) return JSON.stringify({ error: "M01 화면 아님" });
+  if (!tab.closest(".ui-collapsible").classList.contains("is-collapsed")) tab.click();
+  tab.click();
+  const m01 = await until(() => $(".m01lab-side .m02-dfp") && $(".m01lab-side > .ui-side-panels"));
+  if (!m01) return JSON.stringify({ error: "M01 로직 못 엶" });
+  await W(600);
+  result.m01 = await check(m01, "source");
+  const srcHandle = $('.ui-side-panels__handles > button[data-panel="source"]', m01);
+  const m01Was = srcHandle.getAttribute("aria-expanded");
+  if (m01Was !== "true") srcHandle.click();
+  await until(() => $(".m01lab-side .m01lab-src__table"));
+  result.m01Cells = cells($(".m01lab-side"));
+  result.m01Look = look($(".m01lab-side"));
+  if (m01Was !== "true") srcHandle.click();
+
+  // ② M02 일위대가 상세 — 원문(같은 로직 줄)
+  location.hash = "#/m02-master-template?open=구조물조합&root=master";
+  const node = await until(() => $('[data-node="i|item1"]'));
+  if (!node) return JSON.stringify({ ...result, error: "item1 없음" });
+  node.click();
+  const card = await until(() =>
+    $$(".m02-struct__card").find((c) => $("table.m02-labrow tbody tr[data-labor-logic]", c)),
+  );
+  $$(".m02-struct__card-tools button", card)
+    .find((b) => b.innerText.trim() === "수정")
+    ?.click();
+  const row = await until(() =>
+    $(".ui-side-panels-row .m02-labor__edit")?.closest(".ui-side-panels-row"),
+  );
+  if (!row) return JSON.stringify({ ...result, error: "일위대가 상세 없음" });
+  const labor = $(":scope > .ui-side-panels", row);
+  const lh = $(".ui-side-panels__handles > button", labor);
+  const laborWas = lh.getAttribute("aria-expanded");
+  if (laborWas !== "true") lh.click();
+  const same = await until(() => $('tbody tr[data-labor-logic="GC000198"] .m02-labrow__name', row));
+  same?.click();
+  await until(() => $("[data-labor-source] .m01lab-src__table", row));
+  result.m02Cells = cells(row);
+  result.m02Look = look(row);
+  if (laborWas !== "true") lh.click();
+  await W(200);
+  result.labor = await check(labor, "source");
+
+  // ③ M02 면적산출 상세 — 일위대가 · 도면
+  node.click();
+  const vis = (b) => b && !b.hidden && b.offsetParent !== null;
+  const edits = () =>
+    $$(".m02-struct button").filter((b) => vis(b) && b.textContent.trim() === "수정");
+  await until(() => edits().length === 3);
+  (edits().find((b) => /면적/.test(b.title)) ?? edits()[2])?.click();
+  const area = await until(() =>
+    $$(".ui-side-panels").find((s) => shown(s) && $('[data-panel="drawing"]', s)),
+  );
+  if (!area) return JSON.stringify({ ...result, error: "면적산출 상세 없음" });
+  await W(600);
+  result.area = await check(area, "labor");
+  node.click();
+  await W(800);
+  result.sameCells = JSON.stringify(result.m01Cells) === JSON.stringify(result.m02Cells);
+  result.sameLook = JSON.stringify(result.m01Look) === JSON.stringify(result.m02Look);
+  return JSON.stringify(result);
+})();
diff --git a/resources/tester/ui_checks/50-1_보낸범위_읽기.js b/resources/tester/ui_checks/50-1_보낸범위_읽기.js
new file mode 100644
index 000000000..0f4353814
--- /dev/null
+++ b/resources/tester/ui_checks/50-1_보낸범위_읽기.js
@@ -0,0 +1,42 @@
+/* 50-1 면적 시트 「도면으로 보낸 범위」 읽기(`sentRanges`) — orca eval 한 번(서버 쓰기 없음 · 가짜 응답).
+ * 시작 화면: 로그인한 M02(#/m02-master-template?open=구조물조합&root=master) 아무 화면.
+ * 하는 일: 도면 읽기 길만 가짜 연결표(T1 · T3)로 바꿔 부름 → 그 답 · 실패 때(500) 빈 목록 → fetch 되돌림.
+ * 기대(out): rows = 2 · tag = ["T1 도면","T3 도면"] · tip0 = 「도면 표 T1 로 보낸 범위 A1:B2 · 글자 2.5」 ·
+ *   sheet0 = 가짜 시트 id · failed = [] .
+ */
+(async () => {
+  const mod =
+    await import("/@fs/C:/Aislo_wt/sub_laptop_3/M02_MasterTemplete/M02_MasterTemplete_AreaToDrawing.ts");
+  const real = window.fetch;
+  const at = { layer: "system", projectId: null, kind: "area", name: "item1", label: "item1" };
+  const out = {};
+  try {
+    window.fetch = async (url, init) => {
+      if (!String(url).includes("/templates/structure/item1")) return real(url, init);
+      return new Response(
+        JSON.stringify({
+          종류: "structure",
+          이름: "item1",
+          판: "1",
+          문서: {
+            연결표: [
+              { 연결: "T1", 시트: "s9", 범위: "A1:B2", 글자크기: 2.5, 값: {} },
+              { 연결: "T3", 시트: "s9", 범위: "C3:D5", 글자크기: 3, 값: {} },
+            ],
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    };
+    const rows = await mod.sentRanges(at);
+    out.rows = rows.length;
+    out.tag = rows.map((r) => r.이름);
+    out.tip0 = rows[0]?.설명;
+    out.sheet0 = rows[0]?.시트;
+    window.fetch = async () => new Response("{}", { status: 500 });
+    out.failed = await mod.sentRanges(at);
+  } finally {
+    window.fetch = real;
+  }
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/50-1_알약_강조_표시.js b/resources/tester/ui_checks/50-1_알약_강조_표시.js
new file mode 100644
index 000000000..10004fb5b
--- /dev/null
+++ b/resources/tester/ui_checks/50-1_알약_강조_표시.js
@@ -0,0 +1,52 @@
+/* 50-1 면적산출 알약 · 칸 · 보낸 범위 표시 — orca eval 한 번에 도는 시나리오(저장 · 서버 없음).
+ * 시작 화면: /@fs/C:/Aislo_wt/sub_laptop_3/resources/tester/spreadsheet/harness_links.html?ghost=1&range=1 (알약 L · H · A · 연결 X=B1 · L=B2 · 범위 A1:B2).
+ * 하는 일: ① 알약 줄 ② 보낸 범위 상자 ③ 칸 B1 · B2 를 눌러 그 칸 알약 강조 ④ X 의 [×] 로 연결 풀기
+ * 기대(out): orphan = X 만 ⚠ · 목록 알약 L 은 아님 · rangeTag "T1 도면" · rangeFill 투명 · rangeDashed true ·
+ *   hereB1 = ["X"] · hereB2 = ["L"] · popOnce true(칸이 바뀐 첫 그림만) · xGone true.
+ */
+(async () => {
+  const W = (t) => new Promise((r) => setTimeout(r, t));
+  const q = (s) => document.querySelector(s);
+  const all = (s) => [...document.querySelectorAll(s)];
+  const click = (el) => {
+    const r = el.getBoundingClientRect();
+    const at = {
+      bubbles: true,
+      button: 0,
+      clientX: r.left + r.width / 2,
+      clientY: r.top + r.height / 2,
+    };
+    const t = document.elementFromPoint(at.clientX, at.clientY) ?? el;
+    for (const type of ["mousedown", "mouseup", "click"]) t.dispatchEvent(new MouseEvent(type, at));
+  };
+  await W(800);
+  const out = {};
+  const pill = (k) => q(`.ss-link[data-key="${k}"]`);
+  out.orphan = all(".ss-link.is-orphan").map((b) => b.dataset.key);
+  out.xText = pill("X")?.textContent;
+  out.lOrphan = pill("L")?.classList.contains("is-orphan");
+  const range = q(".ss-link-range");
+  const cs = range && getComputedStyle(range);
+  out.rangeTag = range?.querySelector(".ss-link-range__tag")?.textContent;
+  out.rangeFill = cs?.backgroundColor;
+  out.rangeDashed = cs?.borderTopStyle === "dashed";
+  out.rangeSize = range && [Math.round(range.offsetWidth), Math.round(range.offsetHeight)];
+  const byKey = (k) => all(".ss-link-cell").find((t) => t.dataset.key === k); // 칸 표시는 고를 때마다 새로 얹힘
+  out.cellOrphan = byKey("X")?.classList.contains("is-orphan");
+  const here = () => all(".ss-link.is-here").map((b) => b.dataset.key);
+  click(byKey("X")); // B1
+  await W(300);
+  out.hereB1 = here();
+  out.popOnce = all(".ss-link.is-pop").length === 1;
+  click(byKey("L")); // B2
+  await W(300);
+  out.hereB2 = here();
+  const doc0 = window.ss.getDoc();
+  const n0 = doc0.시트[0].연결.length;
+  click(pill("X").querySelector(".ss-link__x"));
+  await W(300);
+  const n1 = window.ss.getDoc().시트[0].연결.length;
+  out.xGone = n1 === n0 - 1 && !pill("X");
+  out.xCell = !all(".ss-link-cell").some((t) => t.dataset.key === "X");
+  return out;
+})();
diff --git a/resources/tester/ui_checks/50-2_원문_항강조.js b/resources/tester/ui_checks/50-2_원문_항강조.js
new file mode 100644
index 000000000..63ae5ac2d
--- /dev/null
+++ b/resources/tester/ui_checks/50-2_원문_항강조.js
@@ -0,0 +1,71 @@
+/* 50-2 원문 패널 — 마크다운 기호 벗김 · 출처 항 · 주 강조 · `orca eval --expression "$(cat 이 파일)"` 한 번에 돎 · JSON 돌려줌.
+ *
+ * 시작 화면: M01 마스터 데이터(#/m01-master-data · 시스템 관리자 로그인) · 아무 화면이나.
+ *   로직 GF000003(산림품셈 3-4-2 1) · GF000094(산림품셈 9-7-1 주⑥)을 엶 · 고치지 않음 · 패널 취향을 처음 값으로 되돌림.
+ * 기대 수치:
+ *   item1  = {head:"3-4-2. …", file:"1항", hit:12, first:"1. 단가산출 방법은 …", nextNotHit:true, bad:0(역슬래시 · 「<!--」 · 「>」 머리 글 수), inView:true}
+ *   note6  = {file:"주⑥", hit:1, first:"⑥ 굴착기의 작업능력 …", nextNotHit:true, bad:0, inView:true}
+ */
+(async () => {
+  const W = (ms) => new Promise((r) => setTimeout(r, ms));
+  const $ = (s, root = document) => root.querySelector(s);
+  const $$ = (s, root = document) => [...root.querySelectorAll(s)];
+  const until = async (f, ms = 15000) => {
+    for (let t = 0; t < ms; t += 200) {
+      const v = f();
+      if (v) return v;
+      await W(200);
+    }
+    return null;
+  };
+  const PREF = "aislo:pref:m01-logic-side";
+  const first = localStorage.getItem(PREF);
+  const out = {};
+  const openLogic = async (key) => {
+    sessionStorage.setItem("m01.logic.pending", key);
+    const tab = $$(".ui-collapsible__title").find((h) => h.innerText.trim() === "단가산출 로직");
+    if (!tab) return false;
+    if (!tab.closest(".ui-collapsible").classList.contains("is-collapsed")) tab.click();
+    tab.click();
+    return until(() => {
+      const t = $(".m02-dfp__title")?.innerText ?? "";
+      return !$(".m01lab-side")?.hidden && $(".m01lab-side .m02-dfp") && t;
+    });
+  };
+  const shown = (n) => !!n && n.getBoundingClientRect().width > 0;
+  const panel = (id) => $(`.m01lab-side .ui-side-panels__panel[data-panel="${id}"]`);
+  const strip = (title) =>
+    $$(".m01lab-side .ui-side-panels__handles > *").find(
+      (s) => s.innerText.replace(/\s/g, "") === title,
+    );
+  const inView = (n) => {
+    const r = n.getBoundingClientRect();
+    return r.top >= 0 && r.bottom <= innerHeight && r.height > 0;
+  };
+  const read = async (key, wantFile) => {
+    if (!(await openLogic(key))) return { error: "로직 못 엶" };
+    await W(600);
+    if (!shown(panel("source"))) strip("원문")?.click();
+    await until(() => $$(".m01lab-src__file").some((f) => f.innerText.includes(wantFile)), 6000);
+    await W(600);
+    const ps = $$(".m01lab-src__body > *");
+    const hits = $$(".m01lab-src__hit");
+    const texts = $$(".m01lab-src__p, .m01lab-src__head").map((n) => n.innerText);
+    return {
+      head: $(".m01lab-src__head")?.innerText,
+      file: $(".m01lab-src__file")?.innerText.split(" · ").pop(),
+      hit: hits.length,
+      first: hits[0]?.innerText.slice(0, 20),
+      nextNotHit: !hits.includes(ps[ps.indexOf(hits[hits.length - 1]) + 1]),
+      bad: texts.filter((t) => /\|<!--|^>/.test(t)).length,
+      inView: hits.length > 0 && inView(hits[0]),
+    };
+  };
+  if (!(await openLogic("GF000003"))) return JSON.stringify({ error: "로직 못 엶" });
+  out.item1 = await read("GF000003", "1항");
+  out.note6 = await read("GF000094", "주⑥");
+  // 되돌림 — 처음 취향
+  if (first === null) localStorage.removeItem(PREF);
+  else localStorage.setItem(PREF, first);
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/50-3-4_고르기_서고탭.js b/resources/tester/ui_checks/50-3-4_고르기_서고탭.js
new file mode 100644
index 000000000..edf1a56ec
--- /dev/null
+++ b/resources/tester/ui_checks/50-3-4_고르기_서고탭.js
@@ -0,0 +1,174 @@
+/* 50-3 ④ — 일위대가 상세 [로직 추가] 창 탭 단가산출 · 단가승격 · 사전조합 + 층 단추 · 참조 줄 표 · 줄 상세
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item1(구조물 조합 · 일위대가 첫 줄 GC000198)이 있음
+ * 부르는 법: orca eval --expression "$(tr '\n' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 공유 마스터에 서고 문서를 안 씀 — 이 탭 fetch 만 바꿔 끼움(끝나면 되돌림):
+ *   층 목록 = 가짜 SP-990001 · SC-990001 더함 · calc = 참조 줄 빼고 진짜 셈 + 참조 줄 답(승격 = GC000198 줄 · 사전조합 안 줄 하나)
+ * 하는 일: item1 → 일위대가 [수정] → [로직 추가] 탭 셋 → 단가승격 탭 · 마스터 → SP 고름 → 사전조합 탭 → SC 고름 →
+ *   승격 줄 누름 · 조합 줄 누름 → 두 줄 삭제(저장 안 함) → item1 다시
+ * 기대 수치:
+ *   - tabs = ["단가산출","단가승격","사전조합"] · layers = ["마스터"](마스터 층은 위 층 없음) · listed = ["SP-990001"] · ["SC-990001"]
+ *   - added.kinds 끝 둘 = ["단가승격","일위조합"] · added.keys 끝 둘 = ["SP-990001","SC-990001"] · 옵션 단추 없음(optBtn = 0)
+ *   - promote.from = "원 로직 GC000198" · promote.rows = GC000198 줄 수(4) · promote.sum = first 줄 기준 계
+ *   - combo.inner = 1 · combo.innerKind = "단가승격"
+ *   - removed = true(원래 줄 수) · askedLeave = false(저장 안 한 고침 없음) · back = true
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const n = (s) => Number(String(s ?? "").replace(/[^0-9.-]/g, "")) || 0;
+  const SP = { 층: "system", 주인: null, 키: "SP-990001" };
+  const SC = { 층: "system", 주인: null, 키: "SC-990001" };
+  const rid = (r) => `참조|${r.층}|${r.주인 ?? ""}|${r.키}`;
+  const real = window.fetch;
+  let first = null;
+  window.fetch = async (url, init) => {
+    const u = String(url);
+    if (/\/layers\/system\/templates$/.test(u)) {
+      const got = await (await real(url, init)).json();
+      got.양식.push(
+        { 종류: "promote", 이름: SP.키, 제목: "시험 승격", 단위: "㎡" },
+        { 종류: "precombo", 이름: SC.키, 제목: "시험 조합", 단위: "식" },
+      );
+      return new Response(JSON.stringify(got), { status: 200 });
+    }
+    if (/\/labor\/[^/]+\/calc/.test(u) && init?.body) {
+      const body = JSON.parse(init.body);
+      const refs = (body.doc?.담은로직 ?? []).filter((r) => r.참조);
+      if (!refs.length) return real(url, init);
+      body.doc.담은로직 = body.doc.담은로직.filter((r) => !r.참조);
+      const got = await (await real(url, { ...init, body: JSON.stringify(body) })).json();
+      first = got.줄[0];
+      for (const r of refs) {
+        const base = { ...first.기준 };
+        const line = {
+          참조: r.참조,
+          이름: r.참조.키 === SP.키 ? "시험 승격" : "시험 조합",
+          알약: rid(r.참조),
+          분모: "㎡",
+          배: 1,
+          기준: base,
+          반영: null,
+          수량: null,
+          수량출처: "없음",
+          까닭: null,
+        };
+        if (r.참조.키 === SP.키) Object.assign(line, { 원로직: first.로직, 줄: first.줄 });
+        else
+          line.안 = [{ 참조: SP, 수량: 1, 이름: "시험 승격", 단위: "㎡", 기준: base, 까닭: null }];
+        got.줄.push(line);
+      }
+      return new Response(JSON.stringify(got), { status: 200 });
+    }
+    return real(url, init);
+  };
+  const out = {};
+  try {
+    const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+    if (!node) return JSON.stringify({ error: "item1 없음" });
+    node.click();
+    const card = await until(() =>
+      [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+        c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+      ),
+    );
+    if (!card) return JSON.stringify({ error: "일위대가 카드 없음" });
+    [...card.querySelectorAll(".m02-struct__card-tools button")]
+      .find((b) => b.innerText.trim() === "수정")
+      ?.click();
+    const table = () =>
+      [...document.querySelectorAll("table.m02-labrow")].find(
+        (t) => !t.closest(".m02-struct__card") && t.querySelector("tr[data-labor-logic]"),
+      );
+    await until(() => table() && !/…/.test(table().querySelector("tbody").innerText), 12000);
+    const host = table().closest("[data-labor]");
+    const before = table().querySelectorAll("tbody tr[data-labor-logic]").length;
+    const add = async (tabLabel, key) => {
+      [...host.querySelectorAll(".m01-logic__section-head button")]
+        .find((b) => b.innerText.trim() === "로직 추가")
+        .click();
+      const dlg = await until(
+        () =>
+          document.querySelector(".m01-logic__pick [data-pick-tabs] button") &&
+          document.querySelector(".m01-logic__pick"),
+      );
+      const tabs = [...dlg.querySelectorAll("[data-pick-tabs] button")];
+      out.tabs = tabs.map((b) => b.innerText.trim());
+      tabs.find((b) => b.innerText.trim() === tabLabel).click();
+      await until(() => dlg.querySelector(`[data-pick="${key}"]`));
+      out.layers = [...dlg.querySelectorAll("[data-pick-layers] button")].map((b) =>
+        b.innerText.trim(),
+      );
+      (out.listed ??= []).push([...dlg.querySelectorAll("[data-pick]")].map((b) => b.dataset.pick));
+      dlg.querySelector(`[data-pick="${key}"]`).click();
+      await until(
+        () =>
+          table()?.querySelector(`tr[data-labor-logic="${rid({ ...SP, 키: key })}"]`) &&
+          !/…/.test(table().querySelector("tbody").innerText),
+        12000,
+      );
+    };
+    await add("단가승격", SP.키);
+    await add("사전조합", SC.키);
+    const rows = [...table().querySelectorAll("tbody tr[data-labor-logic]")];
+    out.added = {
+      kinds: rows.slice(-2).map((r) => r.querySelector(".m02-labrow__kind").innerText.trim()),
+      keys: rows.slice(-2).map((r) => r.querySelector(".m02-labrow__key").innerText.trim()),
+      optBtn: rows
+        .slice(-2)
+        .flatMap((r) =>
+          [...r.querySelectorAll("button")].filter((b) => b.innerText.trim() === "옵션"),
+        ).length,
+    };
+    const open = async (ref) => {
+      table()
+        .querySelector(`tr[data-labor-logic="${rid(ref)}"] .m02-labrow__name`)
+        .click();
+      await w(300);
+      return host.querySelector("[data-labor-linedet]");
+    };
+    let det = await open(SP);
+    const grid = det.querySelector("table.m01-logic__grid");
+    out.promote = {
+      from: det.querySelector("p")?.innerText.trim(),
+      rows: grid?.querySelectorAll("tbody tr").length ?? 0,
+      sum: [...(grid?.querySelectorAll("tbody tr") ?? [])].reduce(
+        (a, r) => a + n(r.lastElementChild.innerText),
+        0,
+      ),
+      firstBase: first?.기준?.계 ?? null,
+    };
+    det = await open(SC);
+    const inner = det.querySelector("[data-labor-inner]");
+    out.combo = {
+      inner: inner?.querySelectorAll("tbody tr").length ?? 0,
+      innerKind: inner?.querySelector("tbody td")?.innerText.trim(),
+    };
+    await open(SC); /* 닫음 */
+    for (const ref of [SC, SP]) {
+      const tr = table().querySelector(`tr[data-labor-logic="${rid(ref)}"]`);
+      [...tr.querySelectorAll("button")].find((b) => b.innerText.trim() === "삭제").click();
+      await w(600);
+    }
+    out.removed = table().querySelectorAll("tbody tr[data-labor-logic]").length === before;
+  } finally {
+    window.fetch = real;
+  }
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(800);
+  const ask = [...document.querySelectorAll(".ui-modal button, dialog button")].find((b) =>
+    /확인|버림|떠나기/.test(b.innerText),
+  );
+  out.askedLeave = !!ask; /* 저장 안 한 고침이 남았으면 물음 — 지운 뒤라 없어야 함 */
+  ask?.click();
+  await w(1200);
+  out.back = !!document.querySelector(".m02-struct__card table.m02-labrow");
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/50-3_일위대가조합_서고.js b/resources/tester/ui_checks/50-3_일위대가조합_서고.js
new file mode 100644
index 000000000..2e8c23c96
--- /dev/null
+++ b/resources/tester/ui_checks/50-3_일위대가조합_서고.js
@@ -0,0 +1,97 @@
+/* 50-3 ③ — M02 좌측 「일위대가 조합」 서고 컨테이너 · 상세 서고 모드
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=일위대가조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — 새로 창은 열고 닫기만 · 상세 모드는 떼어 둔 칸에 가짜 문서로 붙여 봄(서버 calc 만 부름)
+ * 기대 수치:
+ *   - side.order = ["구조물 조합", "일위대가 조합", …] · side.open = true(진입 open=일위대가조합 이 펼침)
+ *   - side.layerButtons ≥ 1 · side.subs = ["promote", "precombo"] · side.newButtons = 2(관리자)
+ *   - picker.opened = true(단가승격 [새로] = 로직 고르기 창) · precomboDialog = { opened: true, closed: true }
+ *   - detail.promote = { name: true, mats: false, diagram: false, add: false, rows: 1, source: true }
+ *   - detail.precombo = { name: true, mats: false, diagram: false, add: false, rows: 0 }
+ */
+(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const sections = [...document.querySelectorAll(".m02-side__lists > section")];
+  const title = (s) => s.querySelector(".ui-collapsible__title")?.textContent?.trim() ?? "";
+  const lib = sections.find((s) => title(s) === "일위대가 조합");
+  const side = {
+    order: sections.map(title),
+    open: !!lib && !lib.classList.contains("is-collapsed"),
+    layerButtons: lib?.querySelectorAll(".m02-layers__btn").length ?? 0,
+    subs: [...(lib?.querySelectorAll("[data-precombo]") ?? [])].map((x) => x.dataset.precombo),
+    newButtons: [...(lib?.querySelectorAll(".m02-side__row") ?? [])].length,
+    rows: lib?.querySelectorAll("[data-precombo-key]").length ?? 0,
+  };
+  const btn = (kind, i) =>
+    lib?.querySelector(`[data-precombo="${kind}"] .m02-side__row`)?.querySelectorAll("button")[i];
+  // 단가승격 [새로] = 로직 고르기 창 → 닫기
+  btn("promote", 0)?.click();
+  await wait(300);
+  const pick = document.querySelector(".m01-logic__pick");
+  const picker = { opened: !!pick };
+  pick?.closest(".m01-logic__backdrop")?.remove();
+  // 사전조합 [새로] = 이름 창 → 닫기(Escape)
+  btn("precombo", 0)?.click();
+  await wait(300);
+  const modal = document.querySelector(".m02-modal");
+  const precomboDialog = { opened: !!modal };
+  modal?.querySelector(".ui-modal__top button")?.click(); // [닫기]
+  await wait(200);
+
+  // 상세 서고 모드 — 떼어 둔 칸(화면 밖)에 가짜 문서
+  // 모듈 주소 = 페이지가 받은 UI_Side 주소에서 파일 이름만 바꿈(vite 뿌리 밖 `/@fs/…`)
+  const sideUrl = performance
+    .getEntriesByType("resource")
+    .map((e) => e.name)
+    .find((n) => n.includes("M02_MasterTemplete_UI_Side.ts"));
+  const { mountLaborDetail } = await import(
+    sideUrl.replace(/M02_MasterTemplete_UI_Side\.ts.*$/, "M02_MasterTemplete_Labor_Detail.ts")
+  );
+  const probe = async (mode, doc) => {
+    const host = document.createElement("div");
+    host.style.cssText = "position:fixed;left:-9999px;top:0;width:900px";
+    document.body.append(host);
+    const h = mountLaborDetail(host, doc, {
+      layer: "system",
+      column: doc.키,
+      readOnly: false,
+      onChanged: () => {},
+      goArea: null,
+      mode,
+    });
+    await wait(400);
+    const out = {
+      name: !!host.querySelector('[data-labor-field="이름"] input'),
+      nameValue: host.querySelector('[data-labor-field="이름"] input')?.value ?? null,
+      mats: [...host.querySelectorAll("h3")].some((x) => x.textContent === "자재목록"),
+      diagram: !!host.querySelector(".m02-labor__dg"),
+      add: [...host.querySelectorAll("button")].some((x) => x.textContent === "로직 추가"),
+      rows: host.querySelectorAll("[data-labor-logic]").length,
+      source:
+        !!host.querySelector("[data-labor-source]") || !!host.querySelector(".ui-side-panels"),
+      kind: h.getDoc().종류,
+      keepsColumn: "열" in h.getDoc() || "자재" in h.getDoc(),
+    };
+    h.destroy();
+    host.remove();
+    return out;
+  };
+  const detail = {
+    promote: await probe("promote", {
+      종류: "단가승격",
+      키: "SP-999999",
+      이름: "시험 승격",
+      단위: null,
+      담은로직: [{ 로직: "L-0001", 입력값: {} }],
+    }),
+    precombo: await probe("precombo", {
+      종류: "사전조합",
+      키: "SC-999999",
+      이름: "시험 사전조합",
+      단위: null,
+      담은로직: [],
+    }),
+  };
+  precomboDialog.closed = !document.querySelector(".m02-modal");
+  return JSON.stringify({ side, picker, precomboDialog, detail });
+})();
diff --git a/resources/tester/ui_checks/50-4_일위대가_줄_상세.js b/resources/tester/ui_checks/50-4_일위대가_줄_상세.js
new file mode 100644
index 000000000..11fecbbb2
--- /dev/null
+++ b/resources/tester/ui_checks/50-4_일위대가_줄_상세.js
@@ -0,0 +1,131 @@
+/* 50-4 — 일위대가 단가산출 로직 표 줄 누름 = 표 아래 그 줄 상세(M01 시험계산 표) · 다시 누르면 닫힘 · 「구분」 열 — 카드 · 상세 두 곳
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item1(구조물 조합 · 일위대가 로직 둘 이상)이 있음
+ * 부르는 법: orca eval --expression "$(tr '\n' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 하는 일: item1 카드 표 줄 누름 · 다른 줄 · 같은 줄 다시 → 일위대가 카드 [수정]으로 상세 → 같은 차례 → item1 다시(값 안 바뀜)
+ * 기대 수치(카드 · 상세 같음):
+ *   - head[1] = "구분" · kinds = 줄마다 "단가산출"
+ *   - first.open = 1(상세 상자 하나) · first.rows ≥ 1 · first.sum = first.total = first.base(줄 합 = 상세 계 = 표 기준 합계)
+ *   - first.applied = first.appliedRow(상세 반영 계 = 표 반영 합계 · 수량 없으면 둘 다 「—」 = 0)
+ *   - second.title 가 둘째 줄 키 · second.open = 1(한 줄만)
+ *   - again.open = 0 · again.selected = 0(같은 줄 다시 = 닫힘)
+ *   - back = true(카드 화면으로 돌아감)
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const n = (s) => Number(String(s ?? "").replace(/[^0-9.-]/g, "")) || 0;
+  const rowsOf = (t) => [...t.querySelectorAll("tbody tr[data-labor-logic]")];
+  const settled = (get) =>
+    until(() => {
+      const t = get();
+      return t && !/…/.test(t.querySelector("tbody").innerText) ? t : null;
+    }, 10000);
+  /* 상세 상자 읽기 — 표 줄 금액 합 · 기준 계 · 반영 계 */
+  const det = (box) => {
+    const dl = [...box.querySelectorAll("dl.m01-logic__sums")];
+    const total = (d) => {
+      const dt = d && [...d.querySelectorAll("dt")].find((x) => /계|합계|Total/.test(x.innerText));
+      return dt ? n(dt.nextElementSibling.innerText) : null;
+    };
+    const rows = [...box.querySelectorAll("table.m01-logic__grid tbody tr")];
+    return {
+      title: box.querySelector("h4")?.innerText ?? null,
+      rows: rows.length,
+      sum: rows.reduce((a, r) => a + n(r.lastElementChild.innerText), 0),
+      total: total(dl[0]),
+      applied: dl[1] ? total(dl[1]) : "없음",
+    };
+  };
+  const measure = async (get, boxOf) => {
+    const t = await settled(get);
+    const rows = rowsOf(t);
+    const head = [...t.querySelectorAll("thead th")].map((th) => th.innerText.trim());
+    const kinds = rows.map((r) => r.querySelector(".m02-labrow__kind")?.innerText.trim());
+    const click = async (key) => {
+      get().querySelector(`tr[data-labor-logic="${key}"] .m02-labrow__name`).click();
+      await w(300);
+    };
+    const opened = () =>
+      [...boxOf().querySelectorAll("[data-labor-linedet]")].filter((b) => b.childElementCount);
+    const k0 = rows[0].getAttribute("data-labor-logic");
+    const k1 = rows[1]?.getAttribute("data-labor-logic") ?? k0;
+    const sumCell = (key) => {
+      const tds = get().querySelectorAll(`tr[data-labor-logic="${key}"] .m02-labrow__money`);
+      const last = tds[tds.length - 1];
+      return {
+        base: n(last.querySelector(".m02-labrow__base").innerText),
+        applied: n(last.querySelector(".m02-labrow__applied").innerText),
+      };
+    };
+    await click(k0);
+    const d0 = det(opened()[0]);
+    const row0 = sumCell(k0);
+    const first = {
+      key: k0,
+      open: opened().length,
+      ...d0,
+      base: row0.base,
+      appliedRow: row0.applied,
+    };
+    await click(k1);
+    const second = {
+      key: k1,
+      open: opened().length,
+      title: opened()[0]?.querySelector("h4")?.innerText,
+    };
+    await click(k1);
+    const again = {
+      open: opened().length,
+      selected: rowsOf(get()).filter((r) => r.classList.contains("is-selected")).length,
+    };
+    return { head, kinds, first, second, again };
+  };
+  const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+  if (!node) return JSON.stringify({ error: "item1 없음 — 폴더를 펼쳐 둘 것" });
+  node.click();
+  const card = await until(() =>
+    [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+      c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+    ),
+  );
+  if (!card) return JSON.stringify({ error: "일위대가 카드 표 없음" });
+  await w(1500);
+  const out = {
+    card: await measure(
+      () => card.querySelector("table.m02-labrow"),
+      () => card,
+    ),
+  };
+  const edit = [...card.querySelectorAll(".m02-struct__card-tools button")].find(
+    (b) => b.innerText.trim() === "수정",
+  );
+  if (!edit) return JSON.stringify({ ...out, error: "일위대가 [수정] 없음" });
+  edit.click();
+  const dt = await until(() =>
+    [...document.querySelectorAll("table.m02-labrow")].find(
+      (t) => !t.closest(".m02-struct__card") && t.querySelector("tbody tr[data-labor-logic]"),
+    ),
+  );
+  if (!dt) return JSON.stringify({ ...out, error: "상세 표 없음" });
+  await w(2000);
+  const table = () =>
+    [...document.querySelectorAll("table.m02-labrow")].find((t) => !t.closest(".m02-struct__card"));
+  out.detail = await measure(table, () => table().closest("[data-labor]"));
+  /* 카드 화면으로 돌아감(고름만 했으니 버림 물음 없음 — 뜨면 확인) */
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(800);
+  [...document.querySelectorAll(".ui-modal button, dialog button")]
+    .find((b) => /확인|버림|떠나기/.test(b.innerText))
+    ?.click();
+  await w(1200);
+  out.back = !!document.querySelector(".m02-struct__card table.m02-labrow");
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/51-10_서고_표양식.js b/resources/tester/ui_checks/51-10_서고_표양식.js
new file mode 100644
index 000000000..0b472b6ef
--- /dev/null
+++ b/resources/tester/ui_checks/51-10_서고_표양식.js
@@ -0,0 +1,149 @@
+/* 51-10 — 서고 목록표(단가산출 승격 · 일위대가 사전조합) = M01 단가산출 로직 목록 표 양식 · 단추 꼴 ·
+ *         사전조합 상세 [로직 추가] = 일위대가 상세 [로직 추가] 와 같은 고르기 창(서고 줄만)
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=일위대가조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — 서고 목록 · 문서 읽기는 가짜 응답(fetch 바꿔 끼움 · 끝에 되돌림)
+ * 기대 수치:
+ *   - table.wrap = "m01-master__grid-wrap" · table.table = "m01-master__grid" · table.row = "m01-master__table-row"
+ *   - table.filters = true(찾기 칸 + 쪽 `m01-master__pager`) · table.sameCell = true(M01 표 칸과 padding · 글자 · 밑줄 같음)
+ *   - table.search = 1(「값 없음」 치면 한 줄)
+ *   - buttons.variants = ["filled", "ghost", "danger"](M01 [신규 로직] · [로직 복사/생성] · [로직 지우기] 와 같음) · buttons.redDelete = true
+ *   - precombo.add = "로직 추가" · picker.label = "로직 고르기" · picker.kinds ⊂ {단가승격, 일위조합} · picker.logicRows = 0
+ */
+(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 4000) => {
+    for (let t = 0; t < ms; t += 100) {
+      const v = fn();
+      if (v) return v;
+      await wait(100);
+    }
+    return null;
+  };
+  const SYS = { 층: "system", 주인: null };
+  const rows = [
+    {
+      종류: "promote",
+      이름: "SP-999901",
+      판: "a",
+      수정일: "2026-10-05",
+      제목: "시험 승격",
+      단위: "㎡",
+      기준금액: 1234.5,
+    },
+    {
+      종류: "promote",
+      이름: "SP-999902",
+      판: "b",
+      수정일: "2026-10-05",
+      제목: "값 없음",
+      단위: null,
+      기준금액: null,
+    },
+    {
+      종류: "precombo",
+      이름: "SC-999901",
+      판: "c",
+      수정일: "2026-10-05",
+      제목: "시험 묶음",
+      단위: "개소",
+      기준금액: 10,
+    },
+  ];
+  const doc = {
+    종류: "사전조합",
+    키: "SC-999901",
+    이름: "시험 묶음",
+    단위: "개소",
+    담은로직: [{ 참조: { ...SYS, 키: "SP-999901" }, 수량: { 손: 1 } }],
+  };
+  const json = (body, status = 200) =>
+    new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+  const real = window.fetch;
+  window.fetch = async (input, init = {}) => {
+    const url = String(input?.url ?? input);
+    const method = (init.method ?? "GET").toUpperCase();
+    if (method === "GET" && /\/m02\/layers\/system\/templates(\?|$)/.test(url)) {
+      const got = await (await real(input, init)).json();
+      return json({ ...got, 양식: [...got.양식.filter((r) => !/^S[PC]-/.test(r.이름)), ...rows] });
+    }
+    if (method === "GET" && url.includes("/templates/precombo/SC-999901"))
+      return json({ 종류: "precombo", 이름: "SC-999901", 판: "c", 문서: doc });
+    if (method !== "GET" && !url.includes("/calc"))
+      return json({ detail: "시험 — 쓰기 막음" }, 400);
+    return real(input, init);
+  };
+  const sec = [...document.querySelectorAll(".m02-side__lists > section")].find(
+    (s) => s.querySelector(".ui-collapsible__title")?.textContent?.trim() === "일위대가 조합",
+  );
+  const items = [...sec.querySelectorAll("[data-precombo]")];
+  const list = (kind) => document.querySelector(`[data-lib-list="${kind}"]`);
+  const tools = () => [...document.querySelectorAll(".m02-main__slot .m02-main__tools button")];
+  const box = (n) => {
+    const s = getComputedStyle(n);
+    return [s.paddingTop, s.paddingLeft, s.fontSize, s.borderBottomWidth].join("|");
+  };
+  try {
+    items[0].click();
+    await until(() => list("promote")?.querySelector(`[data-lib-key="SP-999902"]`));
+    const wrap = list("promote");
+    const td = wrap.querySelector("[data-lib-key] td:nth-child(3)");
+    // M01 목록 표와 같은 클래스로 짠 견본 칸 — 같은 CSS 면 같은 칸 꼴
+    const ref = document.createElement("div");
+    ref.className = "m01-master__grid-wrap";
+    ref.innerHTML =
+      '<table class="m01-master__grid"><tbody><tr class="m01-master__table-row"><td>시험 승격</td></tr></tbody></table>';
+    wrap.parentElement.append(ref);
+    const table = {
+      wrap: wrap.className,
+      table: wrap.querySelector("table").className,
+      row: wrap.querySelector("[data-lib-key]").className,
+      filters:
+        !!wrap.parentElement.querySelector(".m01-head__filters input[type=search]") &&
+        !!wrap.parentElement.querySelector(".m01-head__filters .m01-master__pager"),
+      sameCell: box(td) === box(ref.querySelector("td")),
+      cell: box(td),
+    };
+    ref.remove();
+    const search = wrap.parentElement.querySelector(".m01-head__filters input[type=search]");
+    search.value = "값 없음";
+    search.dispatchEvent(new Event("input"));
+    await wait(100);
+    table.search = list("promote").querySelectorAll("[data-lib-key]").length;
+    search.value = "";
+    search.dispatchEvent(new Event("input"));
+    const v = (b) => ["filled", "ghost", "danger"].find((x) => b.className.includes(`--${x}`));
+    const buttons = {
+      labels: tools().map((b) => b.textContent),
+      variants: tools().map(v),
+      redDelete: /rgb\((1\d\d|2\d\d), (\d|[1-9]\d), (\d|[1-9]\d)\)/.test(
+        getComputedStyle(tools()[2]).backgroundColor + getComputedStyle(tools()[2]).color,
+      ),
+      deleteColor: getComputedStyle(tools()[2]).backgroundColor,
+    };
+    // 사전조합 상세 [로직 추가]
+    items[1].click();
+    const row = await until(() =>
+      document.querySelector('[data-lib-key="SC-999901"] td:nth-child(3)'),
+    );
+    row.click();
+    const edit = await until(() => document.querySelector(".m02-main__host [data-labor]"));
+    await wait(300);
+    const add = [...edit.querySelectorAll("button")].find((b) => b.textContent === "로직 추가");
+    const precombo = { add: add?.textContent ?? null };
+    add?.click();
+    const pick = await until(() => document.querySelector(".m01-logic__pick"));
+    await until(() => pick?.querySelectorAll("[data-pick]").length, 3000);
+    const kinds = [...(pick?.querySelectorAll("[data-pick-kind]") ?? [])].map((x) => x.textContent);
+    const picker = {
+      label: pick?.getAttribute("aria-label") ?? null,
+      kinds: [...new Set(kinds)],
+      logicRows: kinds.filter((k) => k === "단가산출").length,
+      rows: kinds.length,
+    };
+    pick?.closest(".m01-logic__backdrop")?.remove();
+    return JSON.stringify({ table, buttons, precombo, picker });
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-11_사전조합_고르기.js b/resources/tester/ui_checks/51-11_사전조합_고르기.js
new file mode 100644
index 000000000..490b84dc0
--- /dev/null
+++ b/resources/tester/ui_checks/51-11_사전조합_고르기.js
@@ -0,0 +1,164 @@
+/* 51-11 — 서고 사전조합 상세 [로직 추가] = 일위대가 상세와 같은 고르기 창 · 같은 표 · 같은 동작
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=일위대가조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — 서고 목록 · 문서 읽기 · [저장] PUT 은 가짜 응답(fetch 바꿔 끼움 · 끝에 되돌림) · calc 만 서버
+ * 기대 수치:
+ *   - picker = { filters: 2, kinds: ["단가산출", "단가승격", "일위조합"] }(걸러냄 없음 · 일위대가 상세와 같음)
+ *   - added = 2 · logic = { option: true, modal: true, qty: "1", sheet: false, sub: ≥1 }
+ *   - sum = 줄 계 합 == 합계 줄 계 · moved = ["GC000421", "SP-000001"](참조 = 마스터 실제 SP-000001 · calc 가 읽음)
+ *   - sent = { 로직: "GC000421", 수량: { 손: 1 } } · removed = 1 · left = 버림 확인 뒤 목록
+ */
+(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 6000) => {
+    for (let t = 0; t < ms; t += 100) {
+      const v = fn();
+      if (v) return v;
+      await wait(100);
+    }
+    return null;
+  };
+  const SYS = { 층: "system", 주인: null };
+  const LOGIC = "GC000421";
+  const rows = [
+    {
+      종류: "precombo",
+      이름: "SC-999901",
+      판: "c",
+      수정일: "2026-10-05T12:00:00",
+      제목: "시험 묶음",
+      단위: "개소",
+      기준금액: 100,
+    },
+  ];
+  const docs = {
+    "precombo/SC-999901": {
+      종류: "사전조합",
+      키: "SC-999901",
+      이름: "시험 묶음",
+      단위: "개소",
+      담은로직: [{ 참조: { ...SYS, 키: "SP-000001" }, 수량: { 손: 1 } }],
+    },
+  };
+  const json = (body, status = 200) =>
+    new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+  const real = window.fetch;
+  let putBody = null;
+  window.fetch = async (input, init = {}) => {
+    const url = String(input?.url ?? input);
+    const method = (init.method ?? "GET").toUpperCase();
+    if (method === "GET" && /\/m02\/layers\/system\/templates(\?|$)/.test(url)) {
+      const got = await (await real(input, init)).json();
+      return json({ ...got, 양식: [...got.양식.filter((r) => r.이름 !== "SC-999901"), ...rows] });
+    }
+    const hit = Object.keys(docs).find((k) => url.includes(`/templates/${k}`));
+    if (hit && method === "GET" && !url.includes("/calc"))
+      return json({ 종류: hit.split("/")[0], 이름: docs[hit].키, 판: "a", 문서: docs[hit] });
+    if (hit && method === "PUT") {
+      putBody = JSON.parse(init.body);
+      return json({ 이름: "SC-999901", 판: "z" });
+    }
+    if (method !== "GET" && !url.includes("/calc"))
+      return json({ detail: "시험 — 쓰기 막음" }, 400);
+    return real(input, init);
+  };
+  const sec = [...document.querySelectorAll(".m02-side__lists > section")].find(
+    (s) => s.querySelector(".ui-collapsible__title")?.textContent?.trim() === "일위대가 조합",
+  );
+  const items = [...sec.querySelectorAll("[data-precombo]")];
+  const btn = (root, text) =>
+    [...(root?.querySelectorAll("button") ?? [])].find((b) => b.textContent === text);
+  const edit = () => document.querySelector(".m02-main__host [data-labor]");
+  const lines = () => [...(edit()?.querySelectorAll("[data-labor-logic]") ?? [])];
+  const keys = () => lines().map((tr) => tr.querySelector(".m02-labrow__key")?.textContent);
+  const num = (s) => Number(String(s ?? "").replace(/[^\d.-]/g, "")) || 0;
+  const applied = (tr) =>
+    [...tr.querySelectorAll(".m02-labrow__money .m02-labrow__applied")].pop()?.textContent;
+  const calcDone = () =>
+    until(() => {
+      const t = edit()?.querySelector(".m02-labrow__total .m02-labrow__applied")?.textContent;
+      return t && !t.includes("…") ? t : null;
+    });
+  try {
+    items[1].click();
+    (
+      await until(() => document.querySelector('[data-lib-key="SC-999901"] td:nth-child(3)'))
+    ).click();
+    await until(() => lines().length);
+    await wait(300);
+    // 고르기 창 — 일위대가 상세와 같음(구분 · 상세구분 거름 · 구분 셋)
+    btn(edit(), "로직 추가").click();
+    const pick = await until(() => document.querySelector(".m01-logic__pick"));
+    await until(() => {
+      const k = new Set([...pick.querySelectorAll("[data-pick-kind]")].map((x) => x.textContent));
+      return k.size >= 3;
+    }, 20000);
+    const picker = {
+      filters: pick.querySelectorAll(".ui-find__filters select").length,
+      kinds: [...new Set([...pick.querySelectorAll("[data-pick-kind]")].map((x) => x.textContent))],
+    };
+    const search = pick.querySelector("input");
+    search.value = LOGIC;
+    search.dispatchEvent(new Event("input"));
+    (await until(() => pick.querySelector(`[data-pick="${LOGIC}"]`))).click();
+    await until(() => lines().length === 2);
+    const added = lines().length;
+    const row = () => lines().find((tr) => tr.dataset.laborLogic === LOGIC);
+    // [옵션] → 넣을 값 모달
+    const option = btn(row(), "옵션");
+    option?.click();
+    const modal = await until(() => document.querySelector(".m02-labin"));
+    btn(modal, "닫기")?.click();
+    await wait(200);
+    // 수량 — 손 입력 기본 1 · 시트 없음
+    row().querySelector("[data-labor-qty-open]").click();
+    const hand = await until(() => document.querySelector('.m02-labqty [data-labor-qty="hand"]'));
+    const logic = {
+      option: !!option,
+      modal: !!modal,
+      qty: hand?.value,
+      sheet: !!document.querySelector(".m02-labqty [data-labor-qty-sheet]"),
+    };
+    btn(document.querySelector(".m02-labqty"), "닫기")?.click();
+    await wait(200);
+    // 합 — 줄 계(반영) 합 == 합계 줄
+    const total = await calcDone();
+    const sum = {
+      lines: lines().reduce((a, tr) => a + num(applied(tr)), 0),
+      total: num(total),
+    };
+    // 줄 누름 → 하위 행
+    row().querySelector(".m02-labrow__name").click();
+    await until(() => edit().querySelector("[data-labor-sub]"));
+    await until(() => !edit().querySelector("[data-labor-sub]")?.textContent.includes("…"));
+    logic.sub = edit().querySelectorAll("[data-labor-sub]").length;
+    // 위로
+    btn(row(), "위로").click();
+    await wait(300);
+    const moved = keys();
+    // [저장] 본문(가짜 PUT)
+    const save = btn(document.querySelector(".m02-main__head"), "저장");
+    save.click();
+    await until(() => putBody);
+    const s = putBody?.문서?.담은로직?.find((x) => x.로직 === LOGIC);
+    const sent = s ? { 로직: s.로직, 수량: s.수량 } : null;
+    // 삭제 — 로직 줄 뺌
+    btn(row(), "삭제").click();
+    await wait(300);
+    const removed = lines().length;
+    // 떠남 — 버림 확인 → 목록(되돌림)
+    items[1].click();
+    const ok = await until(
+      () =>
+        document.querySelector(
+          ".ui-confirm__actions .ui-button--danger, .ui-confirm__actions button:last-child",
+        ),
+      1500,
+    );
+    ok?.click();
+    const left = !!(await until(() => document.querySelector('[data-lib-list="precombo"]')));
+    return JSON.stringify({ picker, added, logic, sum, moved, sent, removed, left });
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-12_고르기_구분.js b/resources/tester/ui_checks/51-12_고르기_구분.js
new file mode 100644
index 000000000..9361d5031
--- /dev/null
+++ b/resources/tester/ui_checks/51-12_고르기_구분.js
@@ -0,0 +1,97 @@
+/* 51-12 — 로직 고르기 창 구분 · 상세구분 거름에 단가승격 · 사전조합 줄도 들어감
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 · item1 있음
+ * 부르는 법: orca eval --expression "$(tr '
+' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 하는 일: item1 → 일위대가 [수정] → [로직 추가] → 서고 줄마다 구분 · 상세구분으로 걸러 봄 → 창 닫음(저장 안 함)
+ * 기대 수치:
+ *   - libRows ≥ 2(SP-000001 · SC-000001 포함)
+ *   - lib[키].sub = 한 구분(빈 값 아님) · lib[키].detail = 한 상세구분 · lib[키].subText 에 둘이 다 보임
+ *   - lib[키].withLogic = true(같은 구분 칸에 단가산출 줄도 함께 — 같은 값은 한 칸)
+ *   - subDup = 0(구분 칸 겹침 없음)
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const out = {};
+  const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+  if (!node) return JSON.stringify({ error: "item1 없음" });
+  node.click();
+  const card = await until(() =>
+    [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+      c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+    ),
+  );
+  if (!card) return JSON.stringify({ error: "일위대가 카드 없음" });
+  [...card.querySelectorAll(".m02-struct__card-tools button")]
+    .find((b) => b.innerText.trim() === "수정")
+    ?.click();
+  const table = () =>
+    [...document.querySelectorAll("table.m02-labrow")].find(
+      (t) => !t.closest(".m02-struct__card") && t.querySelector("tr[data-labor-logic]"),
+    );
+  await until(() => table() && !/…/.test(table().querySelector("tbody").innerText), 12000);
+  const host = table().closest("[data-labor]");
+  [...host.querySelectorAll(".m01-logic__section-head button")]
+    .find((b) => b.innerText.trim() === "로직 추가")
+    .click();
+  const dlg = await until(() => document.querySelector(".m01-logic__pick"));
+  const rows = () => [...dlg.querySelectorAll(".ui-find__row")];
+  const isLib = (r) => r.querySelector(".ui-find__tag")?.innerText.trim() !== "단가산출";
+  await until(() => rows().some(isLib) && rows().some((r) => !isLib(r)), 20000);
+  await w(500);
+  const [subSel, detailSel] = dlg.querySelectorAll(".ui-find__filters select");
+  const set = async (sel, v) => {
+    sel.value = v;
+    sel.dispatchEvent(new Event("change", { bubbles: true }));
+    await w(120);
+  };
+  const libKeys = rows()
+    .filter(isLib)
+    .map((r) => r.dataset.pick);
+  out.libRows = libKeys.length;
+  const subVals = [...subSel.options].map((o) => o.value).filter(Boolean);
+  out.subDup = subVals.length - new Set(subVals).size;
+  const lib = {};
+  for (const k of libKeys)
+    lib[k] = {
+      subText: rows()
+        .find((r) => r.dataset.pick === k)
+        ?.querySelector(".ui-find__sub")?.innerText,
+      sub: [],
+      detail: [],
+      withLogic: false,
+    };
+  for (const s of subVals) {
+    await set(subSel, s);
+    const shown = rows();
+    const hasLogic = shown.some((r) => !isLib(r));
+    for (const r of shown.filter(isLib)) {
+      if (!lib[r.dataset.pick]) continue;
+      lib[r.dataset.pick].sub.push(s);
+      lib[r.dataset.pick].withLogic ||= hasLogic;
+    }
+    for (const d of [...detailSel.options].map((o) => o.value).filter(Boolean)) {
+      await set(detailSel, d);
+      for (const r of rows().filter(isLib)) lib[r.dataset.pick]?.detail.push(d);
+    }
+    await set(detailSel, "");
+  }
+  await set(subSel, "");
+  out.lib = lib;
+  [...dlg.querySelectorAll("button")].find((b) => b.innerText.trim() === "닫기")?.click();
+  out.closed = !document.querySelector(".m01-logic__pick");
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(800);
+  const ask = [...document.querySelectorAll(".ui-modal button, dialog button")].find((x) =>
+    /확인|버림|떠나기/.test(x.innerText),
+  );
+  ask?.click();
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/51-12_서고_구분.js b/resources/tester/ui_checks/51-12_서고_구분.js
new file mode 100644
index 000000000..52e315697
--- /dev/null
+++ b/resources/tester/ui_checks/51-12_서고_구분.js
@@ -0,0 +1,142 @@
+/* 51-12 — 서고(단가승격 · 사전조합) 구분 · 상세구분 · 연결
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=일위대가조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — GET · calc 밖 요청은 가짜 400(새로 만들기 POST 본문만 잡음) · 마스터 SP-000001 · SC-000001 읽기만
+ * 기대 수치:
+ *   - heads = ["", "키", "구분", "상세구분", "이름", ...] · listSP = SP-000001 줄 구분 · 상세구분 빈 것 아님
+ *   - promote = { 구분, 상세구분, 연결 } 셋 다 글 있음 · readOnly = true
+ *   - precombo = { selects: 2, 구분 = 문서 값 · subOptions ≥ 1 } · switched.상세구분 = 바꾼 구분의 첫 상세구분 · back = 처음 값
+ *   - created = { 구분: 목록 첫 구분, 상세구분: 그 첫 상세구분 }
+ *   - picker = 구분(SP-000001 것) 고르면 SP-000001 줄 보임 · 다른 구분이면 안 보임
+ */
+(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 6000) => {
+    for (let t = 0; t < ms; t += 100) {
+      const v = fn();
+      if (v) return v;
+      await wait(100);
+    }
+    return null;
+  };
+  const json = (body, status = 200) =>
+    new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+  const real = window.fetch;
+  let posted = null;
+  window.fetch = async (input, init = {}) => {
+    const url = String(input?.url ?? input);
+    const method = (init.method ?? "GET").toUpperCase();
+    if (method === "POST" && url.includes("/library/precombo")) {
+      posted = JSON.parse(init.body);
+      return json({ detail: "시험 — 쓰기 막음" }, 400);
+    }
+    if (method !== "GET" && !url.includes("/calc"))
+      return json({ detail: "시험 — 쓰기 막음" }, 400);
+    return real(input, init);
+  };
+  const sec = [...document.querySelectorAll(".m02-side__lists > section")].find(
+    (s) => s.querySelector(".ui-collapsible__title")?.textContent?.trim() === "일위대가 조합",
+  );
+  const items = [...sec.querySelectorAll("[data-precombo]")];
+  const list = (kind) => document.querySelector(`[data-lib-list="${kind}"]`);
+  const edit = () => document.querySelector(".m02-main__host [data-labor]");
+  const field = (name) => edit()?.querySelector(`[data-labor-field="${name}"]`);
+  const btn = (root, text) =>
+    [...(root?.querySelectorAll("button") ?? [])].find((b) => b.textContent === text);
+  const subs = await (
+    await real("/api/m02/logic-lib/subs", { credentials: "include" })
+  )
+    .json()
+    .then((d) => d.subs);
+  try {
+    // ① 승격 목록 · 상세
+    items[0].click();
+    const spRow = await until(() => list("promote")?.querySelector('[data-lib-key="SP-000001"]'));
+    const heads = [...list("promote").querySelectorAll("thead th")].map((th) => th.textContent);
+    const cells = [...spRow.querySelectorAll("td")].map((td) => td.textContent);
+    const listSP = { 구분: cells[2], 상세구분: cells[3] };
+    spRow.querySelector("td:nth-child(5)").click();
+    await until(() => field("연결"));
+    const val = (name) => field(name)?.querySelector("input")?.value ?? null;
+    const promote = {
+      구분: val("구분"),
+      상세구분: val("상세구분"),
+      연결: val("연결"),
+      readOnly: ["구분", "상세구분", "연결"].every(
+        (n) => field(n)?.querySelector("input")?.readOnly,
+      ),
+    };
+    // ② 사전조합 상세 — 고르기 · 바꿔 보고 되돌림
+    items[1].click();
+    (
+      await until(() =>
+        list("precombo")?.querySelector('[data-lib-key="SC-000001"] td:nth-child(5)'),
+      )
+    ).click();
+    const subSel = await until(() => field("구분")?.querySelector("select"));
+    await until(() => subSel.options.length > 1, 4000);
+    const detSel = field("상세구분").querySelector("select");
+    const start = { 구분: subSel.value, 상세구분: detSel.value };
+    const precombo = {
+      selects: edit().querySelectorAll(".m01lab__info select").length,
+      ...start,
+      subOptions: subSel.options.length,
+    };
+    const other = subs.find((s) => s.name !== start.구분 && s.details.length);
+    subSel.value = other.name;
+    subSel.dispatchEvent(new Event("change"));
+    const switched = {
+      구분: field("구분").querySelector("select").value,
+      상세구분: field("상세구분").querySelector("select").value,
+      want: other.details[0],
+    };
+    const s2 = field("구분").querySelector("select");
+    s2.value = start.구분;
+    s2.dispatchEvent(new Event("change"));
+    const d2 = field("상세구분").querySelector("select");
+    d2.value = start.상세구분;
+    d2.dispatchEvent(new Event("change"));
+    const back = {
+      구분: field("구분").querySelector("select").value,
+      상세구분: field("상세구분").querySelector("select").value,
+    };
+    // ③ 고르기 창 — 구분 거름에 승격 줄
+    btn(edit(), "로직 추가").click();
+    const pick = await until(() => document.querySelector(".m01-logic__pick"));
+    await until(() => pick.querySelector('[data-pick="SP-000001"]'), 20000);
+    const [fSub, fDet] = pick.querySelectorAll(".ui-find__filters select");
+    const pickerWith = async (s, d) => {
+      fSub.value = s;
+      fSub.dispatchEvent(new Event("change"));
+      if (d != null) {
+        fDet.value = d;
+        fDet.dispatchEvent(new Event("change"));
+      }
+      await wait(100);
+      return !!pick.querySelector('[data-pick="SP-000001"]');
+    };
+    const picker = {
+      same: await pickerWith(promote.구분, promote.상세구분),
+      other: await pickerWith(subs.find((s) => s.name !== promote.구분)?.name ?? "", null),
+    };
+    pick.closest(".m01-logic__backdrop")?.remove();
+    // ④ 새 사전조합 처음 값(POST 본문만 잡음)
+    items[1].click();
+    await until(() => list("precombo"));
+    btn(document.querySelector(".m02-main__slot"), "생성").click();
+    const box = await until(() => document.querySelector(".m02-modal"));
+    box.querySelector("input").value = "시험 51-12";
+    btn(box, "만들기").click();
+    await until(() => posted);
+    btn(document.querySelector(".m02-modal"), "닫기")?.click();
+    document.querySelector(".m02-modal")?.closest(".ui-modal__backdrop, .ui-modal")?.remove();
+    const created = {
+      구분: posted?.문서?.구분,
+      상세구분: posted?.문서?.상세구분,
+      want: [subs[0].name, subs[0].details[0] ?? null],
+    };
+    return JSON.stringify({ heads, listSP, promote, precombo, switched, back, picker, created });
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-13_일위조합_하위행.js b/resources/tester/ui_checks/51-13_일위조합_하위행.js
new file mode 100644
index 000000000..c40dc1b7b
--- /dev/null
+++ b/resources/tester/ui_checks/51-13_일위조합_하위행.js
@@ -0,0 +1,132 @@
+/* 51-13 — 일위대가 표 구분 「일위조합」 줄 누름 = 하위 행 = 그 조합 세부 항목 한 층(참조 줄 · 로직 줄 51-11) — 카드 · 상세 두 곳
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item3(단가승격 SP-000001 · 일위조합 SC-000001 줄이 있음)
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — item3 calc 답만 바꿔 끼움(fetch · 끝에 되돌림): SC 줄 「안」 = [SP-000001 × 2 · 첫 단가산출 로직 줄 × 1.5]
+ *   (안 줄 기준 = 같은 답의 그 줄 기준 · SC 기준 = 안 기준 × 수량 합 · SC 수량 손 3 · 반영 = 기준 × 3 · 서고 저장 없음)
+ * 기대 수치(카드 · 상세 같음):
+ *   - sc.subs = sc.inner(2) · sc.cells = [head] · sc.next = true
+ *   - sc.base ≈ sc.subBase(위 줄 기준 = 하위 합 · 반올림 차 ≤ 2) · sc.applied ≈ sc.subApplied ≈ sc.base × 3
+ *   - sc.names[0] 「SP-000001 …」 · sc.names[1] 「<로직 키>」(로직 줄 · 깨지지 않음)
+ *   - sc.qty = ["2", "1.5"](안 줄 수량) · sp.subs ≥ 1(단가승격 하위 행 그대로)
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const SC = "참조|system||SC-000001";
+  const SP = "참조|system||SP-000001";
+  const KEYS = ["노무비", "재료비", "경비", "계"];
+  const real = window.fetch;
+  let inner = 0;
+  window.fetch = async (input, init) => {
+    const res = await real(input, init);
+    const url = typeof input === "string" ? input : input.url;
+    if (!/\/labor\/item3\/calc/.test(url) || !res.ok) return res;
+    const j = await res.clone().json();
+    const sc = j.줄.find((l) => l.참조?.키 === "SC-000001");
+    const sp = j.줄.find((l) => l.참조?.키 === "SP-000001");
+    const lg = j.줄.find((l) => !l.참조 && l.기준);
+    if (sc && sp?.기준 && lg) {
+      sc.안 = [
+        { 참조: sp.참조, 수량: 2, 이름: sp.이름, 단위: sp.분모, 기준: sp.기준, 까닭: null },
+        { 로직: lg.로직, 수량: 1.5, 이름: lg.로직, 단위: null, 기준: lg.기준, 까닭: null },
+      ];
+      sc.기준 = Object.fromEntries(KEYS.map((k) => [k, sp.기준[k] * 2 + lg.기준[k] * 1.5]));
+      Object.assign(sc, { 수량: 3, 수량출처: "손" }); // 위 줄 수량 3 — 반영 = 기준 × 3
+      sc.반영 = Object.fromEntries(KEYS.map((k) => [k, sc.기준[k] * 3]));
+      inner = sc.안.length;
+    }
+    return new Response(JSON.stringify(j), { status: 200, headers: res.headers });
+  };
+  const n = (s) => Number(String(s ?? "").replace(/[^0-9.-]/g, "")) || 0;
+  const total = (tr, part) => {
+    const tds = tr.querySelectorAll(".m02-labrow__money");
+    return n(tds[tds.length - 1].querySelector(part).innerText);
+  };
+  const settled = (get) =>
+    until(() => {
+      const t = get();
+      return t && !/…/.test(t.querySelector("tbody").innerText) ? t : null;
+    }, 10000);
+  const open = async (get, key) => {
+    get().querySelector(`tr[data-labor-logic="${key}"] .m02-labrow__name`).click();
+    await w(300);
+    const tb = get();
+    const tr = tb.querySelector(`tr[data-labor-logic="${key}"]`);
+    const subs = [...tb.querySelectorAll("tbody tr[data-labor-sub]")];
+    let at = tr.nextElementSibling;
+    if (at?.hasAttribute("data-labor-opt")) at = at.nextElementSibling;
+    return { tb, tr, subs, next: at === subs[0] };
+  };
+  const measure = async (get) => {
+    const t = await settled(get);
+    const head = t.querySelectorAll("thead th").length;
+    const sp = await open(get, SP);
+    const { tr, subs, next } = await open(get, SC);
+    const out = {
+      head,
+      sp: { subs: sp.subs.length },
+      sc: {
+        inner,
+        subs: subs.length,
+        next,
+        cells: [
+          ...new Set(subs.map((s) => [...s.children].reduce((a, c) => a + (c.colSpan || 1), 0))),
+        ],
+        base: total(tr, ".m02-labrow__base"),
+        subBase: Math.round(subs.reduce((a, s) => a + total(s, ".m02-labrow__base"), 0)),
+        applied: total(tr, ".m02-labrow__applied"),
+        subApplied: Math.round(subs.reduce((a, s) => a + total(s, ".m02-labrow__applied"), 0)),
+        names: subs.map((s) => s.querySelector(".m02-labrow__subname").innerText),
+        qty: subs.map((s) => s.querySelector(".m02-labrow__qty").innerText),
+        units: subs.map((s) => s.querySelector(".m02-labrow__unit").innerText),
+      },
+    };
+    await open(get, SC); // 같은 줄 다시 = 닫힘
+    return out;
+  };
+  try {
+    const node = await until(() => document.querySelector('[data-node="i|item3"]'));
+    if (!node) return JSON.stringify({ error: "item3 없음 — 폴더를 펼쳐 둘 것" });
+    document.querySelector('[data-node="i|item1"]')?.click(); // 다시 읽게 다른 항목 거침
+    await w(1500);
+    node.click();
+    const card = await until(() =>
+      [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+        c.querySelector(`table.m02-labrow tbody tr[data-labor-logic="${SC}"]`),
+      ),
+    );
+    if (!card) return JSON.stringify({ error: "일위조합 줄 카드 없음" });
+    await w(1500);
+    const out = { card: await measure(() => card.querySelector("table.m02-labrow")) };
+    const edit = [...card.querySelectorAll(".m02-struct__card-tools button")].find(
+      (b) => b.innerText.trim() === "수정",
+    );
+    if (!edit) return JSON.stringify({ ...out, error: "일위대가 [수정] 없음" });
+    edit.click();
+    const detail = () =>
+      [...document.querySelectorAll("table.m02-labrow")].find(
+        (t) => !t.closest(".m02-struct__card") && t.querySelector(`tr[data-labor-logic="${SC}"]`),
+      );
+    if (!(await until(detail))) return JSON.stringify({ ...out, error: "상세 표 없음" });
+    await w(2000);
+    out.detail = await measure(detail);
+    document.querySelector('[data-node="i|item3"]')?.click();
+    await w(800);
+    [...document.querySelectorAll(".ui-modal button, dialog button")]
+      .find((b) => /확인|버림|떠나기/.test(b.innerText))
+      ?.click();
+    await w(1200);
+    out.back = !!document.querySelector(".m02-struct__card table.m02-labrow");
+    return JSON.stringify(out);
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-14_순서칸_2행_옵션수정.js b/resources/tester/ui_checks/51-14_순서칸_2행_옵션수정.js
new file mode 100644
index 000000000..19f94dc3a
--- /dev/null
+++ b/resources/tester/ui_checks/51-14_순서칸_2행_옵션수정.js
@@ -0,0 +1,159 @@
+/* 51-14 — 일위대가 표 순서 칸 2행(위 [위로] [아래로] / 아래 [옵션]·[수정] [삭제]) · 단가승격 [옵션] · 일위조합 [수정] 모달
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item3(단가승격 SP-000001 · 일위조합 SC-000001 줄이 있음)
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — 모달은 모두 [취소]로 닫음 · PUT 수 = 0 확인(서고 저장 안 함)
+ * 기대 수치:
+ *   - card.sp / card.sc: groups 1 · labels [옵션, 삭제] / [수정, 삭제]
+ *   - detail.sp / detail.sc: groups 2 · top [위로, 아래로] · bottom [옵션, 삭제] / [수정, 삭제] · danger = 삭제
+ *   - promote: notice 있음 · foot [취소, 저장] · closed = true
+ *   - combo: notice 있음 · add [로직 추가] · foot [취소, 저장] — 모달 안 [로직 추가]로 단가산출 한 줄 넣음(화면만) ·
+ *     added.groups 2 · top [위로, 아래로] · bottom [옵션, 삭제] · [취소] = 버림 물음(asked) → 확인 · closed = true · recalc ≥ 1
+ *   - puts = 0
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const SC = "참조|system||SC-000001";
+  const SP = "참조|system||SP-000001";
+  const real = window.fetch;
+  let puts = 0;
+  let calcs = 0;
+  window.fetch = (input, init) => {
+    const url = typeof input === "string" ? input : input.url;
+    if ((init?.method ?? "GET").toUpperCase() === "PUT") puts++;
+    if (/\/labor\/item3\/calc/.test(url)) calcs++;
+    return real(input, init);
+  };
+  const txt = (b) => b.innerText.trim();
+  const tools = (tb, key) => {
+    const cell = tb.querySelector(`tr[data-labor-logic="${key}"] .m02-labrow__move`);
+    const groups = [...cell.querySelectorAll(".m02-labrow__tools > .ui-btn-group")];
+    const btn = (g) => [...g.querySelectorAll("button")];
+    const last = groups.at(-1) ? btn(groups.at(-1)).at(-1) : null;
+    return {
+      groups: groups.length,
+      top: groups.length > 1 ? btn(groups[0]).map(txt) : [],
+      bottom: groups.length ? btn(groups.at(-1)).map(txt) : [],
+      danger: last ? last.className : "",
+      _btn: (label) => groups.flatMap(btn).find((b) => txt(b) === label),
+    };
+  };
+  const clean = (t) => {
+    delete t._btn;
+    return t;
+  };
+  const modal = () => [...document.querySelectorAll(".ui-modal")].at(-1) ?? null;
+  const foot = (m) => [...m.querySelectorAll(".m02-labin__foot button")].map(txt);
+  const cancel = async (m) => {
+    [...m.querySelectorAll(".m02-labin__foot button")].find((b) => txt(b) === "취소").click();
+    await w(600);
+    return !document.body.contains(m);
+  };
+  try {
+    const node = await until(() => document.querySelector('[data-node="i|item3"]'));
+    if (!node) return JSON.stringify({ error: "item3 없음 — 폴더를 펼쳐 둘 것" });
+    document.querySelector('[data-node="i|item1"]')?.click(); // 다시 읽게 다른 항목 거침
+    await w(1500);
+    node.click();
+    const card = await until(() =>
+      [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+        c.querySelector(`table.m02-labrow tbody tr[data-labor-logic="${SC}"]`),
+      ),
+    );
+    if (!card) return JSON.stringify({ error: "일위조합 줄 카드 없음" });
+    await w(1500);
+    const ct = card.querySelector("table.m02-labrow");
+    const out = { card: { sp: clean(tools(ct, SP)), sc: clean(tools(ct, SC)) } };
+    const edit = [...card.querySelectorAll(".m02-struct__card-tools button")].find(
+      (b) => txt(b) === "수정",
+    );
+    if (!edit) return JSON.stringify({ ...out, error: "일위대가 [수정] 없음" });
+    edit.click();
+    const detail = () =>
+      [...document.querySelectorAll("table.m02-labrow")].find(
+        (t) =>
+          !t.closest(".m02-struct__card, .ui-modal") &&
+          t.querySelector(`tr[data-labor-logic="${SC}"]`),
+      );
+    if (!(await until(detail))) return JSON.stringify({ ...out, error: "상세 표 없음" });
+    await w(2000);
+    const sp = tools(detail(), SP);
+    const sc = tools(detail(), SC);
+    out.detail = { sp: clean({ ...sp }), sc: clean({ ...sc }) };
+
+    // 단가승격 [옵션] — 넣을 값 모달 · 알림 한 줄 · [취소]
+    sp._btn("옵션").click();
+    const pm = await until(() => modal()?.querySelector(".m02-inputval") && modal());
+    out.promote = pm
+      ? {
+          title: pm.querySelector(".ui-modal__top h3").innerText,
+          notice: !!pm.querySelector("[data-labor-notice]"),
+          inputs: pm.querySelectorAll("[data-labor-input]").length,
+          foot: foot(pm),
+          closed: await cancel(pm),
+        }
+      : { error: "승격 모달 없음" };
+
+    // 일위조합 [수정] — 사전조합 상세 모달 · [취소] · 닫으면 다시 셈
+    tools(detail(), SC)._btn("수정").click();
+    const cm = await until(() => document.querySelector(".m02-labref"));
+    if (!cm) return JSON.stringify({ ...out, error: "일위조합 모달 없음", puts });
+    await w(1000);
+    out.combo = {
+      title: cm.querySelector(".ui-modal__top h3").innerText,
+      notice: !!cm.querySelector("[data-labor-notice]"),
+      rows0: cm.querySelectorAll("table.m02-labrow tbody tr[data-labor-logic]").length,
+      add: [...cm.querySelectorAll(".m01-logic__section-head button")].map(txt),
+      foot: foot(cm),
+    };
+    // 모달 안 [로직 추가] → 단가산출 첫 줄(화면 캐시만)
+    [...cm.querySelectorAll(".m01-logic__section-head button")]
+      .find((b) => txt(b) === "로직 추가")
+      .click();
+    const pick = await until(
+      () =>
+        [...document.querySelectorAll(".m01-logic__pick .ui-find__row")].find(
+          (r) => r.querySelector(".ui-find__tag")?.innerText.trim() === "단가산출",
+        ),
+      30000, // 로직 목록 1천여 줄
+    );
+    if (!pick) return JSON.stringify({ ...out, error: "고르기 줄 없음", puts });
+    pick.click();
+    const added = await until(() =>
+      cm.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+    );
+    if (added) {
+      const key = added.getAttribute("data-labor-logic");
+      out.combo.added = clean(tools(cm.querySelector("table.m02-labrow"), key));
+    }
+    const before = calcs;
+    [...cm.querySelectorAll(".m02-labin__foot button")].find((b) => txt(b) === "취소").click();
+    const ask = await until(() => document.querySelector(".ui-confirm"));
+    out.combo.asked = !!ask;
+    [...(ask?.querySelectorAll("button") ?? [])].find((b) => txt(b) === "확인")?.click();
+    await w(600);
+    out.combo.closed = !document.body.contains(cm);
+    await w(1200);
+    out.combo.recalc = calcs - before;
+    out.puts = puts;
+
+    document.querySelector('[data-node="i|item3"]')?.click();
+    await w(800);
+    [...document.querySelectorAll(".ui-modal button, dialog button")]
+      .find((b) => /확인|버림|떠나기/.test(b.innerText))
+      ?.click();
+    await w(1200);
+    out.back = !!document.querySelector(".m02-struct__card table.m02-labrow");
+    return JSON.stringify(out);
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-1_오른쪽패널_높이.js b/resources/tester/ui_checks/51-1_오른쪽패널_높이.js
new file mode 100644
index 000000000..1a447c13b
--- /dev/null
+++ b/resources/tester/ui_checks/51-1_오른쪽패널_높이.js
@@ -0,0 +1,63 @@
+/* 51-1 — 오른쪽 패널(공용 ui_template_side_panels) 높이 = innerHeight − 머리띠 · 스크롤 처음/중간/끝 화면 안
+ * 시작 화면: 패널이 이미 열린 상세 화면 하나(M02 일위대가 상세 · M02 면적산출 · M01 로직 상세 중 하나) · 화면마다 한 번씩 부름
+ * 부르는 법: orca eval --expression "$(tr '\n' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 기대: ok = true · h = want(innerHeight − max(머리띠, 칸 위)) ±2 · 칸이 올라가 붙은 뒤는 innerHeight − 머리띠 · inView = 그대로·처음·중간·끝 모두 true
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const sp = [...document.querySelectorAll(".ui-side-panels")].find(
+    (s) => !s.classList.contains("is-collapsed") && s.getClientRects().length,
+  );
+  if (!sp) return JSON.stringify({ error: "펴진 패널 없음" });
+  const head = document.querySelector(".app-header")?.getBoundingClientRect().bottom ?? 0;
+  const scroller = (() => {
+    for (let n = sp.parentElement; n; n = n.parentElement) {
+      const y = getComputedStyle(n).overflowY;
+      if ((y === "auto" || y === "scroll") && n.scrollHeight > n.clientHeight + 1) return n;
+    }
+    return document.scrollingElement;
+  })();
+  const max = scroller.scrollHeight - scroller.clientHeight;
+  const sample = async (name, y) => {
+    scroller.scrollTop = y;
+    window.dispatchEvent(new Event("scroll")); // 뒤에 가린 탭은 스크롤 알림이 안 와서 직접
+    await w(150);
+    const r = sp.getBoundingClientRect();
+    const want = Math.round(
+      innerHeight - Math.max(head, sp.parentElement.getBoundingClientRect().top),
+    );
+    const body = sp.querySelector(".ui-side-panels__panel:not([hidden]) .ui-side-panels__body");
+    return {
+      name,
+      top: Math.round(r.top),
+      bottom: Math.round(r.bottom),
+      h: Math.round(r.height),
+      want,
+      inView: r.top >= head - 2 && r.bottom <= innerHeight + 2,
+      bodyScrolls: body ? body.scrollHeight > body.clientHeight : null,
+    };
+  };
+  const was = scroller.scrollTop;
+  // 스크롤 알림 없이 지금 높이 — 내용이 늦게 차도 스스로 다시 쟀는지(알림을 쏘면 가려짐 · 가린 탭은 먼저 orca screenshot 으로 한 장 그림)
+  const r0 = sp.getBoundingClientRect();
+  const still = {
+    name: "그대로",
+    h: Math.round(r0.height),
+    want: Math.round(innerHeight - Math.max(head, sp.parentElement.getBoundingClientRect().top)),
+    inView: r0.top >= head - 2 && r0.bottom <= innerHeight + 2,
+  };
+  const rows = [
+    still,
+    await sample("처음", 0),
+    await sample("중간", Math.round(max / 2)),
+    await sample("끝", max),
+  ];
+  scroller.scrollTop = was;
+  return JSON.stringify({
+    innerHeight,
+    head: Math.round(head),
+    scrollMax: Math.round(max),
+    rows,
+    ok: rows.every((r) => Math.abs(r.h - r.want) <= 2 && r.inView),
+  });
+})();
diff --git a/resources/tester/ui_checks/51-2_줄_하위행.js b/resources/tester/ui_checks/51-2_줄_하위행.js
new file mode 100644
index 000000000..0971db5b7
--- /dev/null
+++ b/resources/tester/ui_checks/51-2_줄_하위행.js
@@ -0,0 +1,114 @@
+/* 51-2 — 일위대가 단가산출 로직 표 줄 누름 = 그 줄 바로 아래 하위 행(같은 표 · 같은 칸 · 접고 폄) — 카드 · 상세 두 곳
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 ·
+ *   나무에 item1(구조물 조합 · 일위대가 로직 둘 이상)이 있음
+ * 부르는 법: orca eval --expression "$(tr '\n' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 하는 일: item1 카드 표 줄마다 누름(하위 행 셈) · 같은 줄 다시 → 일위대가 카드 [수정]으로 상세 → 같은 차례 → item1 다시
+ * 기대 수치(카드 · 상세 같음):
+ *   - lines[*].subs ≥ 1 · lines[*].cells = head(칸 수 = 머리 칸 수) · lines[*].next = true(고른 줄 바로 아래)
+ *   - lines[*].base ≈ lines[*].subBase · lines[*].applied ≈ lines[*].subApplied(반올림 차 ≤ 하위 행 수)
+ *   - lines[*].open = 1(한 줄만 열림) · lines[*].arrow = 0(이름 앞 화살표 없음 · 51-7)
+ *   - lines[*].font = 하위 행 이름 글자 px · lines[*].h = 하위 행 높이 px · lines[*].topH = 위 줄 높이 px(51-7 촘촘)
+ *     전 font 12 · h 61 · 칸 여백 12/16 → 후 font 14 · h 40 · 칸 여백 4/8(위 줄 font 16 · topH 85 그대로)
+ *   - again.subs = 0 · again.selected = 0(같은 줄 다시 = 닫힘) · box = 0(따로 상자 없음)
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const n = (s) => Number(String(s ?? "").replace(/[^0-9.-]/g, "")) || 0;
+  const rowsOf = (t) => [...t.querySelectorAll("tbody tr[data-labor-logic]")];
+  const settled = (get) =>
+    until(() => {
+      const t = get();
+      return t && !/…/.test(t.querySelector("tbody").innerText) ? t : null;
+    }, 10000);
+  const total = (tr, part) => {
+    const tds = tr.querySelectorAll(".m02-labrow__money");
+    return n(tds[tds.length - 1].querySelector(part).innerText);
+  };
+  const measure = async (get) => {
+    const t = await settled(get);
+    const head = t.querySelectorAll("thead th").length;
+    const keys = rowsOf(t).map((r) => r.getAttribute("data-labor-logic"));
+    const click = async (key) => {
+      get().querySelector(`tr[data-labor-logic="${key}"] .m02-labrow__name`).click();
+      await w(300);
+    };
+    const lines = [];
+    for (const key of keys) {
+      await click(key);
+      const tb = get();
+      const tr = tb.querySelector(`tr[data-labor-logic="${key}"]`);
+      const subs = [...tb.querySelectorAll("tbody tr[data-labor-sub]")];
+      /* 고른 줄 바로 아래 — 옵션 값 줄(있으면) 다음이 하위 행 */
+      let at = tr.nextElementSibling;
+      if (at?.hasAttribute("data-labor-opt")) at = at.nextElementSibling;
+      lines.push({
+        key,
+        subs: subs.length,
+        next: at === subs[0],
+        cells: [
+          ...new Set(subs.map((s) => [...s.children].reduce((a, c) => a + (c.colSpan || 1), 0))),
+        ],
+        base: total(tr, ".m02-labrow__base"),
+        subBase: Math.round(subs.reduce((a, s) => a + total(s, ".m02-labrow__base"), 0)),
+        applied: total(tr, ".m02-labrow__applied"),
+        subApplied: Math.round(subs.reduce((a, s) => a + total(s, ".m02-labrow__applied"), 0)),
+        open: rowsOf(tb).filter((r) => r.classList.contains("is-selected")).length,
+        arrow: [...tb.querySelectorAll(".m02-labrow__name")].filter((d) => /[▸▾]/.test(d.innerText))
+          .length,
+        font: parseFloat(getComputedStyle(subs[0].querySelector(".m02-labrow__subname")).fontSize),
+        h: Math.round(subs[0].getBoundingClientRect().height),
+        topH: Math.round(tr.getBoundingClientRect().height),
+        names: subs.map((s) => s.querySelector(".m02-labrow__subname").innerText).slice(0, 4),
+      });
+    }
+    await click(keys[keys.length - 1]);
+    const again = {
+      subs: get().querySelectorAll("tbody tr[data-labor-sub]").length,
+      selected: rowsOf(get()).filter((r) => r.classList.contains("is-selected")).length,
+    };
+    return { head, lines, again, box: document.querySelectorAll("[data-labor-linedet]").length };
+  };
+  const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+  if (!node) return JSON.stringify({ error: "item1 없음 — 폴더를 펼쳐 둘 것" });
+  node.click();
+  const card = await until(() =>
+    [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+      c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+    ),
+  );
+  if (!card) return JSON.stringify({ error: "일위대가 카드 표 없음" });
+  await w(1500);
+  const out = { card: await measure(() => card.querySelector("table.m02-labrow")) };
+  const edit = [...card.querySelectorAll(".m02-struct__card-tools button")].find(
+    (b) => b.innerText.trim() === "수정",
+  );
+  if (!edit) return JSON.stringify({ ...out, error: "일위대가 [수정] 없음" });
+  edit.click();
+  const dt = await until(() =>
+    [...document.querySelectorAll("table.m02-labrow")].find(
+      (t) => !t.closest(".m02-struct__card") && t.querySelector("tbody tr[data-labor-logic]"),
+    ),
+  );
+  if (!dt) return JSON.stringify({ ...out, error: "상세 표 없음" });
+  await w(2000);
+  out.detail = await measure(() =>
+    [...document.querySelectorAll("table.m02-labrow")].find((t) => !t.closest(".m02-struct__card")),
+  );
+  /* 카드 화면으로 돌아감(고름만 했으니 버림 물음 없음 — 뜨면 확인) */
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(800);
+  [...document.querySelectorAll(".ui-modal button, dialog button")]
+    .find((b) => /확인|버림|떠나기/.test(b.innerText))
+    ?.click();
+  await w(1200);
+  out.back = !!document.querySelector(".m02-struct__card table.m02-labrow");
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/51-3_고르기_한목록.js b/resources/tester/ui_checks/51-3_고르기_한목록.js
new file mode 100644
index 000000000..d1bf582bc
--- /dev/null
+++ b/resources/tester/ui_checks/51-3_고르기_한목록.js
@@ -0,0 +1,171 @@
+/* 51-3 — 일위대가 상세 [로직 추가] 고르기 창 한 목록(찾기 단추 · 탭 없음 · 구분 칸 · 치는 대로 걸러짐)
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 · item1 있음
+ * 부르는 법: orca eval --expression "$(tr '
+' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 공유 마스터에 서고 문서를 안 씀 — 이 탭 fetch 만 바꿔 끼움(층 목록 = 가짜 SP-990001 · SC-990001 더함 · 끝나면 되돌림)
+ * 하는 일: item1 → 일위대가 [수정] → [로직 추가] → 목록 점검 → "SP-990001" 침 → 고름 → 표 구분 · 삭제(저장 안 함)
+ * 기대 수치:
+ *   - tabs = 0 · findBtn = 0 · kinds 에 "단가산출" · "단가승격" · "일위조합" 셋 다 · layers = ["마스터"]
+ *   - typed = ["SP-990001"] · typedKinds = ["단가승격"]
+ *   - added.kinds = ["단가승격"] · added.keys = ["SP-990001"] · removed = true · askedLeave = false · back = true
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const n = (s) => Number(String(s ?? "").replace(/[^0-9.-]/g, "")) || 0;
+  const SP = { 층: "system", 주인: null, 키: "SP-990001" };
+  const SC = { 층: "system", 주인: null, 키: "SC-990001" };
+  const rid = (r) => `참조|${r.층}|${r.주인 ?? ""}|${r.키}`;
+  const real = window.fetch;
+  let first = null;
+  window.fetch = async (url, init) => {
+    const u = String(url);
+    if (/\/layers\/system\/templates$/.test(u)) {
+      const got = await (await real(url, init)).json();
+      got.양식.push(
+        { 종류: "promote", 이름: SP.키, 제목: "시험 승격", 단위: "㎡" },
+        { 종류: "precombo", 이름: SC.키, 제목: "시험 조합", 단위: "식" },
+      );
+      return new Response(JSON.stringify(got), { status: 200 });
+    }
+    if (/\/labor\/[^/]+\/calc/.test(u) && init?.body) {
+      const body = JSON.parse(init.body);
+      const refs = (body.doc?.담은로직 ?? []).filter((r) => r.참조);
+      if (!refs.length) return real(url, init);
+      body.doc.담은로직 = body.doc.담은로직.filter((r) => !r.참조);
+      const got = await (await real(url, { ...init, body: JSON.stringify(body) })).json();
+      first = got.줄[0];
+      for (const r of refs) {
+        const base = { ...first.기준 };
+        const line = {
+          참조: r.참조,
+          이름: r.참조.키 === SP.키 ? "시험 승격" : "시험 조합",
+          알약: rid(r.참조),
+          분모: "㎡",
+          배: 1,
+          기준: base,
+          반영: null,
+          수량: null,
+          수량출처: "없음",
+          까닭: null,
+        };
+        if (r.참조.키 === SP.키) Object.assign(line, { 원로직: first.로직, 줄: first.줄 });
+        else
+          line.안 = [{ 참조: SP, 수량: 1, 이름: "시험 승격", 단위: "㎡", 기준: base, 까닭: null }];
+        got.줄.push(line);
+      }
+      return new Response(JSON.stringify(got), { status: 200 });
+    }
+    return real(url, init);
+  };
+  const out = {};
+  try {
+    const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+    if (!node) return JSON.stringify({ error: "item1 없음" });
+    node.click();
+    const card = await until(() =>
+      [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+        c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+      ),
+    );
+    if (!card) return JSON.stringify({ error: "일위대가 카드 없음" });
+    [...card.querySelectorAll(".m02-struct__card-tools button")]
+      .find((b) => b.innerText.trim() === "수정")
+      ?.click();
+    const table = () =>
+      [...document.querySelectorAll("table.m02-labrow")].find(
+        (t) => !t.closest(".m02-struct__card") && t.querySelector("tr[data-labor-logic]"),
+      );
+    await until(() => table() && !/…/.test(table().querySelector("tbody").innerText), 12000);
+    const host = table().closest("[data-labor]");
+    const before = table().querySelectorAll("tbody tr[data-labor-logic]").length;
+    [...host.querySelectorAll(".m01-logic__section-head button")]
+      .find((b) => b.innerText.trim() === "로직 추가")
+      .click();
+    const dlg = await until(() => document.querySelector(".m01-logic__pick"));
+    await until(
+      () =>
+        dlg.querySelector(`[data-pick="${SP.키}"]`) &&
+        [...dlg.querySelectorAll("[data-pick-kind]")].some(
+          (k) => k.innerText.trim() === "단가산출",
+        ),
+    );
+    const kinds = () =>
+      [...dlg.querySelectorAll("[data-pick-kind]")].map((k) => k.innerText.trim());
+    out.tabs = dlg.querySelectorAll("[data-pick-tabs]").length;
+    out.findBtn = [...dlg.querySelectorAll("button")].filter(
+      (b) => b.innerText.trim() === "찾기",
+    ).length;
+    out.kinds = [...new Set(kinds())];
+    out.total = dlg.querySelectorAll("[data-pick]").length;
+    out.layers = [...dlg.querySelectorAll("[data-pick-layers] button")].map((b) =>
+      b.innerText.trim(),
+    );
+    const search = dlg.querySelector('input[type="search"]');
+    search.value = "SP-990001";
+    search.dispatchEvent(new Event("input", { bubbles: true }));
+    await w(200);
+    out.typed = [...dlg.querySelectorAll("[data-pick]")].map((b) => b.dataset.pick);
+    out.typedKinds = kinds();
+    dlg.querySelector(`[data-pick="${SP.키}"]`).click();
+    await until(
+      () =>
+        table()?.querySelector(`tr[data-labor-logic="${rid(SP)}"]`) &&
+        !/…/.test(table().querySelector("tbody").innerText),
+      12000,
+    );
+    const rows = [...table().querySelectorAll("tbody tr[data-labor-logic]")];
+    out.added = {
+      kinds: rows.slice(-1).map((r) => r.querySelector(".m02-labrow__kind").innerText.trim()),
+      keys: rows.slice(-1).map((r) => r.querySelector(".m02-labrow__key").innerText.trim()),
+      optBtn: rows
+        .slice(-1)
+        .flatMap((r) =>
+          [...r.querySelectorAll("button")].filter((b) => b.innerText.trim() === "옵션"),
+        ).length,
+    };
+    const open = async (ref) => {
+      table()
+        .querySelector(`tr[data-labor-logic="${rid(ref)}"] .m02-labrow__name`)
+        .click();
+      await w(300);
+      return host.querySelector("[data-labor-linedet]");
+    };
+    let det = await open(SP);
+    const grid = det.querySelector("table.m01-logic__grid");
+    out.promote = {
+      from: det.querySelector("p")?.innerText.trim(),
+      rows: grid?.querySelectorAll("tbody tr").length ?? 0,
+      sum: [...(grid?.querySelectorAll("tbody tr") ?? [])].reduce(
+        (a, r) => a + n(r.lastElementChild.innerText),
+        0,
+      ),
+      firstBase: first?.기준?.계 ?? null,
+    };
+    for (const ref of [SP]) {
+      const tr = table().querySelector(`tr[data-labor-logic="${rid(ref)}"]`);
+      [...tr.querySelectorAll("button")].find((b) => b.innerText.trim() === "삭제").click();
+      await w(600);
+    }
+    out.removed = table().querySelectorAll("tbody tr[data-labor-logic]").length === before;
+  } finally {
+    window.fetch = real;
+  }
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(800);
+  const ask = [...document.querySelectorAll(".ui-modal button, dialog button")].find((b) =>
+    /확인|버림|떠나기/.test(b.innerText),
+  );
+  out.askedLeave = !!ask; /* 저장 안 한 고침이 남았으면 물음 — 지운 뒤라 없어야 함 */
+  ask?.click();
+  await w(1200);
+  out.back = !!document.querySelector(".m02-struct__card table.m02-labrow");
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/51-4_서고_목록표.js b/resources/tester/ui_checks/51-4_서고_목록표.js
new file mode 100644
index 000000000..767aa03a9
--- /dev/null
+++ b/resources/tester/ui_checks/51-4_서고_목록표.js
@@ -0,0 +1,153 @@
+/* 51-4 — M02 좌측 「일위대가 조합」 = 층 단추 + 항목 둘 · 항목 누름 = 상세 목록표 · 머리 [생성] · [복사] · [삭제]
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=일위대가조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — 서고 목록 · 문서 읽기 · 지우기는 가짜 응답(fetch 바꿔 끼움 · 끝에 되돌림) · 새로 창은 열고 닫기만
+ * 기대 수치:
+ *   - side.items = ["단가산출 승격", "일위대가 사전조합"] · side.otherButtons = 0(새로 · 본떠 · 지우기 없음)
+ *   - promote.heads = ["", "키", "이름", "단위", "기준 금액", "고친 날"] · rows = 2 · base = ["1,234.5", ""]
+ *   - promote.tools = ["생성", "복사", "삭제"] · disabledBefore = [false, true, true] · disabledAfter = [false, false, false]
+ *   - promote.active = true(좌측 항목 고름) · picker = true(생성 = 로직 고르기 창)
+ *   - blocked = 쓰는 곳 까닭 알림 · rowsAfterBlocked = 2
+ *   - open = { title: "SP-999901 시험 승격", name: "시험 승격" }(줄 누름 = 그 문서 상세)
+ *   - precombo.rows = 1 · dialog = true(생성 = 이름 창)
+ */
+(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 4000) => {
+    for (let t = 0; t < ms; t += 100) {
+      const v = fn();
+      if (v) return v;
+      await wait(100);
+    }
+    return null;
+  };
+  const rows = [
+    {
+      종류: "promote",
+      이름: "SP-999901",
+      판: "a",
+      수정일: "2026-10-05T10:00:00",
+      제목: "시험 승격",
+      단위: "㎡",
+      기준금액: 1234.5,
+    },
+    {
+      종류: "promote",
+      이름: "SP-999902",
+      판: "b",
+      수정일: "2026-10-05T11:00:00",
+      제목: "값 없음",
+      단위: null,
+      기준금액: null,
+    },
+    {
+      종류: "precombo",
+      이름: "SC-999901",
+      판: "c",
+      수정일: "2026-10-05T12:00:00",
+      제목: "시험 묶음",
+      단위: "개소",
+      기준금액: 10,
+    },
+  ];
+  const doc = {
+    종류: "단가승격",
+    키: "SP-999901",
+    이름: "시험 승격",
+    단위: "㎡",
+    담은로직: [{ 로직: "L-0001", 입력값: {} }],
+  };
+  const json = (body, status = 200) =>
+    new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+  const real = window.fetch;
+  window.fetch = async (input, init = {}) => {
+    const url = String(input?.url ?? input);
+    const method = (init.method ?? "GET").toUpperCase();
+    if (method === "GET" && /\/m02\/layers\/system\/templates(\?|$)/.test(url)) {
+      const got = await (await real(input, init)).json();
+      return json({ ...got, 양식: [...got.양식.filter((r) => !/^S[PC]-/.test(r.이름)), ...rows] });
+    }
+    if (method === "GET" && url.includes("/templates/promote/SP-999901"))
+      return json({ 종류: "promote", 이름: "SP-999901", 판: "a", 문서: doc });
+    if (method === "DELETE" && /SP-9999/.test(url))
+      return json({ detail: "쓰는 곳이 있어 못 지움 「SP-999901」 — 일위대가 시험" }, 409);
+    return real(input, init);
+  };
+  try {
+    const sec = [...document.querySelectorAll(".m02-side__lists > section")].find(
+      (s) => s.querySelector(".ui-collapsible__title")?.textContent?.trim() === "일위대가 조합",
+    );
+    const items = [...sec.querySelectorAll("[data-precombo]")];
+    const side = {
+      items: items.map((b) => b.textContent),
+      otherButtons: [
+        ...sec.querySelectorAll(".ui-collapsible__body button, .m02-side__items button"),
+      ].filter((b) => !b.matches("[data-precombo], .m02-layers__btn")).length,
+    };
+    const tools = () => [...document.querySelectorAll(".m02-main__slot .m02-main__tools button")];
+    const list = (kind) => document.querySelector(`[data-lib-list="${kind}"]`);
+    // 단가산출 승격
+    items[0].click();
+    await until(() => list("promote")?.querySelectorAll("[data-lib-key]").length);
+    const L = list("promote");
+    const promote = {
+      title: document.querySelector(".m02-main__title")?.textContent,
+      active: items[0].classList.contains("is-active"),
+      heads: [...L.querySelectorAll("th")].map((x) => x.textContent),
+      rows: L.querySelectorAll("[data-lib-key]").length,
+      base: [...L.querySelectorAll("[data-lib-key]")].map((tr) => tr.children[4].textContent),
+      tools: tools().map((b) => b.textContent),
+      disabledBefore: tools().map((b) => b.disabled),
+    };
+    L.querySelector('[data-lib-key="SP-999901"] .m02-lib__pick').click();
+    await wait(100);
+    promote.disabledAfter = tools().map((b) => b.disabled);
+    promote.stillList = !!list("promote"); // 고름 칸 누름은 안 엶
+    // [생성] = 로직 고르기 창 → 닫기
+    tools()[0].click();
+    await wait(400);
+    const pick = document.querySelector(".m01-logic__pick");
+    promote.picker = !!pick;
+    pick?.closest(".m01-logic__backdrop")?.remove();
+    // [삭제] — 확인 창 [확인] → 쓰는 곳 409 까닭 알림
+    tools()[2].click();
+    const okBtn = await until(() =>
+      document.querySelector(
+        ".ui-confirm__actions .ui-button--danger, .ui-confirm__actions button:last-child",
+      ),
+    );
+    okBtn?.click();
+    const toast = await until(() =>
+      [...document.querySelectorAll(".ui-toast")]
+        .map((x) => x.textContent)
+        .find((t) => t?.includes("쓰는 곳")),
+    );
+    const blocked = toast ?? null;
+    const rowsAfterBlocked = list("promote")?.querySelectorAll("[data-lib-key]").length ?? 0;
+    // 줄 누름 = 그 문서 상세
+    list("promote").querySelector('[data-lib-key="SP-999901"] td:nth-child(3)').click();
+    const nameInput = await until(() => document.querySelector('[data-labor-field="이름"] input'));
+    const open = {
+      title: document.querySelector(".m02-main__title")?.textContent,
+      name: nameInput?.value ?? null,
+      sideActive: items[0].classList.contains("is-active"),
+    };
+    // 일위대가 사전조합
+    items[1].click();
+    await until(() => list("precombo")?.querySelectorAll("[data-lib-key]").length);
+    const precombo = {
+      rows: list("precombo")?.querySelectorAll("[data-lib-key]").length ?? 0,
+      active: items[1].classList.contains("is-active") && !items[0].classList.contains("is-active"),
+    };
+    tools()[0].click();
+    await wait(300);
+    const modal = document.querySelector(".m02-modal");
+    precombo.dialog = !!modal;
+    modal?.querySelector(".ui-modal__top button")?.click();
+    await wait(200);
+    precombo.dialogClosed = !document.querySelector(".m02-modal");
+    return JSON.stringify({ side, promote, blocked, rowsAfterBlocked, open, precombo });
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-5_단위단추_크기.js b/resources/tester/ui_checks/51-5_단위단추_크기.js
new file mode 100644
index 000000000..9fd87f7d3
--- /dev/null
+++ b/resources/tester/ui_checks/51-5_단위단추_크기.js
@@ -0,0 +1,35 @@
+/* 51-5 — 단위 고르기 단추(공용 M02_DF_UnitPick) 높이 · 글자 = [저장] 단추와 같음
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(tr '\n' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 하는 일: item1 → 일위대가 [수정] 상세 → 단위 단추 · [저장] 단추 높이 · 글자 크기 잼
+ * 기대: ok = true (|unit.h − save.h| ≤ 1 · 글자 같음)
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(2500);
+  const card = [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+    c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+  );
+  if (!card) return JSON.stringify({ error: "일위대가 카드 없음" });
+  [...card.querySelectorAll(".m02-struct__card-tools button")]
+    .find((b) => b.innerText.trim() === "수정")
+    ?.click();
+  await w(3000);
+  const read = (b) =>
+    b && {
+      h: Math.round(b.getBoundingClientRect().height * 10) / 10,
+      font: getComputedStyle(b).fontSize,
+    };
+  const unit = read(document.querySelector('[data-labor-field="단위"] .ui-btn'));
+  const save = read(
+    [...document.querySelectorAll("button")].find(
+      (b) => b.innerText.trim() === "저장" && b.offsetParent,
+    ),
+  );
+  return JSON.stringify({
+    unit,
+    save,
+    ok: !!unit && !!save && Math.abs(unit.h - save.h) <= 1 && unit.font === save.font,
+  });
+})();
diff --git a/resources/tester/ui_checks/51-6_사전조합_줄넣기.js b/resources/tester/ui_checks/51-6_사전조합_줄넣기.js
new file mode 100644
index 000000000..689cf8434
--- /dev/null
+++ b/resources/tester/ui_checks/51-6_사전조합_줄넣기.js
@@ -0,0 +1,208 @@
+/* 51-6 — 서고 사전조합 상세(일위대가 상세 서고 모드) 줄 넣는 길
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=일위대가조합&root=master) · 시스템 관리자
+ * 부르는 법: orca eval --expression "$(cat 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 쓰기 없음 — 서고 목록 · 문서 읽기 · [저장] PUT 은 가짜 응답(fetch 바꿔 끼움 · 끝에 되돌림) · calc 만 서버
+ * 기대 수치:
+ *   - promote = { add: false, rows: 1, move: 1 }(단가승격 상세는 한 줄 고정 · [옵션]만 · 위로 · 아래로 · 삭제 없음)
+ *   - precombo.add = true · picker = { filters: 0, kinds: ["단가승격", "단가승격", "일위조합"], layers: 1 }
+ *   - added = 2 · again = 「이미 담은」 알림
+ *   - moved = ["SP-999902", "SP-999901"](위로) · qty = { start: "1"(새 줄 기본), sheet: false, after: { 손: 3 } } · addedQty = { 손: 3 }
+ *   - removed = 1 · selfSave = 「순환」 알림(PUT 422) · putBody 에 자기 키 · left = 버림 확인 뒤 목록
+ */
+(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 4000) => {
+    for (let t = 0; t < ms; t += 100) {
+      const v = fn();
+      if (v) return v;
+      await wait(100);
+    }
+    return null;
+  };
+  const SYS = { 층: "system", 주인: null };
+  const rows = [
+    {
+      종류: "promote",
+      이름: "SP-999901",
+      판: "a",
+      수정일: "2026-10-05T10:00:00",
+      제목: "시험 승격",
+      단위: "㎡",
+      기준금액: 100,
+    },
+    {
+      종류: "promote",
+      이름: "SP-999902",
+      판: "b",
+      수정일: "2026-10-05T11:00:00",
+      제목: "시험 승격 둘",
+      단위: "㎡",
+      기준금액: 200,
+    },
+    {
+      종류: "precombo",
+      이름: "SC-999901",
+      판: "c",
+      수정일: "2026-10-05T12:00:00",
+      제목: "시험 묶음",
+      단위: "개소",
+      기준금액: 100,
+    },
+  ];
+  const docs = {
+    "promote/SP-999901": {
+      종류: "단가승격",
+      키: "SP-999901",
+      이름: "시험 승격",
+      단위: "㎡",
+      담은로직: [{ 로직: "GC000421", 입력값: {} }],
+    },
+    "precombo/SC-999901": {
+      종류: "사전조합",
+      키: "SC-999901",
+      이름: "시험 묶음",
+      단위: "개소",
+      담은로직: [{ 참조: { ...SYS, 키: "SP-999901" }, 수량: { 손: 1 } }],
+    },
+  };
+  const json = (body, status = 200) =>
+    new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+  const real = window.fetch;
+  let putBody = null;
+  window.fetch = async (input, init = {}) => {
+    const url = String(input?.url ?? input);
+    const method = (init.method ?? "GET").toUpperCase();
+    if (method === "GET" && /\/m02\/layers\/system\/templates(\?|$)/.test(url)) {
+      const got = await (await real(input, init)).json();
+      return json({ ...got, 양식: [...got.양식.filter((r) => !/^S[PC]-/.test(r.이름)), ...rows] });
+    }
+    const hit = Object.keys(docs).find((k) => url.includes(`/templates/${k}`));
+    if (hit && method === "GET")
+      return json({ 종류: hit.split("/")[0], 이름: docs[hit].키, 판: "a", 문서: docs[hit] });
+    if (hit && method === "PUT") {
+      putBody = JSON.parse(init.body);
+      const self = JSON.stringify(putBody).includes('"키":"SC-999901"}');
+      return self
+        ? json({ detail: "순환 — 자기 자신을 담음 「SC-999901」" }, 422)
+        : json({ 이름: "SC-999901", 판: "z" });
+    }
+    if (method !== "GET" && !url.includes("/calc"))
+      return json({ detail: "시험 — 쓰기 막음" }, 400);
+    return real(input, init);
+  };
+  const sec = [...document.querySelectorAll(".m02-side__lists > section")].find(
+    (s) => s.querySelector(".ui-collapsible__title")?.textContent?.trim() === "일위대가 조합",
+  );
+  const items = [...sec.querySelectorAll("[data-precombo]")];
+  const btn = (root, text) =>
+    [...root.querySelectorAll("button")].find((b) => b.textContent === text);
+  const edit = () => document.querySelector(".m02-main__host [data-labor]");
+  const lines = () => [...(edit()?.querySelectorAll("[data-labor-logic]") ?? [])];
+  const keys = () => lines().map((tr) => tr.querySelector(".m02-labrow__key")?.textContent);
+  const toast = (re) =>
+    until(() =>
+      [...document.querySelectorAll(".ui-toast")]
+        .map((x) => x.textContent)
+        .find((t) => re.test(t ?? "")),
+    );
+  const openDoc = async (i, key) => {
+    items[i].click();
+    const row = await until(() =>
+      document.querySelector(`[data-lib-key="${key}"] td:nth-child(3)`),
+    );
+    row.click();
+    await until(() => lines().length);
+    await wait(300);
+  };
+  const pickerRow = async (key) => {
+    btn(edit(), "로직 추가").click();
+    const row = await until(() => document.querySelector(`.m01-logic__pick [data-pick="${key}"]`));
+    return row;
+  };
+  try {
+    // 단가승격 상세 — 한 줄 고정
+    await openDoc(0, "SP-999901");
+    const promote = {
+      add: !!btn(edit(), "로직 추가"),
+      rows: lines().length,
+      move: edit().querySelectorAll(".m02-labrow__move button").length,
+    };
+    // 사전조합 상세
+    await openDoc(1, "SC-999901");
+    const precombo = { add: !!btn(edit(), "로직 추가"), rows: lines().length };
+    const first = await pickerRow("SP-999902");
+    const pick = document.querySelector(".m01-logic__pick");
+    const picker = {
+      filters: pick.querySelectorAll(".m01-logic__filters select").length,
+      kinds: [...pick.querySelectorAll("[data-pick-kind]")].map((x) => x.textContent),
+      layers: pick.querySelectorAll("[data-pick-layers] button").length,
+    };
+    first.click();
+    await until(() => lines().length === 2);
+    await wait(300);
+    const added = lines().length;
+    // 같은 참조 두 번 — 막힘
+    (await pickerRow("SP-999901")).click();
+    const again = await toast(/이미 담은/);
+    // 위로 — 둘째 줄을 첫째로
+    btn(lines()[1], "위로").click();
+    await wait(300);
+    const moved = keys();
+    // 수량 손 입력 — 시트 없음 · 3
+    lines()[0].querySelector("[data-labor-qty-open]").click();
+    const hand = await until(() => document.querySelector('.m02-labqty [data-labor-qty="hand"]'));
+    const qty = {
+      start: hand?.value,
+      sheet: !!document.querySelector(".m02-labqty [data-labor-qty-sheet]"),
+    };
+    hand.value = "3";
+    hand.dispatchEvent(new Event("input"));
+    btn(document.querySelector(".m02-labqty"), "확인").click();
+    await wait(400);
+    // 저장 본문으로 수량 확인(가짜 PUT)
+    const save = [...document.querySelectorAll(".m02-main__head button")].find(
+      (b) => b.textContent === "저장",
+    );
+    save.click();
+    await until(() => putBody);
+    const sent = putBody.문서.담은로직;
+    const addedQty = sent.find((x) => x.참조.키 === "SP-999902")?.수량 ?? null;
+    qty.after = sent[0]?.수량 ?? null;
+    // 삭제 — 줄 하나 뺌
+    btn(lines()[1], "삭제").click();
+    await wait(300);
+    const removed = lines().length;
+    // 자기 자신 담고 [저장] → 서버 422 알림
+    putBody = null;
+    (await pickerRow("SC-999901")).click();
+    await until(() => lines().length === 2);
+    save.click();
+    const selfSave = await toast(/순환/);
+    const selfSent = JSON.stringify(putBody ?? {}).includes("SC-999901");
+    // 떠남 — 버림 확인 → 목록
+    items[1].click();
+    const ok = await until(() =>
+      document.querySelector(
+        ".ui-confirm__actions .ui-button--danger, .ui-confirm__actions button:last-child",
+      ),
+    );
+    ok?.click();
+    const left = !!(await until(() => document.querySelector('[data-lib-list="precombo"]')));
+    return JSON.stringify({
+      promote,
+      precombo,
+      picker,
+      added,
+      addedQty,
+      again,
+      moved,
+      qty,
+      removed,
+      selfSave,
+      selfSent,
+      left,
+    });
+  } finally {
+    window.fetch = real;
+  }
+})();
diff --git a/resources/tester/ui_checks/51-9_고르기_찾기양식.js b/resources/tester/ui_checks/51-9_고르기_찾기양식.js
new file mode 100644
index 000000000..5a0c5c23b
--- /dev/null
+++ b/resources/tester/ui_checks/51-9_고르기_찾기양식.js
@@ -0,0 +1,90 @@
+/* 51-9 — [로직 추가] 고르기 창이 공용 찾기 양식(ui_template_find_list)을 씀
+ * 시작 화면: M02 마스터 템플릿 · 마스터 층(#/m02-master-template?open=구조물조합&root=master) · 시스템 관리자 · item1 있음
+ * 부르는 법: orca eval --expression "$(tr '
+' ' ' < 이 파일)" (async 식 · JSON 글을 돌려줌)
+ * 하는 일: item1 → 일위대가 [수정] → [로직 추가] → 칸 배치 · 줄 맞춤 · ↓ Enter 점검 → 창 닫음(저장 안 함)
+ * 기대 수치:
+ *   - template = true · filters = 2 · sameLine = true(구분 · 상세구분 top 같음 · left 다름)
+ *   - nameAlign = "left" · nameLeftGap ≤ 꼬리표 폭 + 16 · rowHeight ≤ 40 · oneLine = true
+ *   - active0 = 0 · activeAfterDown = 1 · enterPicked = true(Enter 로 창이 닫힘) · undone = true
+ */
+(async () => {
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 8000) => {
+    for (let t = 0; t < ms; t += 150) {
+      const v = fn();
+      if (v) return v;
+      await w(150);
+    }
+    return null;
+  };
+  const out = {};
+  const node = await until(() => document.querySelector('[data-node="i|item1"]'));
+  if (!node) return JSON.stringify({ error: "item1 없음" });
+  node.click();
+  const card = await until(() =>
+    [...document.querySelectorAll(".m02-struct__card")].find((c) =>
+      c.querySelector("table.m02-labrow tbody tr[data-labor-logic]"),
+    ),
+  );
+  if (!card) return JSON.stringify({ error: "일위대가 카드 없음" });
+  [...card.querySelectorAll(".m02-struct__card-tools button")]
+    .find((b) => b.innerText.trim() === "수정")
+    ?.click();
+  const table = () =>
+    [...document.querySelectorAll("table.m02-labrow")].find(
+      (t) => !t.closest(".m02-struct__card") && t.querySelector("tr[data-labor-logic]"),
+    );
+  await until(() => table() && !/…/.test(table().querySelector("tbody").innerText), 12000);
+  const host = table().closest("[data-labor]");
+  const before = table().querySelectorAll("tbody tr[data-labor-logic]").length;
+  const openPick = async () => {
+    [...host.querySelectorAll(".m01-logic__section-head button")]
+      .find((b) => b.innerText.trim() === "로직 추가")
+      .click();
+    const dlg = await until(() => document.querySelector(".m01-logic__pick"));
+    await until(() => dlg.querySelectorAll(".ui-find__row").length > 1, 20000);
+    return dlg;
+  };
+  const dlg = await openPick();
+  out.template = !!dlg.querySelector(".ui-find .ui-find__filters") && !!dlg.querySelector(".ui-find__list");
+  const sels = [...dlg.querySelectorAll(".ui-find__filters > *")];
+  out.filters = sels.length;
+  const [a, b] = sels.map((x) => x.getBoundingClientRect());
+  out.sameLine = Math.abs(a.top - b.top) < 2 && b.left > a.right - 1;
+  const row = dlg.querySelector(".ui-find__row");
+  const name = row.querySelector(".ui-find__name");
+  const tag = row.querySelector(".ui-find__tag");
+  out.nameAlign = getComputedStyle(name).textAlign;
+  out.rowAlign = getComputedStyle(row).textAlign;
+  out.nameLeftGap = Math.round(name.getBoundingClientRect().left - row.getBoundingClientRect().left);
+  out.tagWidth = Math.round(tag.getBoundingClientRect().width);
+  out.rowHeight = Math.round(row.getBoundingClientRect().height);
+  out.oneLine = getComputedStyle(row).whiteSpace === "nowrap";
+  const rows = () => [...dlg.querySelectorAll(".ui-find__row")];
+  const active = () => rows().findIndex((r) => r.classList.contains("is-active"));
+  out.active0 = active();
+  const search = dlg.querySelector('input[type="search"]');
+  search.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true }));
+  out.activeAfterDown = active();
+  out.rows = rows().length;
+  /* Enter = 고름 — 창이 닫히고 표에 붙은 줄은 바로 지움 */
+  const pickedKey = rows()[active()].dataset.pick;
+  search.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  out.enterPicked = !!(await until(() => !document.querySelector(".m01-logic__pick") || null));
+  out.pickedKey = pickedKey;
+  await until(() => table().querySelectorAll("tbody tr[data-labor-logic]").length > before, 8000);
+  const added = [...table().querySelectorAll("tbody tr[data-labor-logic]")].slice(before);
+  for (const tr of added) {
+    [...tr.querySelectorAll("button")].find((x) => x.innerText.trim() === "삭제")?.click();
+    await w(600);
+  }
+  out.undone = table().querySelectorAll("tbody tr[data-labor-logic]").length === before;
+  document.querySelector('[data-node="i|item1"]')?.click();
+  await w(800);
+  const ask = [...document.querySelectorAll(".ui-modal button, dialog button")].find((x) =>
+    /확인|버림|떠나기/.test(x.innerText),
+  );
+  ask?.click();
+  return JSON.stringify(out);
+})();
diff --git a/resources/tester/ui_checks/52-1_배관_컨테이너.js b/resources/tester/ui_checks/52-1_배관_컨테이너.js
new file mode 100644
index 000000000..02840470e
--- /dev/null
+++ b/resources/tester/ui_checks/52-1_배관_컨테이너.js
@@ -0,0 +1,202 @@
+/* 52-1 — B05 · B06 좌측 「구조물 배치」 배관 = 사용자 구조물 표 01 명세(컨테이너 다섯)
+ * 시작 화면: B05 종단설계(#/b05-profile) · 검증 프로젝트(sub5_검증) · 목록에 「배관 1」
+ * 부르는 법: 단계마다 한 번씩 — 앞에 `window.__m521 = "단계";` 를 붙여
+ *   orca eval --expression "window.__m521='edit'; $(cat 이 파일)"   → 고치고 [저장] (원래 관 지점은 sessionStorage 에 둠)
+ *   (orca reload 로 다시 열기)
+ *   orca eval --expression "window.__m521='verify'; $(cat 이 파일)" → 다시 연 값 · B06 같은 그리기 · 관 길이
+ *   orca eval --expression "window.__m521='restore'; $(cat 이 파일)" → 원래 관 지점으로 되돌림(PUT) · 초안 비움
+ * 쓰는 것: 검증 프로젝트 pipe_points.json(되돌림 단계가 원래 값으로 다시 씀)
+ * 기대 수치(edit): kinds 5 · required 3 늘 보임 · formBasin I형/L형/ㄷ형 · formSoil 6 · split 길이 7 ·
+ *   soilAdd 둘 → 하나 빼면 하나(콘크리트) · chute 하나(돌붙임) · 잇기 유입 지정 · 유출 지정 뒤 풂
+ * 기대 수치(verify): 저장 값 그대로 · 같은 그리기(B05 = B06) · 관 길이 수(B06)
+ */
+(async () => {
+  const MODE = window.__m521 || "edit";
+  const w = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 20000) => {
+    for (let t = 0; t < ms; t += 200) {
+      if (fn()) return true;
+      await w(200);
+    }
+    return false;
+  };
+  const projectId = localStorage.getItem("frd_current_project_id");
+  const modUrl = (part) =>
+    performance
+      .getEntriesByType("resource")
+      .map((e) => e.name)
+      .filter((n) => n.includes(part))
+      .pop();
+  const fetchApi = await import(modUrl("/B04_PreProcess/B04_PreProcess_Api_Fetch.ts"));
+  const spec = () => document.querySelector(".b05-structure__spec");
+  const box = (c, i = 0) => spec().querySelectorAll(`[data-spec-container="${c}"]`)[i];
+  const ctl = (c, item, i = 0) =>
+    box(c, i)?.querySelector(`[data-spec-item="${c}.${item}"]`)?.querySelector("select, input");
+  const set = async (c, item, v, i = 0) => {
+    const el = ctl(c, item, i);
+    el.value = v;
+    el.dispatchEvent(new Event("change", { bubbles: true }));
+    await w(200);
+  };
+  const labels = (c, item) => [...ctl(c, item).options].filter((o) => o.value).map((o) => o.text);
+  const pickPipe = async () => {
+    await until(() => document.querySelectorAll(".b05-route__irregular-list li").length > 0);
+    const li = [...document.querySelectorAll(".b05-route__irregular-list li")].find((l) =>
+      /배관 1$/.test(l.textContent.trim()),
+    );
+    // 다시 열면 고른 것이 복원돼 있음 — 누르면 풀리므로 풀렸으면 한 번 더(재선택 = 해제)
+    (li.querySelector("button") ?? li).click();
+    await w(800);
+    if (!(spec() && spec().offsetParent !== null)) (li.querySelector("button") ?? li).click();
+    await until(() => spec() && spec().offsetParent !== null);
+    await w(500);
+  };
+  const shape = () =>
+    [...spec().querySelectorAll("[data-spec-container]")].map((b) => ({
+      c: b.dataset.specContainer,
+      legend: b.querySelector("legend").firstChild.textContent,
+      items: [...b.querySelectorAll("[data-spec-item]")].map((n) => n.dataset.specItem),
+      link: b.querySelector(".b05-structure__summary-name")?.textContent,
+    }));
+  const linkName = (c, i = 0) =>
+    box(c, i).querySelector(".b05-structure__summary-name").classList.contains("is-assigned");
+  const pickLink = async (c) => {
+    box(c).querySelector('[data-b05-summary="pick"]').click();
+    await until(() => document.querySelector(".ui-item-picker__tree .ui-tree__row"));
+    // 첫 잎까지 펼침
+    for (let k = 0; k < 8; k++) {
+      const rows = [...document.querySelectorAll(".ui-item-picker__tree .ui-tree__row")];
+      const leaf = rows.find((r) => !r.classList.contains("is-branch"));
+      if (leaf) {
+        leaf.click();
+        break;
+      }
+      const closed = rows.find((r) => r.querySelector(".ui-tree__caret")?.textContent === "▸");
+      closed?.click();
+      await w(300);
+    }
+    await w(300);
+    [...document.querySelectorAll(".ui-item-picker__actions button")]
+      .find((b) => b.textContent.includes("적용"))
+      .click();
+    await w(500);
+  };
+  const out = { mode: MODE };
+
+  if (MODE === "edit") {
+    const before = await fetchApi.fetchDetailPipePoints(projectId);
+    sessionStorage.setItem("__521_original", JSON.stringify(before.pipe_points));
+    await pickPipe();
+    const s0 = shape();
+    out.kinds =
+      s0.filter((b) => ["pipe", "inlet", "outlet"].includes(b.c)).length +
+      spec().querySelectorAll("[data-spec-add]").length;
+    out.required = ["pipe", "inlet", "outlet"].every((c) => box(c)?.offsetParent !== null);
+    out.addButtons = [...spec().querySelectorAll("[data-spec-add]")].map((b) => b.textContent);
+    // 형태 선택지가 구조를 따름
+    await set("inlet", "structure", "집수정");
+    out.formBasin = labels("inlet", "form");
+    await set("inlet", "structure", "기슭막이");
+    out.formSoil = labels("inlet", "form");
+    await set("inlet", "form", "돌망태");
+    // 길이 = 전 + 후 — 길이 10 · 전 3 → 후 7 · 이어서 후 4 → 길이 7(전 · 후를 지킴)
+    await set("inlet", "length", "10");
+    await set("inlet", "before", "3");
+    out.splitAfter = ctl("inlet", "after").value;
+    await set("inlet", "after", "4");
+    out.splitLength = ctl("inlet", "length").value;
+    // 선택 컨테이너 — 흙막이 추가 둘 → 첫째 뺌 · 도수로/돌붙임 하나
+    spec().querySelector('[data-spec-add="soil_add"]').click();
+    await w(200);
+    spec().querySelector('[data-spec-add="soil_add"]').click();
+    await w(200);
+    await set("soil_add", "structure", "기슭막이", 0);
+    await set("soil_add", "form", "바자", 0);
+    await set("soil_add", "structure", "기슭막이", 1);
+    await set("soil_add", "form", "콘크리트", 1);
+    out.soilAddTwo = spec().querySelectorAll('[data-spec-container="soil_add"]').length;
+    out.soilFormsSoilAdd = labels("soil_add", "form").length;
+    box("soil_add", 0).querySelector('[data-spec-remove="soil_add"]').click();
+    await w(300);
+    out.soilAddAfterRemove = [...spec().querySelectorAll('[data-spec-container="soil_add"]')].map(
+      (b, i) => [
+        b.querySelector("legend").firstChild.textContent,
+        ctl("soil_add", "form", i).value,
+      ],
+    );
+    spec().querySelector('[data-spec-add="chute_add"]').click();
+    await w(200);
+    await set("chute_add", "structure", "돌붙임");
+    out.chuteChoices = labels("chute_add", "structure");
+    // 구조물 조합 잇기 — 유입 지정 · 유출 지정 뒤 풂
+    await pickLink("inlet");
+    out.linkInlet = linkName("inlet");
+    await pickLink("outlet");
+    out.linkOutletPicked = linkName("outlet");
+    box("outlet").querySelector('[data-b05-summary="clear"]').click();
+    await w(300);
+    out.linkOutletCleared = !linkName("outlet");
+    // [저장]
+    document.querySelector('[data-dock-action="save"]').click();
+    await w(500);
+    out.saved = await until(() => !document.querySelector(".ui-overlay.is-active"), 60000);
+    const after = await fetchApi.fetchDetailPipePoints(projectId);
+    const p = after.pipe_points.find((x) => x.chainage_m > 80 && x.chainage_m < 90); // 배관 1 = 4+5
+    out.file = p && {
+      options: p.options,
+      group_items: Object.keys(p.group_items ?? {}),
+    };
+  }
+
+  if (MODE === "verify") {
+    await pickPipe();
+    out.reopened = {
+      inlet: ["structure", "form", "length", "before", "after"].map((k) => ctl("inlet", k).value),
+      soilAdd: [...spec().querySelectorAll('[data-spec-container="soil_add"]')].map(
+        (_, i) => ctl("soil_add", "form", i).value,
+      ),
+      chute: ctl("chute_add", "structure").value,
+      linkInlet: linkName("inlet"),
+      linkOutlet: linkName("outlet"),
+    };
+    const b05 = shape();
+    out.b05Length = ctl("pipe", "length").value;
+    location.hash = "#/b06-section";
+    await until(() => location.hash.includes("b06"), 5000);
+    await w(6000);
+    await pickPipe();
+    const b06 = shape();
+    out.sameDrawing = JSON.stringify(b05) === JSON.stringify(b06);
+    if (!out.sameDrawing) out.diff = { b05, b06 };
+    out.b06Length = ctl("pipe", "length").value;
+  }
+
+  if (MODE === "restore") {
+    const original = JSON.parse(sessionStorage.getItem("__521_original") || "null");
+    if (!original) return JSON.stringify({ error: "원래 값 없음" });
+    const keys = [
+      "chainage_m",
+      "source",
+      "facility",
+      "start_m",
+      "end_m",
+      "options",
+      "summary_item",
+      "group_items",
+    ];
+    const points = original.map((p) =>
+      Object.fromEntries(
+        keys.filter((k) => p[k] !== undefined && p[k] !== null).map((k) => [k, p[k]]),
+      ),
+    );
+    await fetchApi.saveDetailPipePoints(projectId, points);
+    for (const k of Object.keys(sessionStorage))
+      if (k.startsWith("aislo:draft:pipes:") || k === "__521_original")
+        sessionStorage.removeItem(k);
+    const now = await fetchApi.fetchDetailPipePoints(projectId);
+    const pick = (list) =>
+      JSON.stringify(list.map((p) => [p.chainage_m, p.options ?? {}, p.group_items ?? {}]));
+    out.restored = pick(now.pipe_points) === pick(original);
+  }
+  return JSON.stringify(out);
+})();
diff --git a/ui_template/ui_template_find_list.css b/ui_template/ui_template_find_list.css
new file mode 100644
index 000000000..04dbaf7e0
--- /dev/null
+++ b/ui_template/ui_template_find_list.css
@@ -0,0 +1,73 @@
+/* 공용 찾기 목록(ui_template_find_list.ts) — 거름 2열 · 결과 한 줄 · 이름 왼쪽 맞춤 */
+.ui-find {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+  min-height: 0;
+}
+
+.ui-find__filters {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: var(--spacing-8);
+}
+
+.ui-find__hint {
+  margin: 0;
+  color: var(--color-text-muted);
+  font-size: var(--text-caption);
+}
+
+.ui-find__list {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  overflow: auto;
+}
+
+.ui-find__row {
+  display: flex;
+  align-items: baseline;
+  gap: var(--spacing-8);
+  width: 100%;
+  padding: var(--spacing-4) var(--spacing-8);
+  border: 0;
+  border-bottom: 1px solid var(--color-border);
+  background: none;
+  color: var(--color-text-body);
+  font: inherit;
+  text-align: left;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.ui-find__row.is-active {
+  background: var(--color-mist-violet);
+  color: var(--color-accent);
+}
+
+.ui-find__tag,
+.ui-find__sub,
+.ui-find__unit {
+  flex: none;
+  color: var(--color-text-muted);
+  font-size: var(--text-caption);
+}
+
+.ui-find__tag {
+  min-width: 4.5em;
+}
+
+.ui-find__name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-align: left;
+}
+
+.ui-find__sub {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
diff --git a/ui_template/ui_template_find_list.ts b/ui_template/ui_template_find_list.ts
new file mode 100644
index 000000000..f4fcab62f
--- /dev/null
+++ b/ui_template/ui_template_find_list.ts
@@ -0,0 +1,103 @@
+/* =============================================================================
+ * ui_template_find_list.ts
+ * 공용 찾기 목록 — 걸러내기 고르기 칸(2열 격자) · 찾기 칸 · 알림 줄 · 결과 목록(이름 왼쪽 맞춤 · 한 줄).
+ * 키보드 — 찾기 칸에서 ↑ ↓ 로 옮기고 Enter 로 고름. 창 겉틀은 부르는 쪽 몫.
+ *
+ *   const find = createFindList({ placeholder, filters: [sub.root, detail.root] });
+ *   find.setRows([{ key, tag, name, sub, unit, onPick }]);
+ * ========================================================================== */
+
+import "./ui_template_find_list.css";
+import { createInputField, el } from "./ui_template_elements";
+
+export interface FindRow {
+  /** 줄 표지(`data-pick`) */
+  key: string;
+  name: string;
+  /** 앞 흐린 꼬리표(종류 등) */
+  tag?: string;
+  /** 이름 뒤 흐린 보조 글(키 · 구분 등) */
+  sub?: string;
+  /** 끝 흐린 글(단위 등) */
+  unit?: string;
+  onPick: () => void;
+}
+
+export interface FindList {
+  root: HTMLElement;
+  search: HTMLInputElement;
+  hint: HTMLElement;
+  setRows: (rows: FindRow[]) => void;
+}
+
+export function createFindList(opts: {
+  placeholder: string;
+  filters?: HTMLElement[];
+  /** 찾기 칸과 알림 줄 사이(층 단추 등) */
+  extra?: HTMLElement[];
+}): FindList {
+  const field = createInputField({ type: "search", placeholder: opts.placeholder });
+  const hint = el("p", { className: "ui-find__hint" });
+  const list = el("div", { className: "ui-find__list", attrs: { role: "listbox" } });
+  let rows: FindRow[] = [];
+  let at = -1;
+
+  const mark = (i: number): void => {
+    list.children[at]?.classList.remove("is-active");
+    at = i;
+    const row = list.children[at];
+    row?.classList.add("is-active");
+    row?.scrollIntoView({ block: "nearest" });
+  };
+  field.input.addEventListener("keydown", (ev) => {
+    if (ev.key === "ArrowDown" || ev.key === "ArrowUp") {
+      ev.preventDefault();
+      if (!rows.length) return;
+      const step = ev.key === "ArrowDown" ? 1 : -1;
+      mark((at + step + rows.length) % rows.length);
+    } else if (ev.key === "Enter" && rows[at]) {
+      ev.preventDefault();
+      rows[at].onPick();
+    }
+  });
+
+  const setRows = (next: FindRow[]): void => {
+    rows = next;
+    at = -1;
+    list.replaceChildren(
+      ...rows.map((r, i) => {
+        const row = el("button", {
+          className: "ui-find__row",
+          attrs: { type: "button", role: "option", "data-pick": r.key, title: r.name },
+          children: [
+            ...(r.tag
+              ? [
+                  el("span", {
+                    className: "ui-find__tag",
+                    attrs: { "data-pick-kind": "" },
+                    text: r.tag,
+                  }),
+                ]
+              : []),
+            el("span", { className: "ui-find__name", text: r.name }),
+            el("span", { className: "ui-find__sub", text: r.sub ?? "" }),
+            el("span", { className: "ui-find__unit", text: r.unit ?? "" }),
+          ],
+        });
+        row.addEventListener("click", r.onPick);
+        row.addEventListener("mousemove", () => at !== i && mark(i));
+        return row;
+      }),
+    );
+    if (rows.length) mark(0);
+  };
+
+  const filters = opts.filters?.length
+    ? [el("div", { className: "ui-find__filters", children: opts.filters })]
+    : [];
+  const root = el("div", {
+    className: "ui-find",
+    children: [...filters, field.root, ...(opts.extra ?? []), hint, list],
+  });
+  return { root, search: field.input, hint, setRows };
+}
diff --git a/ui_template/ui_template_locale_m2.ts b/ui_template/ui_template_locale_m2.ts
index 15a1000a0..e7da5b753 100644
--- a/ui_template/ui_template_locale_m2.ts
+++ b/ui_template/ui_template_locale_m2.ts
@@ -99,17 +99,12 @@ export const ui_locales_m2 = {
   M02_SourcePeople: ["다른 사람", "Others"],
   M02_SourcePractice: ["실무문서", "Practice documents"],
   M02_PeopleEmpty: ["비어 있음", "empty"],
-  M02_TreeSearch: [
-    "찾기 — 이름 · 키 · 폴더 · 단위 (낱말 여럿 = 모두 담은 것)",
-    "Find — name, key, folder, unit (all words)",
-  ],
   M02_TreeEmptyEdit: [
     "항목이 없음 — 빈 자리 오른쪽 클릭 또는 층 단추 옆 「+」 로 폴더 · 항목을 더함",
     "No items — right-click an empty area or use + beside the layer buttons to add",
   ],
   M02_TreeAddTop: ["맨 위에 폴더 · 항목 추가", "Add folder or item at top"],
   M02_TreeEmpty: ["항목이 없음", "No items"],
-  M02_TreeNoHit: ["찾은 항목이 없음", "No matching item"],
   M02_TreeAddFolder: ["폴더 추가", "Add folder"],
   M02_TreeAddItem: ["항목 추가", "Add item"],
   M02_TreeRename: ["이름 바꾸기", "Rename"],
diff --git a/ui_template/ui_template_side_panels.css b/ui_template/ui_template_side_panels.css
index 344f6fb1b..77f3f306f 100644
--- a/ui_template/ui_template_side_panels.css
+++ b/ui_template/ui_template_side_panels.css
@@ -1,4 +1,5 @@
-/* 본문 오른쪽 접는 패널 여럿 — 접힌 패널 = 세로 글 띠 · 편 패널 = 공유 폭(--ui-side-panels-width) */
+/* 본문 오른쪽 접는 패널 여럿 — 왼쪽 가장자리 손잡이(좌측 패널과 같은 꼴) · 편 패널 = 공유 폭(--ui-side-panels-width)
+   보이는 칸 안에 붙음(JS followView) — 몸만 따로 스크롤 · 메인 스크롤과 따로 */
 
 /* 부르는 쪽 칸 — [본문, 패널 묶음] */
 .ui-side-panels-row {
@@ -17,40 +18,45 @@
 }
 
 .ui-side-panels {
+  position: relative;
   display: flex;
   flex: none;
-  align-items: stretch;
+  align-self: flex-start;
+  /* 높이 · 붙는 자리 = JS(followView) · 처음 한 번 그릴 때까지 */
+  height: calc(100vh - 80px);
+  /* 손잡이 자리(24) + 틈 */
+  margin-left: calc(var(--spacing-24) + var(--spacing-8));
+}
+
+/* 모두 접힘 — 폭 0 · 손잡이만 왼쪽 밖에 남음 */
+.ui-side-panels.is-collapsed {
+  width: 0;
+}
+
+/* 손잡이 줄 — 패널 왼쪽 밖 세로 가운데 · 패널 둘이면 위아래로 */
+.ui-side-panels__handles {
+  position: absolute;
+  z-index: 2;
+  top: 50%;
+  left: calc(-1 * var(--spacing-24));
+  display: flex;
+  flex-direction: column;
   gap: var(--spacing-4);
-  margin-left: var(--spacing-8);
+  transform: translateY(-50%);
+}
+
+.ui-side-panels__handles > .ui-workflow-overlay__handle--side {
+  position: static;
+  transform: none;
+  border-right: 0;
+  border-left: 1px solid var(--panel-handle-border, var(--color-border));
+  border-radius: var(--radius-buttons) 0 0 var(--radius-buttons);
 }
 
 .ui-side-panels.is-resizing {
   user-select: none;
 }
 
-.ui-side-panels__strip {
-  flex: none;
-  width: 32px;
-  padding: var(--spacing-8) 0;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-cards);
-  background: var(--color-surface);
-  color: var(--color-text-secondary);
-  font: inherit;
-  font-size: var(--text-body-sm);
-  font-weight: 600;
-  writing-mode: vertical-rl;
-  text-orientation: mixed;
-  text-align: start;
-  cursor: pointer;
-}
-
-.ui-side-panels__strip:hover,
-.ui-side-panels__strip:focus-visible {
-  border-color: var(--color-primary);
-  color: var(--color-text);
-}
-
 .ui-side-panels__panel {
   position: relative;
   display: flex;
@@ -58,12 +64,12 @@
   flex-direction: column;
   width: var(--ui-side-panels-width, 420px);
   min-width: 0;
+  height: 100%;
   border: 1px solid var(--color-border);
   border-radius: var(--radius-cards);
   background: var(--color-surface);
 }
 
-.ui-side-panels__strip[hidden],
 .ui-side-panels__panel[hidden] {
   display: none;
 }
@@ -101,22 +107,6 @@
   color: var(--color-text);
 }
 
-.ui-side-panels__fold {
-  flex: none;
-  padding: 0 var(--spacing-4);
-  border: 0;
-  border-radius: var(--radius-sm);
-  background: none;
-  color: var(--color-text-secondary);
-  font: inherit;
-  cursor: pointer;
-}
-
-.ui-side-panels__fold:hover,
-.ui-side-panels__fold:focus-visible {
-  color: var(--color-primary);
-}
-
 .ui-side-panels__body {
   flex: 1 1 auto;
   min-width: 0;
diff --git a/ui_template/ui_template_side_panels.ts b/ui_template/ui_template_side_panels.ts
index 9198144a0..93aa4c17c 100644
--- a/ui_template/ui_template_side_panels.ts
+++ b/ui_template/ui_template_side_panels.ts
@@ -1,7 +1,9 @@
 /* =============================================================================
  * ui_template_side_panels.ts
  * 본문 오른쪽 접는 패널 여럿 — 나란히 · 하나만 열림 · 모두 접힘 됨 · 폭 공유
- * 접힌 패널 = 제목 세로 글 띠(누르면 폄) · 편 패널 = 머리(제목 · 접기 ▸) + 몸 · 왼쪽 경계 끌기(화살표 키)
+ * 좌측 패널과 같은 접기 양식 — 패널 왼쪽 가장자리 손잡이(공용 createWorkflowPanelHandle · 오른쪽으로 접힘)
+ *   패널마다 손잡이 하나(이름표 세로) · 누르면 폄/접음 · 모두 접히면 손잡이만 남음
+ * 편 패널 = 머리(제목) + 몸 · 왼쪽 경계 끌기(화살표 키) · 보이는 칸 안에 붙어 몸만 따로 스크롤(followView)
  * 열린 패널 · 폭 = 부르는 쪽 취향 키(`aislo:pref:{prefKey}`)
  * 부르기: const sp = createSidePanels({ prefKey, panels: [{ id, title, body }] }) →
  *         본문과 함께 `.ui-side-panels-row` 칸에 [본문, sp.root] 로 넣음
@@ -10,11 +12,10 @@
 import { readByKey, writeByKey } from "../A00_Common/b_page_state";
 import { el } from "./ui_template_elements";
 import { currentLanguageIndex } from "./ui_template_locale";
+import { createWorkflowPanelHandle } from "./ui_template_overlay";
 import "./ui_template_side_panels.css";
 
 const TEXT = {
-  Open: ["{v} 펴기", "Open {v}"],
-  Close: ["{v} 접기", "Collapse {v}"],
   Grip: ["패널 너비 — 끌거나 화살표 키", "Panel width — drag or arrow keys"],
 } as const;
 
@@ -89,29 +90,15 @@ export function createSidePanels(opts: SidePanelsOpts): SidePanels {
     if (keep) save();
   };
 
+  const handles = el("div", { className: "ui-side-panels__handles" });
+  root.append(handles);
   const views = opts.panels.map((p) => {
     const bodyId = `ui-side-panel-${opts.prefKey}-${p.id}`;
-    const strip = el("button", {
-      className: "ui-side-panels__strip",
-      text: p.title,
-      attrs: { type: "button", "aria-expanded": "false", "aria-controls": bodyId },
-    });
-    strip.title = ts("Open", p.title);
-    strip.addEventListener("click", () => {
-      open(p.id);
-      fold.focus();
-    });
-    const fold = el("button", {
-      className: "ui-side-panels__fold",
-      text: "▸",
-      attrs: { type: "button", "aria-expanded": "true", "aria-controls": bodyId },
-    });
-    fold.title = ts("Close", p.title);
-    fold.setAttribute("aria-label", fold.title);
-    fold.addEventListener("click", () => {
-      open(null);
-      strip.focus();
-    });
+    const handle = createWorkflowPanelHandle("side", "right", p.title);
+    handle.root.setAttribute("aria-controls", bodyId);
+    handle.root.dataset.panel = p.id;
+    handle.root.addEventListener("click", () => open(now === p.id ? null : p.id));
+    handles.append(handle.root);
     const grip = el("div", {
       className: "ui-side-panels__grip",
       attrs: {
@@ -128,7 +115,7 @@ export function createSidePanels(opts: SidePanelsOpts): SidePanels {
         grip,
         el("header", {
           className: "ui-side-panels__head",
-          children: [el("strong", { className: "ui-side-panels__title", text: p.title }), fold],
+          children: [el("strong", { className: "ui-side-panels__title", text: p.title })],
         }),
         el("div", { className: "ui-side-panels__body", attrs: { id: bodyId }, children: [p.body] }),
       ],
@@ -156,16 +143,17 @@ export function createSidePanels(opts: SidePanelsOpts): SidePanels {
       ev.preventDefault();
       setWidth(width + d, true);
     });
-    root.append(strip, box);
-    return { id: p.id, strip, box };
+    root.append(box);
+    return { id: p.id, handle, box };
   });
 
   const draw = (): void => {
     for (const v of views) {
       const on = v.id === now;
-      v.strip.hidden = on;
+      v.handle.setOpen(on);
       v.box.hidden = !on;
     }
+    root.classList.toggle("is-collapsed", now === null);
   };
 
   function open(id: string | null): void {
@@ -178,5 +166,58 @@ export function createSidePanels(opts: SidePanelsOpts): SidePanels {
   }
 
   draw();
+  followView(root);
   return { root, open, current: () => now, width: () => width };
 }
+
+/** 가장 가까운 스크롤 칸(없으면 창) */
+function scroller(node: HTMLElement): HTMLElement | null {
+  for (let n = node.parentElement; n; n = n.parentElement) {
+    const y = getComputedStyle(n).overflowY;
+    if ((y === "auto" || y === "scroll") && n.scrollHeight > n.clientHeight + 1) return n;
+  }
+  return null;
+}
+
+/**
+ * 패널 묶음을 보이는 칸 안에 붙임 — 높이 = 보이는 창 높이 − 머리띠(칸이 아래에 있으면 칸 위부터) · 본문을 굴려도 그 자리(몸만 따로 스크롤)
+ * CSS sticky 는 위 칸의 overflow 가 막아 JS 로 — 어느 칸이 굴러도(capture) 다시 잼
+ */
+function followView(node: HTMLElement): void {
+  const ref = new WeakRef(node); // 떼었다 다시 붙이는 화면(M01)도 있어 떼어져도 듣기는 남김 · 버려지면 그침
+  // 다시 붙음 · 칸 내용이 늦게 차 칸 크기가 바뀜(스크롤 없이) → 다시 잼
+  const sized = new ResizeObserver(() => place());
+  let watched: Element | null = null;
+  const place = (): void => {
+    const root = ref.deref();
+    if (!root) return stop();
+    if (!root.isConnected) return;
+    if (root.parentElement && root.parentElement !== watched) {
+      if (watched) sized.unobserve(watched);
+      watched = root.parentElement;
+      sized.observe(watched);
+    }
+    const box = scroller(root)?.getBoundingClientRect();
+    const head = document.querySelector(".app-header")?.getBoundingClientRect().bottom ?? 0;
+    const view = Math.max(head, box?.top ?? 0);
+    const bottom = Math.min(window.innerHeight, box?.bottom ?? window.innerHeight);
+    const row = root.parentElement?.getBoundingClientRect();
+    if (!row) return;
+    // 칸이 아직 화면 아래에 있으면 칸 위에 맞춤 · 올라가 붙으면 보이는 칸 전체 높이
+    const top = Math.max(view, row.top);
+    // 칸 바닥(+ 쪽 아래 여백)을 넘지 않음 · 너무 줄면 최소 높이로 두고 칸 바닥에 맞춰 올라감
+    const height = Math.max(240, Math.min(bottom, row.bottom + 48) - top);
+    root.style.height = `${height}px`;
+    const shift = Math.min(Math.max(0, view - row.top), Math.max(0, row.height + 48 - height));
+    root.style.transform = shift ? `translateY(${Math.round(shift)}px)` : "";
+  };
+  const stop = (): void => {
+    window.removeEventListener("scroll", place, true);
+    window.removeEventListener("resize", place);
+    sized.disconnect();
+  };
+  window.addEventListener("scroll", place, true);
+  window.addEventListener("resize", place);
+  sized.observe(node);
+  setTimeout(place); // 붙은 뒤 한 번
+}