diff --git a/A00_Common/design/design_profile.ts b/A00_Common/design/design_profile.ts
index cc0b3335e..8145a6ba3 100644
--- a/A00_Common/design/design_profile.ts
+++ b/A00_Common/design/design_profile.ts
@@ -15,13 +15,10 @@ import { routeSpansFromStructures } from "../../B05_Profile/B05_Profile_UI_Drain
 import { readState, writeState } from "../b_page_state";
 import type { SectionDetailResponse } from "../../B06_Section/B06_Section_Api_Fetch";
 import { createWorkflowPanelHandle } from "@ui/ui_template_overlay";
-import { createMassHaulBadge } from "@util/common_util_mass_haul_badge";
-import { createHaulPlanPrefetch } from "../../B05_Profile/B05_Profile_Api_HaulPlan";
 import type {
   StructureInstance,
   StructureType,
 } from "../../B05_Profile/B05_Profile_Api_Structures";
-import { createProfileTableOverlay } from "../../B05_Profile/B05_Profile_UI_Profile_TableOverlay";
 import {
   hasLegacyAlignment,
   readAlignment,
@@ -56,11 +53,7 @@ import {
   structureIdKeeping,
 } from "../../B05_Profile/B05_Profile_UI_Profile_Structures";
 import { configureBalloonOffsets } from "@util/common_util_mass_haul_balance_view";
-import {
-  createRouteMassHaulPanel,
-  type MassHaulSummaryValues,
-  type RouteMassHaulContext,
-} from "../../B05_Profile/B05_Profile_UI_Profile_MassHaul";
+import type { RouteMassHaulContext } from "../../B05_Profile/B05_Profile_UI_Profile_MassHaul";
 import { renderBalanceBar } from "../../B05_Profile/B05_Profile_UI_Profile_Balance";
 import { createHeightCascade } from "../../B05_Profile/B05_Profile_UI_Profile_Heights";
 import { renderProfile } from "../../B05_Profile/B05_Profile_UI_Profile_Render";
@@ -83,9 +76,11 @@ import {
   snapToMasterStations,
 } from "../../B05_Profile/B05_Profile_UI_Profile_Guard";
 import type { RouteProfilePanelCallbacks } from "../../B05_Profile/B05_Profile_UI_Profile_Panel_Types";
-import { attachWheelHorizontalScroll } from "../../B05_Profile/B05_Profile_UI_Profile_Wheel";
-import { needsFullRedraw, type ElevationWindowResult } from "@util/common_util_chart_ywindow";
+import type { ElevationWindowResult } from "@util/common_util_chart_ywindow";
 import type { DesignSideBoard, DesignSideFactory, DesignView } from "./design_profile_slots";
+import { noticeDroppedEdits } from "./design_save";
+import { createProfileOverlays } from "./design_profile_overlays";
+import { bindProfileViewport } from "./design_profile_viewport";
 import "../../B06_Section/B06_Section_UI_Style.css";
 // SVG 차트 색상(.b06-chart__*)의 정의처는 _Style_Cross.css다. 이걸 빼면 B05로 바로 진입했을 때
 // 배경 rect가 브라우저 기본 fill(검정)로 그려진다 — B06을 먼저 방문해야 정상으로 보이던 원인.
@@ -161,40 +156,14 @@ export function createDesignProfile(ctx: DesignProfileContext) {
     if (drag.isSubDragging()) scheduleLightSync();
     else draw();
   };
-  /** 유토곡선 총괄값 — **그래프 좌측 상단 배지**가 보인다(2026-09-06 사용자 지시).
-   *  유토곡선을 접어도 이 값은 남아야 한다. */
-  const massBadge = createMassHaulBadge();
-  // 그래프 위에 도구줄(상단줄)이 한 줄 있다 — 그 아래로 내려 겹치지 않게 한다.
-  massBadge.root.style.setProperty("--mass-haul-badge-top", "34px");
-  bodyWrap.append(massBadge.root);
-  let massHaulSummary: MassHaulSummaryValues | null = null;
-  // 유토 배분은 **서버가 만든다**(2026-09-06) — 편집이 멈추면 뒤에서 받아 두고, 도착하면
-  // 곡선을 다시 그린다. 그 산식이 브라우저 번들에 안 실리는 것이 이 구조의 목적이다.
-  const haulPrefetch = createHaulPlanPrefetch(
+  // 유토곡선 · 테이블 오버레이 · 유토 배지는 `design_profile_overlays` 몫(700줄 한계).
+  const { massHaul, tableOverlay } = createProfileOverlays({
     projectId,
-    () => routeId ?? undefined,
-    subPanelChanged,
-  );
-  const massHaul = createRouteMassHaulPanel(
-    subPanelChanged,
-    (summary) => {
-      const before = massHaulSummary;
-      massHaulSummary = summary;
-      if (before?.finalM3 !== summary?.finalM3) massBadge.set(summary);
-    },
-    haulPrefetch,
-  );
-  bodyWrap.append(massHaul.overlay, massHaul.handle);
-  // 오버레이의 가로 스크롤을 종단 스크롤러와 양방향 동기화 — 측점 세로선 정렬 유지.
-  massHaul.attachScrollSync(body);
-  // 테이블도 유토곡선과 같은 오버레이 서브패널 — 유토곡선 위에 쌓인다(2026-08-05 사용자 지시).
-  const tableOverlay = createProfileTableOverlay(subPanelChanged);
-  bodyWrap.append(tableOverlay.overlay, tableOverlay.handle);
-  tableOverlay.attachScrollSync(body);
-  // 유토곡선·테이블 영역에서 브라우저 기본 우클릭 메뉴를 막는다(2026-08-05 사용자 지시).
-  // 종단 그래프의 구조물 메뉴는 chartWrap에서 이미 preventDefault 후 자체 메뉴를 띄운다.
-  body.addEventListener("contextmenu", (event) => event.preventDefault());
-  massHaul.overlay.addEventListener("contextmenu", (event) => event.preventDefault());
+    routeId: () => routeId,
+    bodyWrap,
+    body,
+    onChange: subPanelChanged,
+  });
   const content = document.createElement("div");
   content.className = "b05-route-profile__content";
   /** 횡단배수 최소 계획고 대상(배수관·BOX암거) — 관 목록이 바뀔 때 갱신한다. */
@@ -453,7 +422,7 @@ export function createDesignProfile(ctx: DesignProfileContext) {
       zoom: profileZoom.state,
       holdElevationRange: elevationHold.hold,
       toolActive: () => tools.mode() !== "none",
-      selectedRuns: () => tools.selectedRuns(),
+      tools,
       stationIdAtStructure,
       redraw: draw,
       setElevationWindowUpdater: (update) => {
@@ -462,44 +431,17 @@ export function createDesignProfile(ctx: DesignProfileContext) {
     });
   }
 
-  /** 그래프를 통째로 다시 만들 때까지 기다리는 시간(ms) — 눈금 갱신으로도 못 살릴 때만. */
-  const SCROLL_SETTLE_MS = 80;
-  /** 마지막으로 통째로 다시 만든 가로 위치 — 같은 자리면 다시 그리지 않는다. */
-  let settledScrollLeft = 0;
-  let scrollSettleTimer = 0;
-  // 세로 맞춤은 **그리기가 아니라 변환**이다(2026-09-04 사용자 확정) — 스크롤마다 겹 하나의
-  // 변환만 갈아 끼우므로 실시간으로 따라온다. 눈금 간격이 어긋나면 눈금층(요소 20개 안팎)만
-  // 새로 만든다. 그래프를 통째로 다시 만드는 34ms 짜리 재구성은 그래도 안 될 때만 남는다.
-  body.addEventListener("scroll", () => {
-    if (elevationHold.editing()) return;
-    const fitted = updateElevationWindow?.() ?? null;
-    window.clearTimeout(scrollSettleTimer);
-    if (!needsFullRedraw(fitted)) return;
-    scrollSettleTimer = window.setTimeout(() => {
-      if (elevationHold.editing() || Math.abs(body.scrollLeft - settledScrollLeft) < 1) return;
-      settledScrollLeft = body.scrollLeft;
-      draw();
-    }, SCROLL_SETTLE_MS);
+  // 가로 스크롤 · 휠 · 크기 바뀜은 `design_profile_viewport` 몫(700줄 한계).
+  const unbindViewport = bindProfileViewport({
+    body,
+    editing: () => elevationHold.editing(),
+    fitElevation: () => updateElevationWindow?.() ?? null,
+    draw: () => draw(),
+    lastSize: () => ({ width: lastWidth, height: lastHeight }),
+    scheduleLightSync,
+    scheduleDraw: () => drag.scheduleDraw(),
   });
 
-  // 종단면도는 가로로 매우 길다. 세로 휠을 가로 스크롤로 돌려 스크롤바를 잡지 않고도
-  // 노선을 훑을 수 있게 한다 (Shift+휠은 브라우저 기본 가로 스크롤이라 그대로 둔다).
-  attachWheelHorizontalScroll(body);
-
-  const resizeObserver = new ResizeObserver(() => {
-    if (
-      body.clientWidth <= 0 ||
-      body.clientHeight <= 0 ||
-      (Math.abs(body.clientWidth - lastWidth) < 1 && Math.abs(body.clientHeight - lastHeight) < 1)
-    )
-      return;
-    // 끌리는 동안엔 프레임당 경량 높이 동기화만 — 무거운 전체 재구성은 손을 뗀 뒤 한 번.
-    // (150ms 디바운스만 있던 예전 방식은 중간 프레임이 없어 툭툭 끊겼다. 2026-08-05 사용자 보고)
-    scheduleLightSync();
-    drag.scheduleDraw();
-  });
-  resizeObserver.observe(body);
-
   // 접기 — 두 보기가 같은 키 하나를 쓴다(`_Profile_Drag` 몫).
   bindProfileCollapse(root, panelHandle, () => requestAnimationFrame(draw));
 
@@ -650,6 +592,7 @@ export function createDesignProfile(ctx: DesignProfileContext) {
     async save(): Promise<void> {
       if (!routeId || !store.dirty()) return;
       const saved = await saveProfileAlignment(projectId, routeId, store.edits());
+      noticeDroppedEdits(saved);
       const next = saved.profile_alignment as ProfileAlignment | undefined;
       if (next?.base_pvi?.length) {
         base = toAlignmentBase(next);
@@ -689,7 +632,7 @@ export function createDesignProfile(ctx: DesignProfileContext) {
       setListening(false);
       drag.dispose();
       crossPreview.dispose();
-      resizeObserver.disconnect();
+      unbindViewport();
     },
   };
 }
diff --git a/A00_Common/design/design_profile_free.ts b/A00_Common/design/design_profile_free.ts
new file mode 100644
index 000000000..9a35981fb
--- /dev/null
+++ b/A00_Common/design/design_profile_free.ts
@@ -0,0 +1,363 @@
+/* =============================================================================
+ * A00_Common/design/design_profile_free.ts
+ * 종단 [자유지정] 계산 — 범위 · 클릭 점 · 측점선 붙음 · 높이 변환 · 기울기 판정 · 적용(215-1).
+ *
+ * 흐름: 세로 측점선 둘로 범위를 고름 → 시작(또는 끝) 세로선 근처 클릭 = 그 측점 계획고에 이은
+ * 채 시작 → 클릭마다 점 하나(가로 = 범위 안 가장 가까운 측점선 · 높이 = 클릭한 높이) → 반대쪽
+ * 세로선 근처 클릭 또는 Enter = 그 측점 계획고에 이어 끝. Esc = 취소 · Backspace = 마지막 점 빼기.
+ *
+ * 적용은 직선화와 같은 길 — 편집 델타(`station_offsets` · `curve_radii`)만 만들어 캐시에 쓰고
+ * [저장] 때 서버가 다시 셈한다. 꺾이는 점 종단곡선 = 직선화 틸팅과 같은 기본 길이 L
+ * (R = L / |대수차|). 양 끝 세로선의 라운드는 직선화처럼 그대로 둔다.
+ *
+ * 화면(`design_profile_free_view.ts`)은 클릭 · 마우스 · 키만 넘기고 여기 표시 자료를 그린다.
+ * ========================================================================== */
+
+import type {
+  AlignmentBase,
+  AlignmentEdits,
+  ProfileAlignment,
+} from "../../B05_Profile/B05_Profile_UI_Profile_Alignment";
+import {
+  buildAlignment,
+  chainageKey,
+  controlElevationAt,
+} from "../../B05_Profile/B05_Profile_UI_Profile_Alignment";
+import {
+  baseElevationAt,
+  defaultCurveLength,
+} from "../../B05_Profile/B05_Profile_UI_Profile_Straighten";
+
+/** 두 chainage 를 같은 측점으로 볼 허용 오차(m). */
+const SAME_M = 1e-6;
+/** 클릭 높이를 이 단위(m)로 끊는다. */
+const ELEVATION_STEP_M = 0.01;
+
+export interface FreeVertex {
+  chainage_m: number;
+  elevation_m: number;
+}
+
+/** range = 범위 고르는 중 · armed = 시작 세로선을 기다림 · drawing = 점 찍는 중. */
+export type FreePhase = "range" | "armed" | "drawing";
+
+/** 그래프 세로 창 — 그릴 때 기준(`data-yw-*`)과 지금 걸린 변환. */
+export interface ChartWindow {
+  center: number;
+  pxPerM: number;
+  zero: number;
+  scale: number;
+  offset: number;
+}
+
+/** 세로 창 변환 글(`translate(0 a) scale(1 b)`)을 읽는다 — 없으면 그릴 때 그대로. */
+export function parseWindowTransform(text: string | null): { scale: number; offset: number } {
+  const num = "([-+0-9.eE]+)";
+  const match = new RegExp(`translate\\(\\s*0[ ,]+${num}\\s*\\)\\s*scale\\(\\s*1[ ,]+${num}`).exec(
+    text ?? "",
+  );
+  if (!match) return { scale: 1, offset: 0 };
+  const offset = Number(match[1]);
+  const scale = Number(match[2]);
+  return Number.isFinite(offset) && Number.isFinite(scale) && scale > 0
+    ? { scale, offset }
+    : { scale: 1, offset: 0 };
+}
+
+/** 그래프 y(px) → 표고(m). 과장 배율은 `pxPerM` 에 들어 있다. */
+export function elevationAtChartY(view: ChartWindow, y: number): number {
+  const baked = (y - view.offset) / view.scale;
+  return view.center + (view.zero - baked) / view.pxPerM;
+}
+
+/** 표고(m) → 그래프 y(px). `elevationAtChartY` 의 역. */
+export function chartYAtElevation(view: ChartWindow, elevationM: number): number {
+  return view.scale * (view.zero - (elevationM - view.center) * view.pxPerM) + view.offset;
+}
+
+/** 가장 가까운 측점 세로선. 범위를 주면 그 안(양 끝 포함)에서만 고른다. */
+export function snapStation(
+  stations: number[],
+  chainageM: number,
+  range: [number, number] | null = null,
+): number | null {
+  let best: number | null = null;
+  for (const station of stations) {
+    if (range && (station < range[0] - SAME_M || station > range[1] + SAME_M)) continue;
+    if (best === null || Math.abs(station - chainageM) < Math.abs(best - chainageM)) {
+      best = station;
+    }
+  }
+  return best;
+}
+
+/** 두 점 사이 기울기(%). */
+export function gradePct(from: FreeVertex, to: FreeVertex): number {
+  const span = to.chainage_m - from.chainage_m;
+  return Math.abs(span) > 1e-12 ? ((to.elevation_m - from.elevation_m) / span) * 100 : 0;
+}
+
+/** 임도 기준 최대 기울기를 넘는가 — 판정은 선형 계산의 위반 판정(`violations`)과 같은 식. */
+export function overGrade(pct: number, maxPct: number): boolean {
+  return Math.abs(pct) > maxPct + 1e-6;
+}
+
+/** 점들을 잇는 꺾은선 위 표고(chainage 오름차순 꺾은선). */
+function elevationOnPath(path: FreeVertex[], chainageM: number): number {
+  for (let index = 1; index < path.length; index += 1) {
+    const left = path[index - 1];
+    const right = path[index];
+    if (chainageM > right.chainage_m + SAME_M) continue;
+    const span = right.chainage_m - left.chainage_m;
+    const ratio = span > 1e-12 ? (chainageM - left.chainage_m) / span : 0;
+    return left.elevation_m + (right.elevation_m - left.elevation_m) * ratio;
+  }
+  return path[path.length - 1].elevation_m;
+}
+
+/**
+ * 꺾은선을 계획고 편집으로 바꾼다 — 범위 안 변화점 · 클릭 점을 그 선 위로 옮기고 옛 라운드를
+ * 지운 뒤, 꺾이는 클릭 점에만 종단곡선을 넣는다. 양 끝 점은 손대지 않는다(직선화와 같음).
+ */
+export function buildFreeEdits(
+  base: AlignmentBase,
+  edits: AlignmentEdits,
+  vertices: FreeVertex[],
+): AlignmentEdits {
+  const path = [...vertices].sort((a, b) => a.chainage_m - b.chainage_m);
+  if (path.length < 2) return edits;
+  const fromM = path[0].chainage_m;
+  const toM = path[path.length - 1].chainage_m;
+  if (toM - fromM <= SAME_M) return edits;
+  const inner = new Map<string, number>();
+  buildAlignment(base, edits).pvi.forEach((node) => {
+    if (node.chainage_m > fromM + SAME_M && node.chainage_m < toM - SAME_M) {
+      inner.set(chainageKey(node.chainage_m), node.chainage_m);
+    }
+  });
+  path
+    .slice(1, -1)
+    .forEach((vertex) => inner.set(chainageKey(vertex.chainage_m), vertex.chainage_m));
+  const offsets = { ...edits.station_offsets };
+  const radii = { ...edits.curve_radii };
+  inner.forEach((chainage, key) => {
+    const target = elevationOnPath(path, chainage);
+    offsets[key] = Number((target - baseElevationAt(base, chainage)).toFixed(6));
+    delete radii[key];
+  });
+  for (let index = 1; index < path.length - 1; index += 1) {
+    const gradeIn = gradePct(path[index - 1], path[index]) / 100;
+    const gradeOut = gradePct(path[index], path[index + 1]) / 100;
+    const deltaGrade = Math.abs(gradeOut - gradeIn);
+    if (deltaGrade < 1e-9) continue;
+    radii[chainageKey(path[index].chainage_m)] = Number(
+      (defaultCurveLength(base, deltaGrade) / deltaGrade).toFixed(6),
+    );
+  }
+  return { ...edits, station_offsets: offsets, curve_radii: radii };
+}
+
+export interface FreeSegment {
+  from: FreeVertex;
+  to: FreeVertex;
+  grade_pct: number;
+  over: boolean;
+  /** 마지막 점 → 마우스 자리(아직 안 찍음). */
+  preview: boolean;
+}
+
+/** 오버레이 표시 자료 — 화면은 이것만 그린다. */
+export interface FreeMarks {
+  /** 고른 범위(강조 띠) — 둘 다 고르기 전엔 null. */
+  band: [number, number] | null;
+  /** 세로 강조선 chainage(범위 첫 측점 또는 범위 양 끝). */
+  edges: number[];
+  segments: FreeSegment[];
+  /** 찍힌 점(시작 점 포함). */
+  dots: FreeVertex[];
+}
+
+export interface FreeDrawDeps {
+  base: () => AlignmentBase | null;
+  alignment: () => ProfileAlignment | null;
+  edits: () => AlignmentEdits;
+  /** 편집 적용 — 직선화 결과와 같은 길(캐시 · 되돌리기 · 막기 규칙). */
+  apply: (next: AlignmentEdits) => void;
+  /** 모드를 끈다(적용 뒤 · Esc). */
+  close: () => void;
+  /** 단계 · 안내가 바뀜. */
+  changed: () => void;
+}
+
+export interface FreeDraw {
+  phase: () => FreePhase;
+  reset: () => void;
+  /** 그래프 클릭 — 날 chainage · 표고와 그래프 측점선 목록. 먹었으면 true. */
+  click: (chainageM: number, elevationM: number, stations: number[]) => boolean;
+  /** 마우스 자리 — 미리 보기 대상. 그래프 밖이면 null. */
+  hover: (pointer: { chainageM: number; elevationM: number; stations: number[] } | null) => void;
+  /** Enter · Escape · Backspace — 먹었으면 true. */
+  key: (key: string) => boolean;
+  marks: () => FreeMarks;
+  hint: () => string;
+}
+
+export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
+  let phase: FreePhase = "range";
+  let pending: number | null = null;
+  let range: [number, number] | null = null;
+  let anchor: number | null = null;
+  let points: FreeVertex[] = [];
+  let target: FreeVertex | null = null;
+
+  function reset(): void {
+    phase = "range";
+    pending = null;
+    range = null;
+    anchor = null;
+    points = [];
+    target = null;
+  }
+
+  /** 그 측점의 지금 계획고(변화점이면 라운드 중심 z — 직선화와 같은 값). */
+  function heightAt(chainageM: number): number | null {
+    const alignment = deps.alignment();
+    return alignment ? controlElevationAt(alignment, chainageM) : null;
+  }
+
+  const finishM = (): number | null =>
+    range && anchor !== null ? (anchor === range[0] ? range[1] : range[0]) : null;
+  const same = (a: number | null, b: number | null): boolean =>
+    a !== null && b !== null && Math.abs(a - b) < SAME_M;
+
+  /** 지나온 점(시작 포함) — 마지막 것이 다음 선의 출발점. */
+  function path(): FreeVertex[] {
+    if (anchor === null) return [];
+    const z = heightAt(anchor);
+    return z === null ? [] : [{ chainage_m: anchor, elevation_m: z }, ...points];
+  }
+
+  /** 클릭 · 마우스 자리 → 다음 점 후보. 끝 세로선이면 그 계획고, 뒤로 가면 null. */
+  function candidate(chainageM: number, elevationM: number, stations: number[]): FreeVertex | null {
+    if (phase !== "drawing" || !range) return null;
+    const station = snapStation(stations, chainageM, range);
+    const end = finishM();
+    if (station === null || end === null) return null;
+    if (same(station, end)) {
+      const z = heightAt(end);
+      return z === null ? null : { chainage_m: end, elevation_m: z };
+    }
+    const walked = path();
+    const last = walked[walked.length - 1];
+    if (!last || (station - last.chainage_m) * Math.sign(end - last.chainage_m) <= SAME_M) {
+      return null;
+    }
+    const z = Math.round(elevationM / ELEVATION_STEP_M) * ELEVATION_STEP_M;
+    return { chainage_m: station, elevation_m: Number(z.toFixed(3)) };
+  }
+
+  function finish(): void {
+    const base = deps.base();
+    const end = finishM();
+    const z = end === null ? null : heightAt(end);
+    if (!base || end === null || z === null) return;
+    const vertices = [...path(), { chainage_m: end, elevation_m: z }];
+    const next = buildFreeEdits(base, deps.edits(), vertices);
+    reset();
+    deps.apply(next);
+    deps.close();
+  }
+
+  return {
+    phase: () => phase,
+    reset,
+    click(chainageM, elevationM, stations) {
+      if (phase === "range") {
+        const station = snapStation(stations, chainageM);
+        if (station === null) return true;
+        if (pending === null || same(pending, station)) pending = station;
+        else {
+          range = [Math.min(pending, station), Math.max(pending, station)];
+          pending = null;
+          phase = "armed";
+        }
+      } else if (phase === "armed" && range) {
+        const station = snapStation(stations, chainageM, range);
+        if (same(station, range[0]) || same(station, range[1])) {
+          anchor = station;
+          points = [];
+          phase = "drawing";
+        }
+      } else if (phase === "drawing") {
+        const next = candidate(chainageM, elevationM, stations);
+        if (!next) return true;
+        if (same(next.chainage_m, finishM())) {
+          finish();
+          return true;
+        }
+        points.push(next);
+      }
+      target = null;
+      deps.changed();
+      return true;
+    },
+    hover(pointer) {
+      target = pointer ? candidate(pointer.chainageM, pointer.elevationM, pointer.stations) : null;
+    },
+    key(key) {
+      if (key === "Escape") {
+        reset();
+        deps.close();
+        return true;
+      }
+      if (key === "Enter") {
+        if (phase !== "drawing") return false;
+        finish();
+        return true;
+      }
+      if (key === "Backspace") {
+        if (phase !== "drawing") return false;
+        if (points.length) points.pop();
+        else {
+          anchor = null;
+          phase = "armed";
+        }
+        target = null;
+        deps.changed();
+        return true;
+      }
+      return false;
+    },
+    marks() {
+      const maxPct = deps.base()?.policy.max_grade_pct ?? Number.POSITIVE_INFINITY;
+      const dots = path();
+      const line = target ? [...dots, target] : dots;
+      const segments: FreeSegment[] = [];
+      for (let index = 1; index < line.length; index += 1) {
+        const grade = gradePct(line[index - 1], line[index]);
+        segments.push({
+          from: line[index - 1],
+          to: line[index],
+          grade_pct: grade,
+          over: overGrade(grade, maxPct),
+          preview: target !== null && index === line.length - 1,
+        });
+      }
+      return {
+        band: range,
+        edges: range ? [...range] : pending !== null ? [pending] : [],
+        segments,
+        dots,
+      };
+    },
+    hint() {
+      if (phase === "range") {
+        return pending === null
+          ? "자유지정 — 범위 첫 세로 측점선을 고르세요"
+          : `${pending.toFixed(1)}m 선택 — 범위 끝 세로 측점선을 고르세요`;
+      }
+      if (phase === "armed") return "시작(또는 끝) 세로선 근처를 눌러 시작하세요 (Esc 취소)";
+      return "클릭마다 점 · 반대쪽 세로선 또는 Enter 로 끝 (Backspace 점 빼기 · Esc 취소)";
+    },
+  };
+}
diff --git a/A00_Common/design/design_profile_free_view.ts b/A00_Common/design/design_profile_free_view.ts
new file mode 100644
index 000000000..9584478f9
--- /dev/null
+++ b/A00_Common/design/design_profile_free_view.ts
@@ -0,0 +1,217 @@
+/* =============================================================================
+ * A00_Common/design/design_profile_free_view.ts
+ * 종단 [자유지정] 화면 — 그래프 클릭 · 마우스 · 오버레이(범위 강조 · 점선 · 기울기 글)(215-1).
+ *
+ * 계산 · 상태는 `design_profile_free.ts` 몫. 여기서는 마우스 자리를 (chainage, 표고)로 바꿔
+ * 넘기고 돌려받은 표시 자료를 그린다. 표고 변환은 종단 그래프 세로 창(`data-yw-*` + 지금 걸린
+ * 변환)을 그대로 되짚는다 — 스크롤로 창이 바뀌어도 같은 식이다.
+ *
+ * 그래프는 그릴 때마다 새로 만들어지므로 그릴 때마다 `mount` 를 다시 부른다.
+ * 자유지정 중엔 그래프 클릭 · 누르기를 여기서 먹는다(측점 고르기 · 구조물 끌기로 새지 않게).
+ * ========================================================================== */
+
+import { Y_WINDOW_ATTRS, Y_WINDOW_CLASS } from "../../B06_Section/B06_Section_UI_Longitudinal";
+import {
+  chartYAtElevation,
+  elevationAtChartY,
+  parseWindowTransform,
+  type ChartWindow,
+  type FreeDraw,
+} from "./design_profile_free";
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+/** 종단 그래프 한 벌의 가로 매핑 — 렌더러가 그릴 때마다 넘긴다. */
+export interface FreeChartGeom {
+  /** 그래프 래퍼(`b05-profile__chart`). */
+  chart: HTMLElement;
+  /** 가로 스크롤러 — 스크롤하면 세로 창이 바뀌어 다시 그린다. */
+  scroller: HTMLElement;
+  x: (chainageM: number) => number;
+  toChainage: (px: number) => number;
+  widthPx: number;
+  heightPx: number;
+  /** 그래프 세로 측점선 chainage(정규 + 구조물). */
+  stations: number[];
+}
+
+export interface FreeView {
+  /** 그래프를 새로 그렸거나 모드가 바뀜 — 켜져 있으면 붙이고, 꺼져 있으면 뗀다. */
+  mount: (geom: FreeChartGeom | null, active: boolean) => void;
+  redraw: () => void;
+}
+
+function svgEl(tag: string, attrs: Record<string, string | number>): SVGElement {
+  const element = document.createElementNS(SVG_NS, tag);
+  Object.entries(attrs).forEach(([name, value]) => element.setAttribute(name, String(value)));
+  return element;
+}
+
+/** 지금 그래프의 세로 창 — 자동 창 SVG 가 없으면 null. */
+function readWindow(chart: HTMLElement): { view: ChartWindow; top: number } | null {
+  const svg = chart.querySelector<SVGSVGElement>(`svg[${Y_WINDOW_ATTRS.auto}="1"]`);
+  if (!svg) return null;
+  const read = (name: string): number => Number(svg.getAttribute(name));
+  const layer = svg.querySelector(`.${Y_WINDOW_CLASS}`);
+  const view: ChartWindow = {
+    center: read(Y_WINDOW_ATTRS.center),
+    pxPerM: read(Y_WINDOW_ATTRS.pxPerM),
+    zero: read(Y_WINDOW_ATTRS.zero),
+    ...parseWindowTransform(layer?.getAttribute("transform") ?? null),
+  };
+  if (![view.center, view.pxPerM, view.zero].every(Number.isFinite) || view.pxPerM <= 0) {
+    return null;
+  }
+  // 그래프 SVG 가 래퍼 위쪽에서 떨어져 있으면 그만큼 오버레이 y 를 맞춘다.
+  const top = svg.getBoundingClientRect().top - chart.getBoundingClientRect().top;
+  return { view, top };
+}
+
+export function createFreeView(free: FreeDraw): FreeView {
+  let geom: FreeChartGeom | null = null;
+  let active = false;
+  let overlay: SVGSVGElement | null = null;
+  let listeners: AbortController | null = null;
+
+  /** 마우스 자리 → (chainage, 표고). 그래프 밖이면 null. */
+  function pointerAt(event: MouseEvent) {
+    if (!geom) return null;
+    const win = readWindow(geom.chart);
+    if (!win) return null;
+    const rect = geom.chart.getBoundingClientRect();
+    const chainageM = geom.toChainage(event.clientX - rect.left);
+    if (!Number.isFinite(chainageM)) return null;
+    const elevationM = elevationAtChartY(win.view, event.clientY - rect.top - win.top);
+    return { chainageM, elevationM, stations: geom.stations };
+  }
+
+  function redraw(): void {
+    overlay?.remove();
+    overlay = null;
+    if (!geom || !active) return;
+    const win = readWindow(geom.chart);
+    if (!win) return;
+    const { x, widthPx, heightPx } = geom;
+    const y = (elevationM: number): number => chartYAtElevation(win.view, elevationM) + win.top;
+    const marks = free.marks();
+    const svg = svgEl("svg", {
+      class: "b05-profile-freemark",
+      width: widthPx,
+      height: heightPx,
+      viewBox: `0 0 ${widthPx} ${heightPx}`,
+    }) as SVGSVGElement;
+    if (marks.band) {
+      const [left, right] = marks.band.map(x);
+      svg.append(
+        svgEl("rect", {
+          class: "b05-profile-freemark__band",
+          x: left,
+          y: 0,
+          width: Math.max(0, right - left),
+          height: heightPx,
+        }),
+      );
+    }
+    marks.edges.forEach((chainage) =>
+      svg.append(
+        svgEl("line", {
+          class: "b05-profile-freemark__edge",
+          x1: x(chainage),
+          x2: x(chainage),
+          y1: 0,
+          y2: heightPx,
+        }),
+      ),
+    );
+    marks.segments.forEach((segment) => {
+      const x1 = x(segment.from.chainage_m);
+      const x2 = x(segment.to.chainage_m);
+      const y1 = y(segment.from.elevation_m);
+      const y2 = y(segment.to.elevation_m);
+      const over = segment.over ? " is-over" : "";
+      svg.append(
+        svgEl("line", {
+          class: `b05-profile-freemark__line${over}${segment.preview ? " is-preview" : ""}`,
+          x1,
+          y1,
+          x2,
+          y2,
+        }),
+      );
+      const label = svgEl("text", {
+        class: `b05-profile-freemark__grade${over}`,
+        x: (x1 + x2) / 2,
+        y: (y1 + y2) / 2 - 6,
+        "text-anchor": "middle",
+      });
+      label.textContent = `${segment.grade_pct.toFixed(1)}%`;
+      svg.append(label);
+    });
+    marks.dots.forEach((dot) =>
+      svg.append(
+        svgEl("circle", {
+          class: "b05-profile-freemark__dot",
+          cx: x(dot.chainage_m),
+          cy: y(dot.elevation_m),
+          r: 3.5,
+        }),
+      ),
+    );
+    overlay = svg;
+    geom.chart.append(svg);
+  }
+
+  function mount(next: FreeChartGeom | null, on: boolean): void {
+    listeners?.abort();
+    listeners = null;
+    if (next) geom = next;
+    active = on;
+    if (!on) free.reset();
+    if (!geom || !on || !geom.chart.isConnected) {
+      overlay?.remove();
+      overlay = null;
+      return;
+    }
+    listeners = new AbortController();
+    const { signal } = listeners;
+    const chart = geom.chart;
+    const swallow = (event: Event): void => {
+      event.stopPropagation();
+      event.stopImmediatePropagation();
+    };
+    // 누르기는 삼킴 — 구조물 측점선 끌기 · 계획고 버튼 길게 누르기가 시작되지 않게.
+    chart.addEventListener("pointerdown", swallow, { capture: true, signal });
+    chart.addEventListener(
+      "click",
+      (event) => {
+        swallow(event);
+        event.preventDefault();
+        const pointer = pointerAt(event);
+        if (pointer) free.click(pointer.chainageM, pointer.elevationM, pointer.stations);
+        free.hover(pointerAt(event));
+        redraw();
+      },
+      { capture: true, signal },
+    );
+    chart.addEventListener(
+      "mousemove",
+      (event) => {
+        free.hover(pointerAt(event));
+        redraw();
+      },
+      { signal },
+    );
+    chart.addEventListener(
+      "mouseleave",
+      () => {
+        free.hover(null);
+        redraw();
+      },
+      { signal },
+    );
+    geom.scroller.addEventListener("scroll", redraw, { signal, passive: true });
+    redraw();
+  }
+
+  return { mount, redraw };
+}
diff --git a/A00_Common/design/design_profile_overlays.ts b/A00_Common/design/design_profile_overlays.ts
new file mode 100644
index 000000000..eb60de408
--- /dev/null
+++ b/A00_Common/design/design_profile_overlays.ts
@@ -0,0 +1,63 @@
+/* =============================================================================
+ * design_profile_overlays.ts
+ * 종단도 바닥 오버레이 서브패널 — 유토곡선 · 테이블 · 유토 총괄 배지(213-3 · 700줄 한계로 뗌).
+ * 만들어 `bodyWrap` 에 붙이고 종단 스크롤과 잇는 데까지 — 그리기 · 높이는 종단도 몫.
+ * ========================================================================== */
+
+import { createMassHaulBadge } from "@util/common_util_mass_haul_badge";
+import { createHaulPlanPrefetch } from "../../B05_Profile/B05_Profile_Api_HaulPlan";
+import { createProfileTableOverlay } from "../../B05_Profile/B05_Profile_UI_Profile_TableOverlay";
+import {
+  createRouteMassHaulPanel,
+  type MassHaulSummaryValues,
+} from "../../B05_Profile/B05_Profile_UI_Profile_MassHaul";
+
+export interface ProfileOverlaysDeps {
+  projectId: string;
+  routeId: () => number | null;
+  /** 종단 열(요약 줄 · 본문 · 서클을 담은 칸) — 오버레이가 그 위를 덮는다. */
+  bodyWrap: HTMLElement;
+  /** 종단 스크롤러 — 오버레이 가로 스크롤을 이것과 맞춘다. */
+  body: HTMLElement;
+  /** 서브패널이 바뀜(펼침 · 범례 · 리사이저 · 유토 배분 도착). */
+  onChange: () => void;
+}
+
+export function createProfileOverlays(deps: ProfileOverlaysDeps) {
+  const { bodyWrap, body, onChange } = deps;
+  /** 유토곡선 총괄값 — **그래프 좌측 상단 배지**가 보인다(2026-09-06 사용자 지시).
+   *  유토곡선을 접어도 이 값은 남아야 한다. */
+  const massBadge = createMassHaulBadge();
+  // 그래프 위에 도구줄(상단줄)이 한 줄 있다 — 그 아래로 내려 겹치지 않게 한다.
+  massBadge.root.style.setProperty("--mass-haul-badge-top", "34px");
+  bodyWrap.append(massBadge.root);
+  let massHaulSummary: MassHaulSummaryValues | null = null;
+  // 유토 배분은 **서버가 만든다**(2026-09-06) — 편집이 멈추면 뒤에서 받아 두고, 도착하면
+  // 곡선을 다시 그린다. 그 산식이 브라우저 번들에 안 실리는 것이 이 구조의 목적이다.
+  const haulPrefetch = createHaulPlanPrefetch(
+    deps.projectId,
+    () => deps.routeId() ?? undefined,
+    onChange,
+  );
+  const massHaul = createRouteMassHaulPanel(
+    onChange,
+    (summary) => {
+      const before = massHaulSummary;
+      massHaulSummary = summary;
+      if (before?.finalM3 !== summary?.finalM3) massBadge.set(summary);
+    },
+    haulPrefetch,
+  );
+  bodyWrap.append(massHaul.overlay, massHaul.handle);
+  // 오버레이의 가로 스크롤을 종단 스크롤러와 양방향 동기화 — 측점 세로선 정렬 유지.
+  massHaul.attachScrollSync(body);
+  // 테이블도 유토곡선과 같은 오버레이 서브패널 — 유토곡선 위에 쌓인다(2026-08-05 사용자 지시).
+  const tableOverlay = createProfileTableOverlay(onChange);
+  bodyWrap.append(tableOverlay.overlay, tableOverlay.handle);
+  tableOverlay.attachScrollSync(body);
+  // 유토곡선·테이블 영역에서 브라우저 기본 우클릭 메뉴를 막는다(2026-08-05 사용자 지시).
+  // 종단 그래프의 구조물 메뉴는 chartWrap에서 이미 preventDefault 후 자체 메뉴를 띄운다.
+  body.addEventListener("contextmenu", (event) => event.preventDefault());
+  massHaul.overlay.addEventListener("contextmenu", (event) => event.preventDefault());
+  return { massHaul, tableOverlay };
+}
diff --git a/A00_Common/design/design_profile_viewport.ts b/A00_Common/design/design_profile_viewport.ts
new file mode 100644
index 000000000..ea193f514
--- /dev/null
+++ b/A00_Common/design/design_profile_viewport.ts
@@ -0,0 +1,66 @@
+/* =============================================================================
+ * design_profile_viewport.ts
+ * 종단 스크롤러의 가로 스크롤 · 휠 · 크기 바뀜 듣개(213-3 · 700줄 한계로 뗌).
+ * 다시 그리기 · 높이 동기화는 종단도가 넘긴 함수를 부른다.
+ * ========================================================================== */
+
+import { attachWheelHorizontalScroll } from "../../B05_Profile/B05_Profile_UI_Profile_Wheel";
+import { needsFullRedraw, type ElevationWindowResult } from "@util/common_util_chart_ywindow";
+
+/** 그래프를 통째로 다시 만들 때까지 기다리는 시간(ms) — 눈금 갱신으로도 못 살릴 때만. */
+const SCROLL_SETTLE_MS = 80;
+
+export interface ProfileViewportDeps {
+  body: HTMLElement;
+  /** ▲▼ 계획고 편집으로 Y 축을 잡고 있는 중. */
+  editing: () => boolean;
+  /** 세로 창 갱신기 — 그릴 때마다 렌더러가 새로 준다(없으면 null). */
+  fitElevation: () => ElevationWindowResult | null;
+  draw: () => void;
+  /** 마지막으로 그린 본문 크기 — 같으면 크기 바뀜을 무시한다. */
+  lastSize: () => { width: number; height: number };
+  scheduleLightSync: () => void;
+  scheduleDraw: () => void;
+}
+
+/** 듣개를 붙이고 떼는 함수를 돌려준다. */
+export function bindProfileViewport(deps: ProfileViewportDeps): () => void {
+  const { body } = deps;
+  /** 마지막으로 통째로 다시 만든 가로 위치 — 같은 자리면 다시 그리지 않는다. */
+  let settledScrollLeft = 0;
+  let scrollSettleTimer = 0;
+  // 세로 맞춤은 **그리기가 아니라 변환**이다(2026-09-04 사용자 확정) — 스크롤마다 겹 하나의
+  // 변환만 갈아 끼우므로 실시간으로 따라온다. 눈금 간격이 어긋나면 눈금층(요소 20개 안팎)만
+  // 새로 만든다. 그래프를 통째로 다시 만드는 34ms 짜리 재구성은 그래도 안 될 때만 남는다.
+  body.addEventListener("scroll", () => {
+    if (deps.editing()) return;
+    const fitted = deps.fitElevation();
+    window.clearTimeout(scrollSettleTimer);
+    if (!needsFullRedraw(fitted)) return;
+    scrollSettleTimer = window.setTimeout(() => {
+      if (deps.editing() || Math.abs(body.scrollLeft - settledScrollLeft) < 1) return;
+      settledScrollLeft = body.scrollLeft;
+      deps.draw();
+    }, SCROLL_SETTLE_MS);
+  });
+
+  // 종단면도는 가로로 매우 길다. 세로 휠을 가로 스크롤로 돌려 스크롤바를 잡지 않고도
+  // 노선을 훑을 수 있게 한다 (Shift+휠은 브라우저 기본 가로 스크롤이라 그대로 둔다).
+  attachWheelHorizontalScroll(body);
+
+  const resizeObserver = new ResizeObserver(() => {
+    const last = deps.lastSize();
+    if (
+      body.clientWidth <= 0 ||
+      body.clientHeight <= 0 ||
+      (Math.abs(body.clientWidth - last.width) < 1 && Math.abs(body.clientHeight - last.height) < 1)
+    )
+      return;
+    // 끌리는 동안엔 프레임당 경량 높이 동기화만 — 무거운 전체 재구성은 손을 뗀 뒤 한 번.
+    // (150ms 디바운스만 있던 예전 방식은 중간 프레임이 없어 툭툭 끊겼다. 2026-08-05 사용자 보고)
+    deps.scheduleLightSync();
+    deps.scheduleDraw();
+  });
+  resizeObserver.observe(body);
+  return () => resizeObserver.disconnect();
+}
diff --git a/A00_Common/design/design_save.ts b/A00_Common/design/design_save.ts
index 8c8bad1fa..827ffbfe9 100644
--- a/A00_Common/design/design_save.ts
+++ b/A00_Common/design/design_save.ts
@@ -65,11 +65,26 @@ function reportOnly(label: string): (error: unknown) => void {
   };
 }
 
+/** 서버가 버린 계획고 편집 자리(측점 · 관 · 구조물이 없는 자리 · 213-2)를 알린다. */
+export function noticeDroppedEdits(saved: { dropped_edit_chainages?: number[] }): void {
+  const dropped = saved.dropped_edit_chainages ?? [];
+  if (!dropped.length) return;
+  const where = dropped
+    .slice(0, 5)
+    .map((value) => `${value.toFixed(2)}m`)
+    .join(" · ");
+  showToast(
+    `계획고 편집 ${dropped.length}곳을 지웠습니다 — 측점 · 관 · 구조물이 없는 자리: ${where}` +
+      (dropped.length > 5 ? ` 외 ${dropped.length - 5}곳` : ""),
+    "info",
+  );
+}
+
 /** 계획고 초안(가게 하나)을 종단 정본에 쓴다. 없으면 아무 일도 하지 않는다. */
 async function flushAlignmentDraft(projectId: string, routeId: number): Promise<void> {
   const draft = pendingAlignment(routeId);
   if (!draft) return;
-  await saveProfileAlignment(projectId, routeId, draft);
+  noticeDroppedEdits(await saveProfileAlignment(projectId, routeId, draft));
   markAlignmentSaved(routeId);
 }
 
diff --git a/A00_Common/design/design_selection.ts b/A00_Common/design/design_selection.ts
index de688e943..0e16185a5 100644
--- a/A00_Common/design/design_selection.ts
+++ b/A00_Common/design/design_selection.ts
@@ -97,6 +97,9 @@ export function resolveSelection<T extends SelectableStructure>(
   return { pipeChainageM: null, structureId: hit?.structure_id ?? null };
 }
 
+/** 측점 하나 고름(횡단 카드 · 종단 측점선)이 덮어 열어도 되는 군 — 노면공(G군)은 뺌(152-5 · B05 = B06 216-1). */
+export const coversAtStation = (group: string | undefined): boolean => group !== "G";
+
 /* ── 세션 값 + 알림 ─────────────────────────────────────────────────────── */
 
 interface Stored {
diff --git a/A00_Common/design/design_view_profile.ts b/A00_Common/design/design_view_profile.ts
index 4124b09a5..9a1fe7824 100644
--- a/A00_Common/design/design_view_profile.ts
+++ b/A00_Common/design/design_view_profile.ts
@@ -31,7 +31,13 @@ import {
   restoreStructurePick,
   wireStructurePick,
 } from "../../B05_Profile/B05_Profile_UI_Structure_Pick_Session";
-import { NO_SELECTION, nearestWithin, readSelection, selectDesign } from "./design_selection";
+import {
+  coversAtStation,
+  NO_SELECTION,
+  nearestWithin,
+  readSelection,
+  selectDesign,
+} from "./design_selection";
 import type { DesignPageHost } from "./design_page";
 import {
   bindDesignView,
@@ -223,6 +229,11 @@ export async function mountProfileView(
     selectMarker: (id) => viewer.markers.selectStation(id),
     selectGraph: (id, chainageM) => selectGraphAt(id, chainageM ?? null),
     selectSidebar: (chainageM) => panel.structures.selectPipeByChainage(chainageM),
+    // 측점선 · 3D 띠 고름 = 횡단 카드 고름(B06 showAtChainage)과 같은 규칙 · 같은 함수(216-1)
+    openAtStation: (chainageM) =>
+      panel.structures.selectAt({ chainageM, structureId: null }, (entry) =>
+        coversAtStation(bridge.typeGroup(entry.type_id)),
+      ),
     selectBasin: (chainageM) => profilePanel.drainage.selectBasinByChainage(chainageM),
     selectPipeForm: (chainageM) => profilePanel.drainage.selectPipeAtChainage(chainageM),
     markStation: (chainageM) => profilePanel.drainage.markStation(chainageM),
diff --git a/A00_Common/key_shortcut.ts b/A00_Common/key_shortcut.ts
new file mode 100644
index 000000000..3957f90f7
--- /dev/null
+++ b/A00_Common/key_shortcut.ts
@@ -0,0 +1,49 @@
+/* =============================================================================
+ * key_shortcut.ts — Ctrl(⌘)+글자 단축키 판정 공용(PLAN 214-2)
+ * 한글 자판은 `key` 가 「ㅋ」·「ㅛ」로 와 글자로는 안 맞음 — 영문 글자·숫자면 그 글자 ·
+ * 아니면 자판 자리(`code`: KeyZ · Digit1)로 판정. Shift 의 대문자도 소문자로 맞춤.
+ * 쓰는 곳 — 페이지(B05 · M02 · 시트 키) + CAD(`B07_DesignDetail/openwebcad` 의 `input-shortcut.ts` 가 다시 내보냄).
+ * 시험 = `resources/tester/cad/ctrl-shortcut-hangul.test.ts`
+ * ========================================================================== */
+
+type KeyLike = Pick<KeyboardEvent, "code"> & Partial<Pick<KeyboardEvent, "key">>;
+
+/** 누른 글자·숫자(소문자) — 글자·숫자 자리가 아니면 빈 글 */
+export function keyLetter(evt: KeyLike): string {
+  const key = evt.key ?? "";
+  if (/^[a-zA-Z0-9]$/.test(key)) return key.toLowerCase();
+  const m = /^(?:Key([A-Z])|Digit([0-9]))$/.exec(evt.code ?? "");
+  return m ? (m[1] ?? m[2]).toLowerCase() : "";
+}
+
+/** Ctrl(Mac ⌘)과 함께 누른 `letter`(소문자 글자·숫자)인가 — Shift · Alt 는 보지 않음 */
+export function isCtrlKey(
+  evt: KeyLike & Pick<KeyboardEvent, "ctrlKey" | "metaKey">,
+  letter: string,
+): boolean {
+  return (evt.ctrlKey || evt.metaKey) && keyLetter(evt) === letter;
+}
+
+/** Ctrl 단축키 이름 */
+export type CtrlShortcut = "undo" | "redo" | "save" | "selectAll";
+
+/** 공용 Ctrl 단축키 — Z · Shift+Z · Y · S · A (Alt 함께는 아님 · Shift 는 Z 만) */
+export function ctrlShortcut(
+  evt: KeyLike &
+    Pick<KeyboardEvent, "ctrlKey" | "altKey" | "shiftKey"> &
+    Partial<Pick<KeyboardEvent, "metaKey">>,
+): CtrlShortcut | null {
+  if (!(evt.ctrlKey || evt.metaKey) || evt.altKey) return null;
+  switch (keyLetter(evt)) {
+    case "z":
+      return evt.shiftKey ? "redo" : "undo";
+    case "y":
+      return evt.shiftKey ? null : "redo";
+    case "s":
+      return evt.shiftKey ? null : "save";
+    case "a":
+      return evt.shiftKey ? null : "selectAll";
+    default:
+      return null;
+  }
+}
diff --git a/A00_Common/main.ts b/A00_Common/main.ts
index 2d94e6e8b..1d3e8b069 100644
--- a/A00_Common/main.ts
+++ b/A00_Common/main.ts
@@ -12,6 +12,7 @@ import "./random_uuid_polyfill";
 import "@ui/ui_template_theme.css";
 import { injectBaseStyles } from "@ui/ui_template_elements";
 import { blockNativeMenu, NATIVE_MENU_ROUTE } from "@ui/ui_template_native_menu";
+import { initLoupe, LOUPE_ROUTE } from "@ui/ui_template_loupe";
 import { ROUTES, type RoutePath } from "@config/config_frontend";
 import { initThemeAndLang, injectShellStyles, renderShell } from "./app_shell";
 import {
@@ -54,6 +55,8 @@ function bootstrap(): void {
 
   // B · M 페이지는 브라우저 기본 오른쪽 클릭 메뉴를 막음 — 우리 메뉴는 그대로(계획서 39-9a)
   blockNativeMenu(window, () => NATIVE_MENU_ROUTE.test(currentRoute()));
+  // B05~B09 돋보기 — 오른쪽 길게 누름 · Z 누름 동안(계획서 218-1)
+  initLoupe(window, () => LOUPE_ROUTE.test(currentRoute()));
 
   // 3. 셸 렌더 + 현재 라우트 렌더를 함께 수행하는 헬퍼
   let shown = "";
diff --git a/A00_Common/spreadsheet/spreadsheet_keys.ts b/A00_Common/spreadsheet/spreadsheet_keys.ts
index 829e128f6..8c6d1fb38 100644
--- a/A00_Common/spreadsheet/spreadsheet_keys.ts
+++ b/A00_Common/spreadsheet/spreadsheet_keys.ts
@@ -10,6 +10,7 @@
  * 복사 · 붙여넣기(Ctrl+C/X/V)는 막지 않음 — E 클립보드가 copy · paste 사건으로 받음.
  * ========================================================================== */
 
+import { keyLetter } from "../key_shortcut";
 import { cycleAbs } from "./spreadsheet_editor";
 import { fillCells } from "./spreadsheet_fill";
 import {
@@ -127,7 +128,7 @@ export function attachKeys(ctx: SpreadsheetContext, ed: Editor, hooks: KeyHooks
       go(move(sheet, sel, arrow[0], arrow[1], { extend: e.shiftKey, jump: ctrl }));
       return true;
     }
-    const k = e.key.length === 1 ? e.key.toLowerCase() : e.key;
+    const k = keyLetter(e) || (e.key.length === 1 ? e.key.toLowerCase() : e.key);
     if (ctrl && !e.altKey) {
       switch (k) {
         case "z":
@@ -233,7 +234,8 @@ export function attachKeys(ctx: SpreadsheetContext, ed: Editor, hooks: KeyHooks
   }
 
   function onKey(e: KeyboardEvent): void {
-    if (e.isComposing || e.keyCode === 229) return; // 한글 조합 중 — 브라우저 몫
+    // 한글 조합 중 — 브라우저 몫 (Ctrl+글자 단축키는 조합 중에도 판정 · 한글 자판 대응 214-2)
+    if ((e.isComposing || e.keyCode === 229) && !((e.ctrlKey || e.metaKey) && keyLetter(e))) return;
     const inBar = e.target === ed.formula;
     const done = ed.editing() ? editingKey(e, inBar) : !inBar && navKey(e);
     if (done) {
diff --git a/B04_PreProcess/B04_PreProcess_Router_Basins.py b/B04_PreProcess/B04_PreProcess_Router_Basins.py
index 20429f91a..bbbb4973c 100644
--- a/B04_PreProcess/B04_PreProcess_Router_Basins.py
+++ b/B04_PreProcess/B04_PreProcess_Router_Basins.py
@@ -91,7 +91,7 @@ def _build(
     return detail, carried
 
 
-# 관 보호공 · 유입 집수정 높이 칸 — 새 관 기본 = 관경 + 0.5(139-1)
+# 관 보호공 · 유입 집수정 높이 칸 — 새 관 기본 = 관경 + 0.5(139-1) · 유입 흙막이만 + 0.7(211-1)
 PIPE_HEIGHT_KEYS = ("inlet_revet_height_m", "outlet_revet_height_m", "inlet_basin_height_m")
 
 
@@ -130,7 +130,10 @@ def _apply_new_defaults(
         if diameter_m > 0:
             for key in PIPE_HEIGHT_KEYS:
                 if key in keys:
-                    options.setdefault(key, pipe_wall_min_height_m(diameter_m))
+                    side = (
+                        "inlet" if key == "inlet_revet_height_m" else ""
+                    )  # 유입 흙막이 + 0.7(211-1)
+                    options.setdefault(key, pipe_wall_min_height_m(diameter_m, side))
         if point.facility == "ford_bridge" and "ford_height_m" not in options:
             flow = (flows or {}).get(round(point.chainage_m, 2))
             height = ford_height_m(flow, float(options.get("ford_width_m") or 0))
diff --git a/B05_Profile/B05_Profile_Api_Fetch.ts b/B05_Profile/B05_Profile_Api_Fetch.ts
index bf89201a6..05e7e1310 100644
--- a/B05_Profile/B05_Profile_Api_Fetch.ts
+++ b/B05_Profile/B05_Profile_Api_Fetch.ts
@@ -219,6 +219,8 @@ export interface ProfileAlignmentSaveResponse {
   route_id: number;
   profile_alignment: unknown;
   grade_summary: RouteGradeSummary | null;
+  /** 측점 · 관 · 구조물 자리가 없어 서버가 버린 계획고 편집 자리(m · 213-2). */
+  dropped_edit_chainages?: number[];
 }
 
 /**
diff --git a/B05_Profile/B05_Profile_Engine_Grade_Alignment.py b/B05_Profile/B05_Profile_Engine_Grade_Alignment.py
index 254b252d8..d5e0f1223 100644
--- a/B05_Profile/B05_Profile_Engine_Grade_Alignment.py
+++ b/B05_Profile/B05_Profile_Engine_Grade_Alignment.py
@@ -158,6 +158,86 @@ def tangent_elevation(pvi_s: np.ndarray, pvi_z: np.ndarray, targets: np.ndarray)
     return np.interp(targets, pvi_s, pvi_z)
 
 
+#: 반올림만 다른 같은 측점(m) — 관 측점 0.001m(자동설계) ↔ 0.01m(화면 저장) 차이.
+#: 화면 `SAME_STATION_SNAP_M`(B05_Profile_UI_Profile_Alignment.ts) 와 짝.
+SAME_STATION_SNAP_M = 0.006
+
+
+def _nearest_station(value: float, station_s: np.ndarray) -> float | None:
+    if not station_s.size:
+        return None
+    near = float(station_s[int(np.argmin(np.abs(station_s - value)))])
+    return near if abs(near - value) < SAME_STATION_SNAP_M else None
+
+
+def snap_to_stations(
+    base_s: np.ndarray,
+    base_z: np.ndarray,
+    edits: dict[str, dict[str, float]],
+    station_s: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray, dict[str, dict[str, float]]]:
+    """측점 0.006m 안의 꼭짓점(base_pvi) · 편집 키를 그 측점으로 모은다(213-1).
+
+    관 측점이 반올림으로 옮겨도(263.206 → 263.21) 꼭짓점 · 편집 키는 옛 글자로 남아, 새 측점
+    편집과 0.004m 사이 두 꼭짓점이 됨(−15000% 계단 · 숨은 측점). 겹치면 측점 위 것이 이김.
+    옮긴 꼭짓점은 옛 선의 측점 높이를 받아 측점 계획고가 안 바뀜. 양 끝 · 측점에서 먼 키는 그대로.
+    """
+    last = len(base_s) - 1
+    nodes: dict[float, tuple[float, float, float]] = {}
+    for index, (s, z) in enumerate(zip(base_s.tolist(), base_z.tolist())):
+        near = None if index in (0, last) else _nearest_station(s, station_s)
+        at = s if near is None else near
+        gap = 0.0 if near is None else abs(near - s)
+        slot = round(at, _KEY_DECIMALS)
+        if slot not in nodes or gap < nodes[slot][0]:
+            # 옮긴 꼭짓점 높이 = 옛 선의 그 측점 높이 — 측점 계획고가 그대로
+            nodes[slot] = (gap, at, z if near is None else float(np.interp(at, base_s, base_z)))
+    ordered = [nodes[slot] for slot in sorted(nodes)]
+    snapped: dict[str, dict[str, float]] = {}
+    for name, values in edits.items():
+        best: dict[str, tuple[float, float]] = {}
+        for key, value in values.items():
+            try:
+                chainage = float(key)
+            except (TypeError, ValueError):
+                chainage = float("nan")
+            near = _nearest_station(chainage, station_s) if np.isfinite(chainage) else None
+            target = key if near is None else chainage_key(near)
+            gap = 0.0 if near is None else abs(near - chainage)
+            if target not in best or gap < best[target][0]:
+                best[target] = (gap, value)
+        snapped[name] = {key: value for key, (_, value) in best.items()}
+    return (
+        np.array([item[1] for item in ordered], dtype=np.float64),
+        np.array([item[2] for item in ordered], dtype=np.float64),
+        snapped,
+    )
+
+
+def drop_unplaced_edits(
+    edits: dict[str, dict[str, float]], places: np.ndarray
+) -> tuple[dict[str, dict[str, float]], list[float]]:
+    """측점 · 관 · 구조물 자리(`places`) 0.006m 안에 없는 편집 키를 버린다(213-2).
+
+    옮긴 관의 옛 자리 · 지운 시설 자리에 남은 키는 측점선 없는 꼭짓점(유령)이 된다 — 세션 초안이
+    옛 키를 다시 보내도 [저장]에서 걸러진다. (남은 편집, 버린 자리 누가거리).
+    """
+    kept: dict[str, dict[str, float]] = {}
+    dropped: set[float] = set()
+    for name, values in edits.items():
+        kept[name] = {}
+        for key, value in values.items():
+            try:
+                chainage = float(key)
+            except (TypeError, ValueError):
+                continue
+            if places.size and float(np.min(np.abs(places - chainage))) < SAME_STATION_SNAP_M:
+                kept[name][key] = value
+            else:
+                dropped.add(round(chainage, _KEY_DECIMALS))
+    return kept, sorted(dropped)
+
+
 def resolve_pvi(
     base_s: np.ndarray,
     base_z: np.ndarray,
@@ -407,6 +487,22 @@ def build_alignment(
         if value is not None
     }
 
+    station_s = np.array(
+        sorted(
+            float(station["chainage_m"])
+            for station in stations
+            if isinstance(station.get("chainage_m"), (int, float))
+        ),
+        dtype=np.float64,
+    )
+    base_s, base_z, snapped = snap_to_stations(
+        base_s,
+        base_z,
+        {"station_offsets": station_offsets, "curve_radii": curve_radii},
+        station_s,
+    )
+    station_offsets, curve_radii = snapped["station_offsets"], snapped["curve_radii"]
+
     pvi_s, pvi_z, sources = resolve_pvi(base_s, base_z, station_offsets)
     curves, warnings = build_curves(
         pvi_s, pvi_z, policy, curve_radii, only_explicit=only_explicit_curves
diff --git a/B05_Profile/B05_Profile_Router.py b/B05_Profile/B05_Profile_Router.py
index 3f0a47c96..1f0576dca 100644
--- a/B05_Profile/B05_Profile_Router.py
+++ b/B05_Profile/B05_Profile_Router.py
@@ -8,6 +8,7 @@ from typing import Any
 from uuid import UUID
 
 import aiomysql
+import numpy as np
 from fastapi import APIRouter
 from fastapi.responses import JSONResponse
 
@@ -15,6 +16,7 @@ from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_
 from B05_Profile.B05_Profile_Debug import log_b05_debug
 from B05_Profile.B05_Profile_Engine import run_route_design
 from B05_Profile.B05_Profile_Engine_Grade import GradeDesignOptions, resolve_grade_options
+from B05_Profile.B05_Profile_Engine_Grade_Alignment import drop_unplaced_edits
 from B05_Profile.B05_Profile_Engine_Grade_Profile import rebuild_alignment_profile
 from B05_Profile.B05_Profile_Engine_Sections import run_section_generation
 from B05_Profile.B05_Profile_Engine_Sections_Core import SectionGenerationOptions
@@ -384,13 +386,30 @@ async def update_contour_interval(
         )
 
 
+def _structure_marks(project_root: Path, route_data_path: str) -> list[float]:
+    """관 · 구조물 자리(m) — 관 지점 전부 + 구조물 측점 자리(시작 · 기준 · 종료)."""
+    from B05_Profile.B05_Profile_Engine_Sections import (
+        _load_pipe_points,
+        _load_route_polyline,
+        resolve_extra_stations,
+    )
+
+    pipes = _load_pipe_points(project_root, _load_route_polyline(project_root, route_data_path))
+    extras = resolve_extra_stations(project_root, pipes)
+    return [float(pipe.chainage_m) for pipe in pipes] + [float(mark) for mark, _ in extras]
+
+
 def _apply_alignment_edits(
-    project_root: Path, longitudinal_file_path: str, edits: dict[str, Any]
-) -> tuple[dict[str, Any], dict[str, Any]]:
-    """저장된 종단 JSON에 계획선 편집을 반영해 정본을 다시 쓰고 (선형, 요약)을 반환한다.
+    project_root: Path,
+    longitudinal_file_path: str,
+    edits: dict[str, Any],
+    marks: list[float] | None = None,
+) -> tuple[dict[str, Any], dict[str, Any], list[float]]:
+    """저장된 종단 JSON에 계획선 편집을 반영해 정본을 다시 쓰고 (선형, 요약, 버린 자리)를 반환한다.
 
     화면이 즉시 계산해 보여준 값과 같은 기하식을 서버에서도 다시 적용해, 파일에
-    남는 정본이 항상 한 곳(백엔드)에서 만들어지게 한다.
+    남는 정본이 항상 한 곳(백엔드)에서 만들어지게 한다. `marks`(관 · 구조물 자리)를 주면
+    측점 · 관 · 구조물 어디에도 없는 편집 키를 버린다(213-2 — 저장 차례가 관 · 구조물 뒤라 최신).
     """
     root = project_root.resolve()
     path = (root / longitudinal_file_path).resolve()
@@ -399,6 +418,16 @@ def _apply_alignment_edits(
     if not path.is_file():
         raise FileNotFoundError("종단 데이터 파일을 찾을 수 없습니다.")
     longitudinal = json.loads(path.read_text(encoding="utf-8"))
+    dropped: list[float] = []
+    if marks is not None:
+        stations = [float(s.get("chainage_m", 0.0)) for s in longitudinal.get("stations") or []]
+        edits, dropped = drop_unplaced_edits(
+            {
+                "station_offsets": dict(edits.get("station_offsets") or {}),
+                "curve_radii": dict(edits.get("curve_radii") or {}),
+            },
+            np.array(stations + marks, dtype=np.float64),
+        )
     alignment, profile = rebuild_alignment_profile(longitudinal, edits)
     longitudinal["profile_alignment"] = alignment
     profiles = longitudinal.get("design_profiles")
@@ -407,7 +436,7 @@ def _apply_alignment_edits(
     else:
         longitudinal["design_profiles"] = [profile]
     atomic_write_json(path, longitudinal)
-    return alignment, {"id": profile["id"], **profile["summary"]}
+    return alignment, {"id": profile["id"], **profile["summary"]}, dropped
 
 
 @router.put("/{project_id}/route/profile-alignment", response_model=ProfileAlignmentSaveResponse)
@@ -426,11 +455,18 @@ async def save_profile_alignment(
                 )
             stored_path = await get_project_storage_relative_path(connection, project_id)
             project_root = Path(resolve_stored_project_path(stored_path))
-            alignment, grade_summary = await asyncio.to_thread(
+            route = await get_latest_route(connection, project_id)
+            marks = None
+            if route and route["id"] == request.route_id and route.get("route_data_path"):
+                marks = await asyncio.to_thread(
+                    _structure_marks, project_root, str(route["route_data_path"])
+                )
+            alignment, grade_summary, dropped = await asyncio.to_thread(
                 _apply_alignment_edits,
                 project_root,
                 str(longitudinal["longitudinal_file_path"]),
                 request.edits(),
+                marks,
             )
             await connection.begin()
             try:
@@ -446,6 +482,7 @@ async def save_profile_alignment(
             route_id=request.route_id,
             profile_alignment=alignment,
             grade_summary=grade_summary,
+            dropped_edit_chainages=dropped,
         )
     except FileNotFoundError as exc:
         return JSONResponse(status_code=404, content={"status": "error", "message": str(exc)})
diff --git a/B05_Profile/B05_Profile_Router_Confirm.py b/B05_Profile/B05_Profile_Router_Confirm.py
index c21c05004..8e5117630 100644
--- a/B05_Profile/B05_Profile_Router_Confirm.py
+++ b/B05_Profile/B05_Profile_Router_Confirm.py
@@ -214,27 +214,41 @@ def _follow_moved_stations(data: dict[str, Any], before: list[float]) -> dict[st
             None,
         )
         moves[chainage_key(old)] = None if near is None else chainage_key(near)
+
+    def moved(value: float) -> tuple[bool, str | None]:
+        """옛 측점 0.006m 안이면 (참, 옮길 키 · 지우면 None) — 옛 글자(263.206)도 같은 측점(213-1).
+        남은 측점 위 값은 그대로."""
+        if chainage_key(value) in after_keys:
+            return False, None
+        for old_key, new_key in moves.items():
+            if abs(float(old_key) - value) < _SAME_STATION_M:
+                return True, new_key
+        return False, None
+
     edits = stored.get("edits") or {}
     next_edits: dict[str, dict[str, Any]] = {}
     changed = False
     for name in ("station_offsets", "curve_radii"):
         values = dict(edits.get(name) or {})
-        for old_key, new_key in moves.items():
-            if old_key in values:
-                value = values.pop(old_key)
-                if new_key is not None:
-                    values.setdefault(new_key, value)
-                changed = True
+        # 옛 측점 글자 그대로인 키가 먼저 — 반올림 글자보다 이김
+        for key in sorted(values, key=lambda item: item not in moves):
+            hit, new_key = moved(float(key))
+            if not hit:
+                continue
+            value = values.pop(key)
+            if new_key is not None:
+                values.setdefault(new_key, value)
+            changed = True
         next_edits[name] = values
     base: list[dict[str, Any]] = []
     for node in stored["base_pvi"]:
-        key = chainage_key(node["chainage_m"])
-        if key not in moves:
+        hit, new_key = moved(float(node["chainage_m"]))
+        if not hit:
             base.append(node)
             continue
         changed = True
-        if moves[key] is not None:
-            base.append({**node, "chainage_m": float(moves[key])})
+        if new_key is not None:
+            base.append({**node, "chainage_m": float(new_key)})
     if not changed:
         return None
     stored["base_pvi"] = base
diff --git a/B05_Profile/B05_Profile_Router_RouteInitial.py b/B05_Profile/B05_Profile_Router_RouteInitial.py
index 9540d6bfc..88e90e6b1 100644
--- a/B05_Profile/B05_Profile_Router_RouteInitial.py
+++ b/B05_Profile/B05_Profile_Router_RouteInitial.py
@@ -173,7 +173,9 @@ async def apply_profile_target(
         root = Path(resolve_stored_project_path(stored_path))
         relative = str(row["longitudinal_file_path"])
         count = await asyncio.to_thread(_set_base_pvi, root / relative, *target)
-        _alignment, summary = await asyncio.to_thread(_apply_alignment_edits, root, relative, {})
+        _alignment, summary, _dropped = await asyncio.to_thread(
+            _apply_alignment_edits, root, relative, {}
+        )
         async with pool.acquire() as connection:
             await connection.begin()
             await update_longitudinal_grade_summary(
diff --git a/B05_Profile/B05_Profile_Schema.py b/B05_Profile/B05_Profile_Schema.py
index e6407c988..804107d7f 100644
--- a/B05_Profile/B05_Profile_Schema.py
+++ b/B05_Profile/B05_Profile_Schema.py
@@ -225,6 +225,8 @@ class ProfileAlignmentSaveResponse(BaseModel):
     route_id: int
     profile_alignment: dict[str, Any]
     grade_summary: dict[str, Any] | None = None
+    #: 측점 · 관 · 구조물 자리가 없어 버린 계획고 편집 자리(m) — 화면이 알림으로 보임(213-2)
+    dropped_edit_chainages: list[float] = Field(default_factory=list)
 
 
 class RouteSolveResponse(BaseModel):
diff --git a/B05_Profile/B05_Profile_UI_Page_Structures.ts b/B05_Profile/B05_Profile_UI_Page_Structures.ts
index c52541f09..8518459e2 100644
--- a/B05_Profile/B05_Profile_UI_Page_Structures.ts
+++ b/B05_Profile/B05_Profile_UI_Page_Structures.ts
@@ -32,6 +32,7 @@ import {
 import type { createRoutePanel } from "./B05_Profile_UI_Panel";
 import type { createRouteProfilePanel } from "./B05_Profile_UI_Profile_Panel";
 import { FACILITY_NAMES } from "./B05_Profile_UI_Page_Helpers";
+import { followedStation } from "./B05_Profile_UI_Profile_Alignment";
 
 /** 관 지점 한 건 — 유효직경·시설 종류·부속 옵션까지 그대로 받는다. */
 export interface PipeProjection {
@@ -103,20 +104,19 @@ export function createStructuresBridge(deps: StructuresBridgeDeps) {
 
   /** 비정규 측점 목록 변경 → 3D·그래프·테이블에 반영(프론트 프리뷰, 백엔드 미전송). */
   function applyIrregularStations(stations: IrregularStation[]): void {
-    // 위치가 바뀌거나 삭제된 비정규 측점의 옛 chainage에 남은 계획고 편집(유령 변화점)을 지운다.
-    // 서버가 관 측점을 0.01m 로 반올림해 돌려주므로 0.005m 안의 새 측점은 같은 측점 — 편집을 옮김.
+    // 위치가 바뀌거나 삭제된 비정규 측점의 옛 chainage에 남은 계획고 편집(유령 변화점)을 옮기거나 지운다.
+    // 옮김 = 0.006m 안 새 측점(서버 0.01m 반올림) · 같은 id · 사라진 것 하나와 새것 하나(옮긴 관 · 213-2)
+    // — 세션 초안도 새 키로 바뀌어 옛 키가 다시 안 나감. 나머지는 지움.
     const nextKeys = new Set(stations.map((station) => station.chainage_m.toFixed(3)));
     const oldKeys = new Set(irregularStations.map((station) => station.chainage_m.toFixed(3)));
-    irregularStations
-      .filter((station) => !nextKeys.has(station.chainage_m.toFixed(3)))
-      .forEach((station) => {
-        const same = stations.find(
-          (next) =>
-            Math.abs(next.chainage_m - station.chainage_m) < 0.006 &&
-            !oldKeys.has(next.chainage_m.toFixed(3)),
-        );
-        deps.profilePanel().resetStationEdit(station.chainage_m, same?.chainage_m);
-      });
+    const gone = irregularStations.filter(
+      (station) => !nextKeys.has(station.chainage_m.toFixed(3)),
+    );
+    const born = stations.filter((station) => !oldKeys.has(station.chainage_m.toFixed(3)));
+    gone.forEach((station) => {
+      const same = followedStation(station, gone, born);
+      deps.profilePanel().resetStationEdit(station.chainage_m, same?.chainage_m);
+    });
     irregularStations = stations;
     deps.renderStationLines();
     deps.profilePanel().setIrregularStations(withoutFordPavement(stations));
@@ -361,6 +361,8 @@ export function createStructuresBridge(deps: StructuresBridgeDeps) {
     },
     /** 그래프·3D가 쓰는 현재 비정규 측점 목록(물넘이포장 제외 — 알약 레인 몫). */
     irregularStations: () => withoutFordPavement(irregularStations),
+    /** 구조물 종류의 군(A~G · 모르면 undefined) — 측점 고름이 덮어 열 구조물을 가름(216-1). */
+    typeGroup: (typeId: string) => structureTypeMap.get(typeId)?.group,
     /** 관 지점 목록이 바뀜 — 측점 투영과 알약 레인을 한 번에 맞춘다. */
     setPipes(pipes: PipeProjection[]): void {
       pipeStations = pipesToStations(pipes);
diff --git a/B05_Profile/B05_Profile_UI_Profile_Alignment.ts b/B05_Profile/B05_Profile_UI_Profile_Alignment.ts
index 1a6c62b19..1346067ba 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Alignment.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Alignment.ts
@@ -182,6 +182,81 @@ export function toAlignmentBase(alignment: ProfileAlignment): AlignmentBase {
   };
 }
 
+/**
+ * 사라진 비정규 측점의 편집이 따라갈 새 측점(213-2) — 0.006m 안(반올림) · 같은 id · 사라진 것 하나와
+ * 새것 하나(옮긴 관)면 그것. 없으면 null(편집을 지움).
+ */
+export function followedStation<T extends { id: string; chainage_m: number }>(
+  station: T,
+  gone: ReadonlyArray<T>,
+  born: ReadonlyArray<T>,
+): T | null {
+  return (
+    born.find((next) => Math.abs(next.chainage_m - station.chainage_m) < 0.006) ??
+    born.find((next) => next.id === station.id) ??
+    (gone.length === 1 && born.length === 1 ? born[0] : null)
+  );
+}
+
+/** 반올림만 다른 같은 측점(m) — 서버 `SAME_STATION_SNAP_M`(B05_Profile_Engine_Grade_Alignment.py) 와 짝. */
+const SAME_STATION_SNAP_M = 0.006;
+
+function nearestStation(value: number, stationS: number[]): number | null {
+  let near: number | null = null;
+  stationS.forEach((station) => {
+    if (near === null || Math.abs(station - value) < Math.abs(near - value)) near = station;
+  });
+  return near !== null && Math.abs(near - value) < SAME_STATION_SNAP_M ? near : null;
+}
+
+function snapKeys(values: Record<string, number>, stationS: number[]): Record<string, number> {
+  const best = new Map<string, { gap: number; value: number }>();
+  Object.entries(values).forEach(([key, value]) => {
+    const chainage = Number(key);
+    const near = Number.isFinite(chainage) ? nearestStation(chainage, stationS) : null;
+    const target = near === null ? key : chainageKey(near);
+    const gap = near === null ? 0 : Math.abs(near - chainage);
+    const held = best.get(target);
+    if (!held || gap < held.gap) best.set(target, { gap, value });
+  });
+  return Object.fromEntries([...best].map(([key, entry]) => [key, entry.value]));
+}
+
+/**
+ * 측점 0.006m 안의 꼭짓점(base_pvi) · 편집 키를 그 측점으로 모은다(213-1) — 서버
+ * `snap_to_stations` 와 같은 규칙. 관 측점이 반올림으로 옮겨도(263.206 → 263.21) 옛 글자로 남아
+ * 0.004m 사이 두 꼭짓점이 되던 흠. 겹치면 측점 위 것이 이김 · 옮긴 꼭짓점은 옛 선의 측점 높이
+ * (측점 계획고 그대로) · 양 끝 · 측점에서 먼 키는 그대로.
+ */
+function snapToStations(
+  base: AlignmentBase,
+  edits: AlignmentEdits,
+): { basePvi: AlignmentNode[]; edits: AlignmentEdits } {
+  const stationS = base.stations.map((station) => station.chainage_m);
+  const baseS = base.basePvi.map((node) => node.chainage_m);
+  const baseZ = base.basePvi.map((node) => node.elevation_m);
+  const last = base.basePvi.length - 1;
+  const nodes = new Map<number, { gap: number; node: AlignmentNode }>();
+  base.basePvi.forEach((node, index) => {
+    const near = index === 0 || index === last ? null : nearestStation(node.chainage_m, stationS);
+    const at = near ?? node.chainage_m;
+    const gap = near === null ? 0 : Math.abs(near - node.chainage_m);
+    const slot = Number(at.toFixed(3));
+    const held = nodes.get(slot);
+    // 옮긴 꼭짓점 높이 = 옛 선의 그 측점 높이 — 측점 계획고가 그대로
+    const elevation = near === null ? node.elevation_m : interpolate(baseS, baseZ, at);
+    if (!held || gap < held.gap)
+      nodes.set(slot, { gap, node: { chainage_m: at, elevation_m: elevation } });
+  });
+  return {
+    basePvi: [...nodes.keys()].sort((a, b) => a - b).map((slot) => nodes.get(slot)!.node),
+    edits: {
+      station_offsets: snapKeys(edits.station_offsets, stationS),
+      curve_radii: snapKeys(edits.curve_radii, stationS),
+    },
+  };
+}
+
 /** 자동 변화점에 사용자 편집 측점을 합쳐 최종 변화점 집합을 만든다. */
 function resolvePvi(
   base: AlignmentBase,
@@ -316,8 +391,10 @@ function normalizeEdits(edits: AlignmentEdits | undefined): AlignmentEdits {
   };
 }
 
-export function buildAlignment(base: AlignmentBase, input: AlignmentEdits): ProfileAlignment {
-  const edits = normalizeEdits(input);
+export function buildAlignment(raw: AlignmentBase, input: AlignmentEdits): ProfileAlignment {
+  const snapped = snapToStations(raw, normalizeEdits(input));
+  const base: AlignmentBase = { ...raw, basePvi: snapped.basePvi };
+  const edits = snapped.edits;
   const warnings: string[] = [];
   const nodes = resolvePvi(base, edits.station_offsets);
   const pviS = nodes.map((node) => node.chainage_m);
diff --git a/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts b/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts
index d50323666..61b8c5add 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts
@@ -9,6 +9,7 @@
  * 되돌리기 범위가 B05 조작 전부인 이유는 `B05_Profile_UI_Profile_History` 머리말 참조.
  * ========================================================================== */
 
+import { isCtrlKey } from "../A00_Common/key_shortcut";
 import type {
   AlignmentBase,
   AlignmentEdits,
@@ -26,6 +27,9 @@ import {
   tiltStraightRun,
 } from "./B05_Profile_UI_Profile_Straighten";
 import type { IrregularStation } from "./B05_Profile_UI_IrregularStations";
+import { createFreeDraw } from "../A00_Common/design/design_profile_free";
+import { createFreeView, type FreeChartGeom } from "../A00_Common/design/design_profile_free_view";
+import { arrowsBelongToProfile } from "../B06_Section/B06_Section_UI_Cross_Panel_Base";
 
 /** 방향키 한 번에 움직이는 양(m) — 계획고·누가거리 모두 같다(사용자 확정). */
 const KEY_STEP_M = 0.1;
@@ -111,6 +115,18 @@ export function createPanelTools(ctx: PanelToolsContext): PanelTools {
     pause: () => (syncPipes(), inner.pause()),
   };
 
+  // [자유지정] — 적용은 직선화 결과와 같은 길(applyEdits · 이력 · 막기 규칙)(215-1).
+  const free = createFreeDraw({
+    base: ctx.base,
+    alignment: ctx.alignment,
+    edits: ctx.edits,
+    apply: (next) => ctx.applyEdits(next),
+    close: () => tools.clear(),
+    changed: ctx.refresh,
+  });
+  const freeView = createFreeView(free);
+  let lastGeom: FreeChartGeom | null = null;
+
   const tools = createProfileTools({
     onStraighten: (fromM, toM) => {
       const base = ctx.base();
@@ -143,12 +159,19 @@ export function createPanelTools(ctx: PanelToolsContext): PanelTools {
       return alignment ? hasStraightRuns(alignment) : false;
     },
     onChanged: ctx.refresh,
+    onModeChange: (mode) => freeView.mount(lastGeom, mode === "free"),
+    freeHint: () => free.hint(),
+    mountOverlay: (geom) => {
+      lastGeom = geom;
+      freeView.mount(geom, tools.mode() === "free");
+    },
   });
 
   /** 그래프에서 누른 자리를 도구가 먹는다. */
   function handleToolPick(chainageM: number | null): boolean {
     const mode = tools.mode();
     if (mode === "none") return false;
+    if (mode === "free") return true; // 자유지정 클릭은 오버레이가 먼저 먹는다.
     if (chainageM === null) return tools.handleRunPick(null);
     const alignment = ctx.alignment();
     if (mode === "shift") {
@@ -200,6 +223,8 @@ export function createPanelTools(ctx: PanelToolsContext): PanelTools {
       ctx.applyEdits(adjustStation(base, ctx.edits(), chainage, delta));
       return true;
     }
+    // 좌우 이동 = 마지막 누름이 종단도 안일 때만 — 횡단 카드 · 3D 를 누른 뒤 방향키가 관을 몰래 옮겼음(219-1)
+    if (!arrowsBelongToProfile()) return false;
     // 옮기는 동안에는 처음 잡은 측점을 계속 쓴다 — 관 측점 id 가 누가거리로 만들어져
     // (`pipe-85.59`) 한 번 옮기면 선택이 풀리고 두 번째 키부터 먹지 않았다(2026-09-04 실측).
     const station = holdStation ?? selectedIrregular();
@@ -283,7 +308,13 @@ export function createPanelTools(ctx: PanelToolsContext): PanelTools {
     // 입력칸 안에서는 방향키가 값 조작이므로 손대지 않는다.
     if (target && target.closest("input, select, textarea")) return;
     const key = event.key;
-    if ((event.ctrlKey || event.metaKey) && (key === "z" || key === "Z")) {
+    // [자유지정] 중 Enter 끝 · Esc 취소 · Backspace 점 빼기 — 단추 초점의 Enter 누름도 막는다.
+    if (tools.mode() === "free" && free.key(key)) {
+      event.preventDefault();
+      freeView.redraw();
+      return;
+    }
+    if (isCtrlKey(event, "z")) {
       event.preventDefault();
       flushHold();
       if (event.shiftKey) history.redo();
diff --git a/B05_Profile/B05_Profile_UI_Profile_Render.ts b/B05_Profile/B05_Profile_UI_Profile_Render.ts
index b7f45b834..af5042efd 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Render.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Render.ts
@@ -34,7 +34,7 @@ import {
   Y_AXIS_WINDOW_CLASS,
   type ElevationWindowResult,
 } from "@util/common_util_chart_ywindow";
-import type { StraightRun } from "./B05_Profile_UI_Profile_Straighten";
+import type { ProfileTools } from "./B05_Profile_UI_Profile_Tools";
 import type { MinCoverPoint } from "./B05_Profile_UI_Profile_MinCover";
 import { buildStickyYAxis, type RouteMassHaulDrawParams } from "./B05_Profile_UI_Profile_MassHaul";
 import type { ProfileZoomState } from "./B05_Profile_UI_Profile_Zoom";
@@ -106,8 +106,8 @@ export interface ProfileRenderContext {
   ) => { min: number; max: number } | undefined;
   /** 그래프 x → chainage 역변환이 필요한 도구 판정용 — 클릭 지점의 누가거리. */
   toolActive: () => boolean;
-  /** [쉬프트]로 고른 직선 구간 — 그래프에 빨갛게 강조한다(2026-09-03). */
-  selectedRuns: () => StraightRun[];
+  /** [쉬프트]로 고른 직선 구간(빨간 강조) · [자유지정] 오버레이(215-1). */
+  tools: Pick<ProfileTools, "selectedRuns" | "mountOverlay">;
   stationIdAtStructure: (structureId: string | null) => string | null;
   /** 알약을 골랐을 때처럼 그리는 도중 다시 그려야 하는 자리. */
   redraw: () => void;
@@ -368,7 +368,7 @@ export function renderProfile(ctx: ProfileRenderContext): void {
   if (alignment) {
     const highlight = createRunHighlight({
       alignment,
-      runs: ctx.selectedRuns(),
+      runs: ctx.tools.selectedRuns(),
       x,
       axis: yAxis,
       widthPx: width,
@@ -403,6 +403,16 @@ export function renderProfile(ctx: ProfileRenderContext): void {
   canvas.append(chartWrap, structureLane);
   body.replaceChildren(canvas);
   body.scrollLeft = scrollLeft;
+  // [자유지정] — 범위 강조 · 점선 미리 보기 · 클릭 점(215-1). 화면에 붙인 뒤라야 자리를 잰다.
+  ctx.tools.mountOverlay({
+    chart: chartWrap,
+    scroller: body,
+    x,
+    toChainage,
+    widthPx: width,
+    heightPx: chartHeight,
+    stations: graphLongitudinal.stations.map((station) => station.chainage_m),
+  });
   // 테이블은 바닥 고정 오버레이에 담는다 — 폭은 종단 캔버스와 같아 세로선이 맞물린다.
   if (table) table.style.width = `${width}px`;
   tableOverlay.setTable(table);
diff --git a/B05_Profile/B05_Profile_UI_Profile_Straighten.ts b/B05_Profile/B05_Profile_UI_Profile_Straighten.ts
index 5b9279de8..74bc054e7 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Straighten.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Straighten.ts
@@ -46,7 +46,7 @@ function pviChainages(alignment: ProfileAlignment): number[] {
 }
 
 /** 자동 선형(base_pvi) 위에서의 표고 — 편집 델타의 기준값. */
-function baseElevationAt(base: AlignmentBase, chainageM: number): number {
+export function baseElevationAt(base: AlignmentBase, chainageM: number): number {
   const nodes = base.basePvi;
   if (!nodes.length) return 0;
   if (chainageM <= nodes[0].chainage_m) return nodes[0].elevation_m;
@@ -181,7 +181,7 @@ export function straightenBetween(
 }
 
 /** 정책에서 라운드 기본 길이 L(m)을 읽는다 — 옛 저장분은 R 기준으로 되돌아간다. */
-function defaultCurveLength(base: AlignmentBase, deltaGrade: number): number {
+export function defaultCurveLength(base: AlignmentBase, deltaGrade: number): number {
   const length = base.policy.default_curve_length_m;
   if (typeof length === "number" && Number.isFinite(length) && length > 0) return length;
   return base.policy.default_curve_radius_m * Math.abs(deltaGrade);
diff --git a/B05_Profile/B05_Profile_UI_Profile_Tools.ts b/B05_Profile/B05_Profile_UI_Profile_Tools.ts
index fd33a05ff..420d00159 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Tools.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Tools.ts
@@ -11,12 +11,14 @@
  *   [쉬프트] → 직선화된 라인을 고름(여러 개 가능) → [▲][▼]로 통째로 올리고 내림.
  *   직선을 고른 채 [직선화] 모드에서 [▲][▼]를 누르면 그 직선이 꺾이며 가운데에
  *   라운드가 생기고 양쪽이 탄젠트 직선이 된다.
+ *   [자유지정] → 범위를 고르고 클릭으로 계획선을 잇는다(`design_profile_free` 몫 · 215-1).
  * ========================================================================== */
 
 import type { StraightRun } from "./B05_Profile_UI_Profile_Straighten";
 import { sameRun } from "./B05_Profile_UI_Profile_Straighten";
+import type { FreeChartGeom } from "../A00_Common/design/design_profile_free_view";
 
-export type ProfileToolMode = "none" | "straighten" | "shift";
+export type ProfileToolMode = "none" | "straighten" | "shift" | "free";
 
 export interface ProfileToolsCallbacks {
   /** 두 측점을 직선으로 잇는다. */
@@ -36,6 +38,12 @@ export interface ProfileToolsCallbacks {
   hasStraightRuns: () => boolean;
   /** 선택 표시를 갱신해야 할 때(모드·선택 변화) 호출된다. */
   onChanged: () => void;
+  /** 모드가 바뀜 — [자유지정] 오버레이를 붙이고 뗀다. */
+  onModeChange: (mode: ProfileToolMode) => void;
+  /** [자유지정] 단계 안내. */
+  freeHint: () => string;
+  /** 그래프를 새로 그림 — [자유지정] 오버레이를 다시 붙인다. */
+  mountOverlay: (geom: FreeChartGeom) => void;
 }
 
 export interface ProfileTools {
@@ -54,6 +62,8 @@ export interface ProfileTools {
   nudge: (delta: number) => boolean;
   /** 모드·선택을 모두 끈다. */
   clear: () => void;
+  /** 그래프를 새로 그릴 때마다 — [자유지정] 오버레이 자리. */
+  mountOverlay: (geom: FreeChartGeom) => void;
 }
 
 function toolButton(label: string, title: string, onClick: () => void): HTMLButtonElement {
@@ -78,6 +88,7 @@ export function createProfileTools(callbacks: ProfileToolsCallbacks): ProfileToo
     mode = "none";
     pending = null;
     runs = [];
+    callbacks.onModeChange(mode);
   }
 
   function setMode(next: ProfileToolMode): void {
@@ -87,6 +98,7 @@ export function createProfileTools(callbacks: ProfileToolsCallbacks): ProfileToo
       mode = next;
       pending = null;
       runs = [];
+      callbacks.onModeChange(mode);
     }
     callbacks.onChanged();
   }
@@ -106,6 +118,7 @@ export function createProfileTools(callbacks: ProfileToolsCallbacks): ProfileToo
     nudge: step,
     selectedRuns: () => runs,
     pendingStation: () => pending,
+    mountOverlay: callbacks.mountOverlay,
     clear() {
       if (mode === "none" && pending === null && !runs.length) return;
       reset();
@@ -174,15 +187,26 @@ export function createProfileTools(callbacks: ProfileToolsCallbacks): ProfileToo
         () => setMode("shift"),
       );
       shift.classList.toggle("is-active", mode === "shift");
+      const free = toolButton(
+        "자유지정",
+        "범위를 고른 뒤 클릭으로 계획선을 잇습니다 (Enter 끝 · Backspace 점 빼기 · Esc 취소)",
+        () => setMode("free"),
+      );
+      free.classList.toggle("is-active", mode === "free");
 
       const up = toolButton("▲", "고른 직선을 0.1m 올림", () => void step(0.1));
       const down = toolButton("▼", "고른 직선을 0.1m 내림", () => void step(-0.1));
-      const idle = mode === "none" || (!runs.length && mode === "shift");
+      const idle = mode === "none" || mode === "free" || (!runs.length && mode === "shift");
       up.disabled = idle || (mode === "straighten" && runs.length !== 1);
       down.disabled = up.disabled;
 
-      wrap.append(reset, undo, redo, straighten, shift, up, down);
-      if (mode === "straighten" && pending !== null) {
+      wrap.append(reset, undo, redo, straighten, free, shift, up, down);
+      if (mode === "free") {
+        const hint = document.createElement("em");
+        hint.className = "b05-route-profile__tool-hint";
+        hint.textContent = callbacks.freeHint();
+        wrap.append(hint);
+      } else if (mode === "straighten" && pending !== null) {
         const hint = document.createElement("em");
         hint.className = "b05-route-profile__tool-hint";
         hint.textContent = `${pending.toFixed(1)}m 선택 — 두 번째 측점을 고르세요 (취소는 [직선화] 다시 누르기)`;
diff --git a/B05_Profile/B05_Profile_UI_RouteEdit_History.ts b/B05_Profile/B05_Profile_UI_RouteEdit_History.ts
index fda74f078..d55eb6e18 100644
--- a/B05_Profile/B05_Profile_UI_RouteEdit_History.ts
+++ b/B05_Profile/B05_Profile_UI_RouteEdit_History.ts
@@ -10,6 +10,8 @@
  * 쪼개면 되돌릴 때 어긋나기 쉽다. 노선 하나가 노드 수십 개라 사진 몇 벌은 가볍다.
  * ========================================================================== */
 
+import { keyLetter } from "../A00_Common/key_shortcut";
+
 export type Vertex = [number, number];
 
 /** 되돌릴 수 있는 편집 상태 한 벌. */
@@ -154,7 +156,7 @@ export function bindHistoryControls(params: HistoryControlsParams): {
 
   const onKey = (event: KeyboardEvent): void => {
     if (!(event.ctrlKey || event.metaKey)) return;
-    const key = event.key.toLowerCase();
+    const key = keyLetter(event);
     if (key === "z" && !event.shiftKey) step("undo");
     else if (key === "y" || (key === "z" && event.shiftKey)) step("redo");
     else return;
diff --git a/B05_Profile/B05_Profile_UI_Selection.ts b/B05_Profile/B05_Profile_UI_Selection.ts
index cc4f393ed..23efb7f6f 100644
--- a/B05_Profile/B05_Profile_UI_Selection.ts
+++ b/B05_Profile/B05_Profile_UI_Selection.ts
@@ -27,6 +27,9 @@ export interface SelectionSyncPorts {
   selectGraph: (stationId: string | null, chainageM?: number | null) => void;
   /** 좌측 구조물 폼 선택(누가거리 기준). */
   selectSidebar: (chainageM: number | null) => void;
+  /** 측점 하나 고름(측점선 · 3D 띠) → 좌측 폼 — 횡단 카드 고름과 같은 규칙(관 → 덮는 구조물 · 노면공 뺌 →
+   *  없으면 폼 비움 · 216-1). 없으면 selectSidebar. */
+  openAtStation?: (chainageM: number | null) => void;
   /** 배수유역도 세부유역 강조(누가거리 기준). */
   selectBasin: (chainageM: number | null) => void;
   /** 배수유역도 계획선 위 측점 마킹(누가거리 기준). 유역 없는 구조물도 위치를 보여 준다. */
@@ -79,17 +82,18 @@ export function createSelectionSync(ports: SelectionSyncPorts): SelectionSync {
       // 측점선 · 3D 띠 · 표 고름도 고름 한 칸에 — 일반 측점을 안 적어 옛 배관 고름이 이겼음(188-1)
       const at =
         stationId === null ? null : (station?.chainage_m ?? ports.regularChainage?.(stationId));
-      if (at !== undefined) ports.remember?.(at);
-      // 규칙 측점을 고른 것이면 구조물 폼은 건드리지 않는다(고를 항목이 없다).
-      if (stationId !== null && !stationId.startsWith(prefix)) return;
+      if (at === undefined) return; // 모르는 측점 — 폼 · 고름 한 칸 안 건드림
       ports.setSyncing(true);
       try {
-        ports.selectSidebar(station ? station.chainage_m : null);
+        // 일반 측점도 폼이 따라감 — 일반 측점이면 폼을 안 건드려 옛 폼이 남았음(B06 카드 규칙 · 216-1)
+        (ports.openAtStation ?? ports.selectSidebar)(at);
         ports.selectPipeForm?.(station && isPipeStation(station) ? station.chainage_m : null);
         ports.selectStructure3D?.(station ? station.chainage_m : null);
       } finally {
         ports.setSyncing(false);
       }
+      // 폼이 연 구조물 · 푼 관 알림이 적은 고름을 이 측점으로 덮음 — 마지막 고름 하나(188-1)
+      ports.remember?.(at);
     },
     selectStationOfPipe(chainageM) {
       if (ports.isSyncing()) return;
diff --git a/B05_Profile/B05_Profile_UI_Structures_Panel.ts b/B05_Profile/B05_Profile_UI_Structures_Panel.ts
index 6ea28ae39..2b7e97e5e 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Panel.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Panel.ts
@@ -617,8 +617,8 @@ export function createStructuresSection(
       loadPipeForm(pipe);
     },
     resolveAt: (selection) => resolveSelection(selection, pipeFacilities, structures),
-    selectAt(selection) {
-      const hit = resolveSelection(selection, pipeFacilities, structures);
+    selectAt(selection, coverable) {
+      const hit = resolveSelection(selection, pipeFacilities, structures, coverable);
       if (hit.pipeChainageM !== null) this.selectPipeByChainage(hit.pipeChainageM);
       else this.selectById(hit.structureId);
       return hit;
diff --git a/B05_Profile/B05_Profile_UI_Structures_Panel_Types.ts b/B05_Profile/B05_Profile_UI_Structures_Panel_Types.ts
index 7183dc422..589623338 100644
--- a/B05_Profile/B05_Profile_UI_Structures_Panel_Types.ts
+++ b/B05_Profile/B05_Profile_UI_Structures_Panel_Types.ts
@@ -174,8 +174,11 @@ export interface StructuresSection {
   /** 측점 · 구조물 고름 한 값을 폼이 열 항목으로 푼다 — 열지는 않는다(관 계열이 먼저). */
   resolveAt: (selection: DesignSelection) => ResolvedSelection;
   /** 고름 한 값으로 폼을 연다(관 → 구조물 순) — 어느 화면에서 골라도 같은 거리 · 같은 순서다.
-   *  고를 항목이 없으면 폼을 해제한다. 푼 결과를 돌려준다. */
-  selectAt: (selection: DesignSelection) => ResolvedSelection;
+   *  고를 항목이 없으면 폼을 해제한다. 푼 결과를 돌려준다. `coverable` = 덮어 열어도 되는 구조물(측점 고름 · 216-1). */
+  selectAt: (
+    selection: DesignSelection,
+    coverable?: (entry: StructureInstance) => boolean,
+  ) => ResolvedSelection;
   /** 종단 그래프 우클릭으로 타입을 지정해 추가한다. */
   addAt: (chainageM: number, typeId: string) => void;
   /** 종단 그래프에서 마크를 끌어 옮긴다. 옮겼으면 true. */
diff --git a/B05_Profile/B05_Profile_UI_Style_Structures.css b/B05_Profile/B05_Profile_UI_Style_Structures.css
index d8fcc2277..ed8512694 100644
--- a/B05_Profile/B05_Profile_UI_Style_Structures.css
+++ b/B05_Profile/B05_Profile_UI_Style_Structures.css
@@ -569,7 +569,7 @@
 }
 
 /* 상자 안 작은 단추 템플릿(54-41) — 높이 = 숫자 칸 [－][＋](`--b05-control-h`) · 글 · 안 여백도 그 높이에 ·
- * 상자 이름표 [삭제]도 같은 틀(136-3) · 상자 밖 [추가] · [삭제] · [리셋]은 제외 */
+ * 상자 이름표 [삭제]도 같은 틀(136-3) · 상자 밖 [추가] · [삭제] · [리셋]은 아래 205-1 */
 .b05-structure__group-body button:not(.b05-structure__step),
 .b05-structure__group > legend > button {
   box-sizing: border-box;
@@ -580,6 +580,24 @@
   line-height: 1;
 }
 
+/* 「구조물 배치」 맨 아래 [추가] · [삭제] · [리셋] 줄(205-1) — 단추 높이 = 상자 안 작은 단추(`--b05-control-h`) ·
+ * 폼이 길어도 스크롤 영역 아래 끝에 붙어 늘 보임(자리 고정 · 뒤 내용이 비치지 않게 불투명 배경) */
+.b05-structure-section .b05-route__irregular-actions {
+  position: sticky;
+  bottom: 0;
+  z-index: 1;
+  background: var(--color-surface-raised);
+}
+
+.b05-structure-section .b05-route__irregular-actions > button {
+  box-sizing: border-box;
+  height: var(--b05-control-h);
+  min-height: 0;
+  padding-block: 0;
+  font-size: var(--text-caption);
+  line-height: 1;
+}
+
 /* 노면공 「확폭 구간」 상자(PLAN 87-3) — 구간마다 단추 한 줄 */
 .b05-structure__widening[hidden] {
   display: none;
diff --git a/B05_Profile/B05_Profile_UI_Style_Table.css b/B05_Profile/B05_Profile_UI_Style_Table.css
index 91e5bfd69..6584eb291 100644
--- a/B05_Profile/B05_Profile_UI_Style_Table.css
+++ b/B05_Profile/B05_Profile_UI_Style_Table.css
@@ -334,6 +334,56 @@
   opacity: 0.5;
 }
 
+/* [자유지정] 오버레이 — 범위 띠 · 지나온 점선 · 마우스까지 미리 보기 · 기울기 글(215-1).
+   기준 기울기를 넘는 구간은 빨강. 클릭은 그래프 래퍼가 받으므로 오버레이는 마우스를 통과시킨다. */
+.b05-profile-freemark {
+  position: absolute;
+  z-index: 5;
+  inset: 0;
+  pointer-events: none;
+}
+
+.b05-profile-freemark__band {
+  fill: color-mix(in srgb, var(--color-primary) 10%, transparent);
+}
+
+.b05-profile-freemark__edge {
+  stroke: var(--color-primary);
+  stroke-width: 1.5;
+}
+
+.b05-profile-freemark__line {
+  stroke: var(--color-primary);
+  stroke-width: 2;
+  stroke-dasharray: 6 4;
+}
+
+.b05-profile-freemark__line.is-preview {
+  opacity: 0.7;
+}
+
+.b05-profile-freemark__line.is-over {
+  stroke: var(--color-danger, #d64545);
+}
+
+.b05-profile-freemark__dot {
+  fill: var(--color-surface);
+  stroke: var(--color-primary);
+  stroke-width: 1.5;
+}
+
+.b05-profile-freemark__grade {
+  fill: var(--color-text);
+  font-size: var(--text-caption);
+  paint-order: stroke;
+  stroke: var(--color-surface);
+  stroke-width: 3px;
+}
+
+.b05-profile-freemark__grade.is-over {
+  fill: var(--color-danger, #d64545);
+}
+
 .b05-profile-edit {
   position: absolute;
   z-index: 4;
diff --git a/B06_Section/B06_Section_Api_Types.ts b/B06_Section/B06_Section_Api_Types.ts
index 88f8e135f..7c09a92ed 100644
--- a/B06_Section/B06_Section_Api_Types.ts
+++ b/B06_Section/B06_Section_Api_Types.ts
@@ -633,8 +633,16 @@ export interface CrossSectionPatch {
 export type CrossCellSource =
   | { src: "area"; key: string }
   | { src: "length"; start: [number, number]; end: [number, number] }
+  | { src: "length" | "area"; pieces: CrossPickPiece[] }
   | { src: "text"; text: string };
 
+/** [상세] 고른 선 조각(209-1) — 어느 선 · 두 끝 [offset, 표고](m). */
+export interface CrossPickPiece {
+  line: "design" | "ground" | "spoil" | "structure";
+  start: [number, number];
+  end: [number, number];
+}
+
 /** [상세] 표 손질 — 칸 출처(표 키 →) · 더한 행(`after` 아래 · 없으면 끝) · 더한 열(오른쪽 끝). */
 export interface CrossDetailTable {
   cells: Record<string, CrossCellSource>;
diff --git a/B06_Section/B06_Section_Engine_Culvert.py b/B06_Section/B06_Section_Engine_Culvert.py
index 24ce66c42..4f50a3c08 100644
--- a/B06_Section/B06_Section_Engine_Culvert.py
+++ b/B06_Section/B06_Section_Engine_Culvert.py
@@ -78,19 +78,23 @@ REVET_FACE_SLOPE = 0.3
 #    `test_b06_pipe_wall_height_mirror`.
 REVET_HEIGHT_STEP_M = 0.1  # 높이 눈금
 REVET_EMBED_DEPTH_M = 0.5  # 근입 깊이
+# 관 보호공 **유입** 흙막이 빈 칸 기본 = 관경(올림) + 0.7 — 유출 · 집수정은 근입 0.5 그대로(211-1).
+# ⚠ TS 짝 `common_util_culvert_sets.INLET_REVET_ADD_M` · `_Cross_Culvert_Const.INLET_REVET_ADD_M`.
+INLET_REVET_ADD_M = 0.7
 # 옛 정의 기본 높이(10-6 표 · 관경 무관) — 관경 > 1.0 관에 이 값이면 관 윗면보다 낮은 벽이라
 # 읽을 때 관경 기준 값으로 봄(139-1).
 OLD_PIPE_WALL_DEFAULT_M = 1.5
 
 
-def pipe_wall_min_height_m(diameter_m: float) -> float:
+def pipe_wall_min_height_m(diameter_m: float, side: str = "") -> float:
     """관 벽 **순수 높이**(근입 포함) 기본값 = 관경(0.1m 로 올림) + 근입 0.5 — 벽 윗면 = 관 윗면(139-1).
 
-    관 · 유입 집수정 높이 칸의 새 기본값이자 빈 칸 값.
+    관 · 유입 집수정 높이 칸의 새 기본값이자 빈 칸 값. `side="inlet"`(유입 흙막이) = + 0.7(211-1).
     """
     raw = float(diameter_m)
     steps = math.ceil(raw / REVET_HEIGHT_STEP_M - 1e-9)
-    return round(steps * REVET_HEIGHT_STEP_M + REVET_EMBED_DEPTH_M, 3)
+    add = INLET_REVET_ADD_M if side == "inlet" else REVET_EMBED_DEPTH_M
+    return round(steps * REVET_HEIGHT_STEP_M + add, 3)
 
 
 def pipe_wall_height_m(stored: float | None, diameter_m: float) -> float | None:
@@ -211,10 +215,11 @@ def _side_spec(
         spec["basin_form"] = str(options.get("inlet_structure") or "") or None
         return spec
 
-    # 높이를 안 적었으면 **관경 기준 높이**(관경 + 0.5 · 139-1) · 옛 1.5 도 관경 > 1.0 이면 그 값.
+    # 높이를 안 적었으면 **관경 기준 높이**(관경 + 0.5 · 유입 + 0.7 · 139-1 · 211-1) ·
+    # 옛 1.5 도 관경 > 1.0 이면 관경 + 0.5(저장 값 해석 · 안 바뀜).
     height = pipe_wall_height_m(_number(options.get(f"{side}_revet_height_m"), None), diameter_m)
     if height is None:
-        height = pipe_wall_min_height_m(diameter_m)
+        height = pipe_wall_min_height_m(diameter_m, side)
     length = _number(
         options.get(f"{side}_revet_length_m"),
         None,
diff --git a/B06_Section/B06_Section_Engine_Design_Geometry.py b/B06_Section/B06_Section_Engine_Design_Geometry.py
index 1bc4121df..3249f58da 100644
--- a/B06_Section/B06_Section_Engine_Design_Geometry.py
+++ b/B06_Section/B06_Section_Engine_Design_Geometry.py
@@ -121,7 +121,11 @@ class _SectionGeometry:
         # ⚠ 옛 저장분(`ditch_choice` 가 없던 것)은 `legacy_ditch_enabled` 로 온다. 그 값은
         #   **자동값과 다를 때만 뜻이 있다** — 같으면 자동이 그렇게 냈던 것이고, 다르면
         #   사용자가 일부러 바꾼 것이다. 그래서 **다를 때만** 선택으로 살린다(설계 의도 보존).
-        if section_mode == "both_fill":
+        # ⚠ 양측 성토는 **판정된 역할**로 가른다(206-1) — 입력 `section_mode` 는 옛 저장값일 수
+        #   있다(계획고를 올려 우 절토 → 양측 성토 · 입력은 right_cut 그대로). 입력으로 가르면 옛
+        #   측구 결과가 선택으로 둔갑해 양측 성토 단면에 측구가 섰다. ⚠ TS 짝 `SectionGeometry`.
+        both_fill = self.left_role == "fill" and self.right_role == "fill"
+        if both_fill:
             auto_ditch = False
         elif ground_at is not None:
             ditch_edge = self.left_extent if ditch_side == "left" else -self.right_extent
@@ -136,10 +140,10 @@ class _SectionGeometry:
         #   없는데, 그것을 선택으로 굳히면 **다시 같은 병**(지형이 바뀌어도 안 따라감)이 된다.
         if choice is not None and bool(choice) == auto_ditch:
             choice = None
-        # 양성(both_fill)은 측구가 설 자리가 없다 — 선택보다 기하가 먼저다.
-        self.has_ditch = auto_ditch if (choice is None or section_mode == "both_fill") else choice
+        # 양성(both_fill)은 측구가 설 자리가 없다 — 선택보다 기하가 먼저 · 남은 선택은 비움.
+        self.has_ditch = auto_ditch if (choice is None or both_fill) else choice
         #: 그 측점에 **사용자가 정한 선택**(없으면 자동). 결과와 갈라 내보낸다.
-        self.ditch_choice = choice
+        self.ditch_choice = None if both_fill else choice
 
         # 설계선 쉬프트 = 쪽마다 사면 이동(≥ 0 · 139-6 · 151-2) — 단면유형 · 측구 판정은 **옮기기 전**
         # 노견에서(위) · 노견(폭 고정) · 측구 · 사면이 같이 바깥으로 · 늘어난 폭은 차도.
diff --git a/B06_Section/B06_Section_Router_CrossTable.py b/B06_Section/B06_Section_Router_CrossTable.py
index e13d35579..74d30efed 100644
--- a/B06_Section/B06_Section_Router_CrossTable.py
+++ b/B06_Section/B06_Section_Router_CrossTable.py
@@ -50,7 +50,7 @@ def cross_quantity_sheet(source: dict[str, Any], design: dict[str, Any] | None)
         key: _format(value) if isinstance(value, (int, float)) else "-"
         for key, value in table.items()
     }
-    _values, texts, repick = edited_cells(design)
+    _values, texts, repick = edited_cells(design, source.get("samples"))
     text.update(texts)
     return {
         "quantity_table": table,
diff --git a/B06_Section/B06_Section_Router_Stations.py b/B06_Section/B06_Section_Router_Stations.py
index df1c4eb4e..3c8172d2c 100644
--- a/B06_Section/B06_Section_Router_Stations.py
+++ b/B06_Section/B06_Section_Router_Stations.py
@@ -20,6 +20,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import math
 from pathlib import Path
 from typing import Any
 from uuid import UUID
@@ -28,6 +29,7 @@ from fastapi import APIRouter
 from fastapi.responses import JSONResponse
 
 from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_path
+from B05_Profile.B05_Profile_Engine_Grade_Alignment import SAME_STATION_SNAP_M
 from B05_Profile.B05_Profile_Repository import (
     get_latest_route,
     get_surface_crs_epsg,
@@ -41,10 +43,9 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/api/projects", tags=["B06 Section"])
 
-#: 「그 자리에 측점이 있다」고 볼 거리(m) — 측점 생성의 스냅 폭과 같음
-#: (`B05_Profile_Engine_Sections_Core` · 같은 횡단 이름이 되는 0.005m 안만 한 측점).
+#: 「그 자리에 측점이 있다」고 볼 거리(m) — 같은 측점 폭(213-1 · 반올림 차이 0.006m) 한 벌(219-1).
 #: 넓으면 조금 옮긴 관(769.28 → 769.38)을 「측점 있음」으로 세어 측점이 옛 자리에 남음(192-1).
-STATION_MATCH_TOLERANCE_M = 0.005
+STATION_MATCH_TOLERANCE_M = SAME_STATION_SNAP_M
 
 SNAPSHOT_MISSING = (
     "지표 샘플링 조건을 찾을 수 없어 측점을 만들 수 없음 — 1단계(지표 확정)를 마친 뒤"
@@ -96,9 +97,15 @@ def _missing_marks(project_root: Path, route_data_path: str) -> list[dict[str, A
     if not extras:
         return []
     existing = _station_chainages(project_root)
+    # 노선 밖(0 미만 · 끝 넘음) = 측점을 못 세움 — 판정에서 뺌(219-1 · 길이 모르면 끝은 안 봄)
+    end_m = sum(math.dist(a[:2], b[:2]) for a, b in zip(polyline, polyline[1:]))
     missing = []
     for chainage, label in extras:
         value = float(chainage)
+        if value < -STATION_MATCH_TOLERANCE_M or (
+            end_m > 0 and value > end_m + STATION_MATCH_TOLERANCE_M
+        ):
+            continue
         if any(abs(value - other) <= STATION_MATCH_TOLERANCE_M for other in existing):
             continue
         missing.append({"chainage_m": round(value, 3), "label": label})
diff --git a/B06_Section/B06_Section_Schema.py b/B06_Section/B06_Section_Schema.py
index d0ee0e92c..fae03161c 100644
--- a/B06_Section/B06_Section_Schema.py
+++ b/B06_Section/B06_Section_Schema.py
@@ -135,14 +135,24 @@ class BoxAdjustPatch(BaseModel):
     right: BoxSideAdjustPatch = Field(default_factory=BoxSideAdjustPatch)
 
 
+class CrossPickPiece(BaseModel):
+    """[상세] 고른 선 조각(209-1) — 어느 선 · 두 끝(m · offset, 표고)."""
+
+    line: Literal["design", "ground", "spoil", "structure"]
+    start: list[float] = Field(..., min_length=2, max_length=2)
+    end: list[float] = Field(..., min_length=2, max_length=2)
+
+
 class CrossCellSource(BaseModel):
-    """[상세] 표 칸 출처(179-4) — area = 설계 면적 칸 · length = 두 끝(m · offset, 표고) · text."""
+    """[상세] 표 칸 출처(179-4) — area = 설계 면적 칸 · length = 두 끝(m · offset, 표고) · text ·
+    pieces(209-1) = 고른 선 조각 목록(length = 길이 합 · area = 닫힌 넓이)."""
 
     src: Literal["area", "length", "text"]
     key: str | None = Field(default=None, max_length=40)
     start: list[float] | None = Field(default=None, min_length=2, max_length=2)
     end: list[float] | None = Field(default=None, min_length=2, max_length=2)
     text: str | None = Field(default=None, max_length=200)
+    pieces: list[CrossPickPiece] | None = Field(default=None, min_length=1, max_length=200)
 
 
 class CrossDetailRow(BaseModel):
diff --git a/B06_Section/B06_Section_UI_Cross_Culvert_Const.ts b/B06_Section/B06_Section_UI_Cross_Culvert_Const.ts
index 673bfeaaf..a6ac1bf2b 100644
--- a/B06_Section/B06_Section_UI_Cross_Culvert_Const.ts
+++ b/B06_Section/B06_Section_UI_Cross_Culvert_Const.ts
@@ -71,6 +71,10 @@ export function pipeWallThicknessM(kind: string | null, diameterM: number): numb
  */
 export const REVET_EMBED_DEPTH_M = 0.5;
 
+/** 관 보호공 **유입** 흙막이 빈 칸 기본 순수 높이 = 관경(올림) + 0.7(211-1) — 유출은 근입 0.5 그대로.
+ *  ⚠ 파이썬 짝 `INLET_REVET_ADD_M` · 세트 짝 `common_util_culvert_sets.INLET_REVET_ADD_M`(거울 시험). */
+export const INLET_REVET_ADD_M = 0.7;
+
 /* 기슭막이 높이는 형태와 무관하게 **사용자 입력 그대로** — 형태별 높이 한계·원지반 맞춤
  * 자동 자르기 없음. 형태가 바꾸는 것은 안 무늬뿐. 높이 기준은 **순수 높이**(벽 바닥~상단,
  * 근입 0.5m 포함). 단 하나 — 벽 윗면은 노면 위로 올라오지 않음(`buildRevetWallGeometry`). */
@@ -138,7 +142,7 @@ export function revetWallSpec(
   // 관경 기준 높이는 기본값만 — 하한은 그림이 서는 값뿐(54-51 · 사용자가 고름).
   const preferred = hiddenPipe
     ? (spec.revet_height_m ?? autoHeightM ?? REVET_EMBED_DEPTH_M)
-    : (spec.revet_height_m ?? pipeWallMinPureHeight(diameterM)); // 칸 값 → 그림(139-1)
+    : (spec.revet_height_m ?? pipeWallMinPureHeight(diameterM, spec.role)); // 칸 값 → 그림(139-1)
   const pureHeight = Math.max(adjust.h ?? preferred, WALL_MIN_PURE_HEIGHT_M);
   return {
     form,
@@ -155,10 +159,12 @@ export const PIPE_CONNECT_GRADE = Math.tan((3 * Math.PI) / 180);
 /**
  * 배관 기슭막이 관 하부 여유(m) — 관 invert 아래 벽 바닥까지의 깊이 = 근입 0.5.
  * **순수 높이 기본 = 관경 + 0.5**(땅속 근입 0.5 포함 벽 전체 높이 · 벽 윗면 = 관 윗면 ·
- * 10-6 표 Ø1000 = 1.5 · 139-1). 칸을 비우면 이 값.
+ * 10-6 표 Ø1000 = 1.5 · 139-1 · 유입 흙막이 = 관경 + 0.7 · 211-1). 칸을 비우면 이 값.
  */
-export function pipeWallMinPureHeight(diameterM: number): number {
-  return revetTargetHeight(diameterM) + REVET_EMBED_DEPTH_M;
+export function pipeWallMinPureHeight(diameterM: number, side = ""): number {
+  return (
+    revetTargetHeight(diameterM) + (side === "inlet" ? INLET_REVET_ADD_M : REVET_EMBED_DEPTH_M)
+  );
 }
 /** 벽 순수 높이 하한(m) — 0 이하는 그림이 안 섬. 관경 · 근입 하한 없음(54-51). */
 export const WALL_MIN_PURE_HEIGHT_M = 0.1;
diff --git a/B06_Section/B06_Section_UI_Cross_Design.ts b/B06_Section/B06_Section_UI_Cross_Design.ts
index 7bc478776..0c7e07f68 100644
--- a/B06_Section/B06_Section_UI_Cross_Design.ts
+++ b/B06_Section/B06_Section_UI_Cross_Design.ts
@@ -388,8 +388,10 @@ export function buildDesignControls(
   groundSegment.classList.add("b06-design__seg--header");
   // 단면 유형은 지형에서 자동 판정되며(D-2), 제목행 pill로 표시한다(E-3, Cross_View에서 생성).
   // 아래 옵션은 선행 조건 미충족 시 비활성 = 숨김(179-2 · CSS) — 편측의 쪽은 알약 글에.
-  const rockCut = isRock(state.ground) && state.mode !== "both_fill";
-  const hasDitch = state.mode !== "both_fill";
+  // 숨김은 「막힘 + 그려진 측구 없음」일 때만(206-1) — 측구가 그려져 있으면 단추를 보여 끌 수 있게.
+  const ditchDrawn = design?.ditch_enabled === true;
+  const rockCut = isRock(state.ground) && (state.mode !== "both_fill" || ditchDrawn);
+  const hasDitch = state.mode !== "both_fill" || ditchDrawn;
   // 측구 생성 여부(자동 판정 or 사용자 override) — 측구형식은 측구가 있을 때만 의미 있다.
   // 화면 표시는 **결과**를 보인다 — 선택이 없으면 자동으로 선 결과가 답이다.
   const ditchOn = state.ditchEnabled ?? design?.ditch_enabled ?? true;
diff --git a/B06_Section/B06_Section_UI_Cross_Detail.ts b/B06_Section/B06_Section_UI_Cross_Detail.ts
index 4f52eab17..260405b9b 100644
--- a/B06_Section/B06_Section_UI_Cross_Detail.ts
+++ b/B06_Section/B06_Section_UI_Cross_Detail.ts
@@ -332,6 +332,7 @@ export function openCrossDetail(section: CrossSection): void {
             axes = drawn.axes;
             const handle = attachDetailZoom(clone, axes, zoom, (next) => (zoom = next));
             cad.replaceChildren(clone, ...(handle ? [buildZoomControls(handle)] : []));
+            tablePick.redraw(); // 선 조각 고르기(209-1)
           }
           showPicked();
         },
@@ -367,11 +368,11 @@ export function openCrossDetail(section: CrossSection): void {
         },
         stop: () => {
           resize.disconnect();
-          detachTable();
+          tablePick.detach();
         },
       };
       // 표 손질(179-4) — 우클릭 · 그래프 고르기 · 더한 칸 글 → 세션 초안 → 표 다시 받음
-      const detachTable = attachDetailTable({
+      const tablePick = attachDetailTable({
         tableBox,
         cad,
         section: () => state.section,
diff --git a/B06_Section/B06_Section_UI_Cross_Detail_Geom.ts b/B06_Section/B06_Section_UI_Cross_Detail_Geom.ts
new file mode 100644
index 000000000..f137535dc
--- /dev/null
+++ b/B06_Section/B06_Section_UI_Cross_Detail_Geom.ts
@@ -0,0 +1,227 @@
+/* =============================================================================
+ * B06_Section_UI_Cross_Detail_Geom.ts
+ * [상세] 그래프 고르기 기하(209-1) — 선을 만나는 점에서 조각으로 나눔 · 조각 길 · 길이 · 닫힌 넓이.
+ *
+ * 짝(① 파이썬 · TS) = `B07_DesignDetail/B07_DesignDetail_Engine_Cross_Table_Edit.py`
+ *   (`piece_path` · `sub_path` · `path_length` · `ring_area` · `ground_runs` — [저장] 뒤 정본 셈) ·
+ *   거울 시험 `resources/tester/test_209_1_detail_select.py`.
+ * 나눔(`splitAtCrossings`)은 화면 몫 — 서버는 저장된 조각 두 끝만 검산.
+ * ========================================================================== */
+
+import type { CrossDesign, CrossPickPiece, SectionSample } from "./B06_Section_Api_Types";
+
+export type Pt = [number, number];
+export type LineKind = CrossPickPiece["line"];
+/** 고를 수 있는 조각 — 어느 선 · 그 선 위 꺾은선(m). */
+export interface SplitPiece {
+  line: LineKind;
+  points: Pt[];
+}
+
+/** 서버 `LINE_TOLERANCE_M` 과 같은 값 — 두 끝이 선에서 이만큼 안이면 「선 위」 · 고리 끝 맞음. */
+export const LINE_TOLERANCE_M = 0.05;
+/** 다른 선 끝이 이만큼 안이면 닿음으로 보고 자름(m) — 설계선 표고 0.1 mm 반올림. */
+const TOUCH_M = 0.01;
+/** 이보다 짧은 조각은 버림(m) — 누를 수도 없음. */
+const MIN_PIECE_M = 0.02;
+
+const dist = (a: Pt, b: Pt): number => Math.hypot(a[0] - b[0], a[1] - b[1]);
+
+/* ── 서버 짝(검산 · 값) ─────────────────────────────────────────────────── */
+
+/** 원지반선 — 무효 표고 샘플마다 끊은 꺾은선들(서버 `ground_runs` · 카드 `appendGroundProfile`). */
+export function groundRuns(samples: ReadonlyArray<SectionSample> | undefined): Pt[][] {
+  const runs: Pt[][] = [[]];
+  for (const sample of samples ?? []) {
+    const x = sample.offset_m;
+    const y = sample.elevation_m ?? sample.z;
+    if (sample.valid === false || typeof x !== "number" || typeof y !== "number") runs.push([]);
+    else runs[runs.length - 1].push([x, y]);
+  }
+  return runs.filter((run) => run.length > 1);
+}
+
+const polyline = (raw: ReadonlyArray<{ offset_m: number; elevation_m: number }> | undefined) =>
+  (raw ?? []).map((p): Pt => [p.offset_m, p.elevation_m]).filter((p) => p.every(Number.isFinite));
+
+/** 서버가 아는 선(서버 `pick_lines`) — 고른 조각 위치 검산 대상. */
+export function pickLines(
+  design: CrossDesign | undefined,
+  samples: ReadonlyArray<SectionSample> | undefined,
+): Record<string, Pt[][]> {
+  return {
+    design: [polyline(design?.design_line)],
+    ground: groundRuns(samples),
+    spoil: [polyline(design?.spoil_fill_line)],
+  };
+}
+
+/** 선 위 자리(앞 끝에서 잰 길이 m) — 허용 안 가장 가까운 곳 · 없으면 null. */
+function locate(point: Pt, run: Pt[]): number | null {
+  let best: [number, number] | null = null;
+  let along = 0;
+  for (let i = 0; i + 1 < run.length; i++) {
+    const [ax, ay] = run[i];
+    const [bx, by] = run[i + 1];
+    const dx = bx - ax;
+    const dy = by - ay;
+    const size = Math.hypot(dx, dy);
+    const raw = size === 0 ? 0 : ((point[0] - ax) * dx + (point[1] - ay) * dy) / size ** 2;
+    const t = Math.max(0, Math.min(1, raw));
+    const gap = Math.hypot(point[0] - (ax + t * dx), point[1] - (ay + t * dy));
+    if (gap <= LINE_TOLERANCE_M && (best === null || gap < best[0])) best = [gap, along + t * size];
+    along += size;
+  }
+  return best ? best[1] : null;
+}
+
+function at(run: Pt[], s: number): Pt {
+  for (let i = 0; i + 1 < run.length; i++) {
+    const [ax, ay] = run[i];
+    const [bx, by] = run[i + 1];
+    const size = Math.hypot(bx - ax, by - ay);
+    if (s <= size) {
+      const t = size === 0 ? 0 : s / size;
+      return [ax + t * (bx - ax), ay + t * (by - ay)];
+    }
+    s -= size;
+  }
+  return run[run.length - 1];
+}
+
+/** 선 위 두 자리 사이 꺾은선(s0 → s1 차례) — 사이 꼭짓점 포함(서버 `sub_path`). */
+export function subPath(run: Pt[], s0: number, s1: number): Pt[] {
+  const lo = Math.min(s0, s1);
+  const hi = Math.max(s0, s1);
+  const inner: Pt[] = [];
+  let along = 0;
+  for (let i = 0; i + 1 < run.length; i++) {
+    along += dist(run[i], run[i + 1]);
+    if (lo < along && along < hi) inner.push(run[i + 1]);
+  }
+  const path = [at(run, lo), ...inner, at(run, hi)];
+  return s0 <= s1 ? path : path.reverse();
+}
+
+/** 고른 조각 → 그 선 위 꺾은선 · 두 끝이 선 밖이면 null(구조물 선 = 두 끝 직선 · 검산 없음). */
+export function piecePath(piece: CrossPickPiece, lines: Record<string, Pt[][]>): Pt[] | null {
+  if (piece.line === "structure") return [piece.start, piece.end];
+  for (const run of lines[piece.line] ?? []) {
+    const s0 = locate(piece.start, run);
+    const s1 = locate(piece.end, run);
+    if (s0 !== null && s1 !== null) return subPath(run, s0, s1);
+  }
+  return null;
+}
+
+export const pathLength = (path: Pt[]): number =>
+  path.slice(1).reduce((sum, p, i) => sum + dist(path[i], p), 0);
+
+const near = (a: Pt, b: Pt): boolean => dist(a, b) <= LINE_TOLERANCE_M;
+
+/** 조각 길들을 끝끼리 이어 한 고리가 되면 그 넓이(㎡) · 안 닫힘 · 남는 조각 = null(서버 `ring_area`). */
+export function ringArea(paths: Pt[][]): number | null {
+  if (!paths.length) return null;
+  const ring = [...paths[0]];
+  const rest = paths.slice(1).map((path) => [...path]);
+  while (rest.length) {
+    const tail = ring[ring.length - 1];
+    const index = rest.findIndex((p) => near(p[0], tail) || near(p[p.length - 1], tail));
+    if (index < 0) return null;
+    const [path] = rest.splice(index, 1);
+    ring.push(...(near(path[0], tail) ? path : path.reverse()).slice(1));
+  }
+  if (ring.length < 4 || !near(ring[0], ring[ring.length - 1])) return null;
+  ring.push(ring[0]); // 끝이 허용 안에서만 맞음 — 닫는 변을 꼭 넣음
+  let twice = 0;
+  for (let i = 0; i + 1 < ring.length; i++)
+    twice += ring[i][0] * ring[i + 1][1] - ring[i + 1][0] * ring[i][1];
+  const area = Math.abs(twice) / 2;
+  return area > 1e-9 ? area : null;
+}
+
+/** 고른 조각들 값(서버 `cell_value` 조각 갈래) — 길이 합 · 닫힌 넓이 · 못 셈 = null. */
+export function piecesValue(
+  kind: "length" | "area",
+  pieces: CrossPickPiece[],
+  lines: Record<string, Pt[][]>,
+): number | null {
+  const paths = pieces.map((piece) => piecePath(piece, lines));
+  if (!paths.length || paths.some((path) => path === null)) return null;
+  const valid = paths as Pt[][];
+  return kind === "length" ? valid.reduce((sum, p) => sum + pathLength(p), 0) : ringArea(valid);
+}
+
+/* ── 나눔(화면 몫) ───────────────────────────────────────────────────────── */
+
+const cross = (a: Pt, b: Pt): number => a[0] * b[1] - a[1] * b[0];
+const sub = (a: Pt, b: Pt): Pt => [a[0] - b[0], a[1] - b[1]];
+
+/** 점이 선분 a→b 위 어디(0~1)에 닿나 — `TOUCH_M` 밖이면 null. */
+function touchAt(point: Pt, a: Pt, b: Pt): number | null {
+  const d = sub(b, a);
+  const size2 = d[0] ** 2 + d[1] ** 2;
+  if (size2 === 0) return null;
+  const t = Math.max(0, Math.min(1, ((point[0] - a[0]) * d[0] + (point[1] - a[1]) * d[1]) / size2));
+  return dist(point, [a[0] + t * d[0], a[1] + t * d[1]]) <= TOUCH_M ? t : null;
+}
+
+/**
+ * 선들을 서로 만나는 점(교차 · 다른 선 끝이 닿는 점)에서 조각으로 나눔.
+ * 자르는 자리 = 꺾은선 위치(선분 번호 + 0~1). 같은 선끼리는 안 자름.
+ * ponytail: 겹쳐 나란한 선분(같은 직선 위)은 교점 없음으로 봄 — 끝 닿음만 자름.
+ */
+export function splitAtCrossings(lines: SplitPiece[]): SplitPiece[] {
+  const out: SplitPiece[] = [];
+  lines.forEach((line, li) => {
+    const cuts: number[] = [];
+    const pts = line.points;
+    for (let i = 0; i + 1 < pts.length; i++) {
+      const p = pts[i];
+      const r = sub(pts[i + 1], p);
+      lines.forEach((other, oi) => {
+        if (oi === li) return;
+        const q = other.points;
+        for (let j = 0; j + 1 < q.length; j++) {
+          const s = sub(q[j + 1], q[j]);
+          const denom = cross(r, s);
+          if (Math.abs(denom) > 1e-12) {
+            const t = cross(sub(q[j], p), s) / denom;
+            const u = cross(sub(q[j], p), r) / denom;
+            if (t >= 0 && t <= 1 && u >= 0 && u <= 1) cuts.push(i + t);
+          }
+        }
+        for (const end of [q[0], q[q.length - 1]]) {
+          const t = touchAt(end, p, pts[i + 1]);
+          if (t !== null) cuts.push(i + t);
+        }
+      });
+    }
+    const at = (c: number): Pt => {
+      const i = Math.min(Math.floor(c), pts.length - 2);
+      const t = c - i;
+      return [
+        pts[i][0] + t * (pts[i + 1][0] - pts[i][0]),
+        pts[i][1] + t * (pts[i + 1][1] - pts[i][1]),
+      ];
+    };
+    const marks = [0, ...cuts.sort((a, b) => a - b), pts.length - 1];
+    for (let k = 0; k + 1 < marks.length; k++) {
+      const [c0, c1] = [marks[k], marks[k + 1]];
+      const inner = pts.slice(Math.floor(c0) + 1, Math.ceil(c1));
+      const points = [at(c0), ...inner, at(c1)];
+      if (pathLength(points) >= MIN_PIECE_M) out.push({ line: line.line, points });
+    }
+  });
+  return out;
+}
+
+/** 조각 → 저장 꼴(두 끝 · 0.1 mm 반올림). */
+export function pieceSource(piece: SplitPiece): CrossPickPiece {
+  const round = (p: Pt): Pt => [Math.round(p[0] * 1e4) / 1e4, Math.round(p[1] * 1e4) / 1e4];
+  return {
+    line: piece.line,
+    start: round(piece.points[0]),
+    end: round(piece.points[piece.points.length - 1]),
+  };
+}
diff --git a/B06_Section/B06_Section_UI_Cross_Detail_Select.ts b/B06_Section/B06_Section_UI_Cross_Detail_Select.ts
new file mode 100644
index 000000000..b3e8540ec
--- /dev/null
+++ b/B06_Section/B06_Section_UI_Cross_Detail_Select.ts
@@ -0,0 +1,245 @@
+/* =============================================================================
+ * B06_Section_UI_Cross_Detail_Select.ts
+ * [상세] 그림 선 고르기(209-1) — 설계선 · 구조물 선 · 원지반선 · 사토장선을 만나는 점에서 조각으로
+ * 나눠(`_Cross_Detail_Geom.splitAtCrossings`) 조각마다 투명 판정 선 · 누름 = 하나 고름 ·
+ * Shift/Ctrl+누름 = 더하기/빼기 · 고른 것 값 = [+ − ⤢] 왼쪽 두 줄(카드 179-1 · 195-1 꼴):
+ *   하나 = 길이 · 경사비율 / 수평 · 높이 · 여럿 = 길이 합 / 닫힌 넓이(안 닫히면 「닫히지 않음」).
+ * 칸에 넣기 = 표 우클릭 「그래프에서 고르기」 동안만(`_Cross_Detail_Table` 이 [칸에 넣기] · Enter 로 씀).
+ * ponytail: 그림을 다시 그리면(칸 크기 · 카드 다시 그림) 고름을 지움 — 조각 키 기억은 필요할 때.
+ * ========================================================================== */
+
+import type { CrossDesign, CrossPickPiece } from "./B06_Section_Api_Types";
+import type { CrossAxesOptions } from "./B06_Section_UI_Cross_Axes";
+import { CROSS_PAD } from "./B06_Section_UI_Section_Common";
+import {
+  DESIGN_LINE_ATTR,
+  mergeStraightPieces,
+  pieceLabel,
+} from "./B06_Section_UI_Cross_Design_Pick";
+import {
+  pathLength,
+  pieceSource,
+  ringArea,
+  splitAtCrossings,
+  type Pt,
+  type SplitPiece,
+} from "./B06_Section_UI_Cross_Detail_Geom";
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+export const PIECE_HIT_CLASS = "b06-detail__piece";
+
+/** 화면 px → m(카드 `x` · `toDisplayY` 의 역 · 축 옵션). */
+export function pxToM(axes: CrossAxesOptions): (p: number[]) => Pt {
+  return ([px, py]) => {
+    const display = axes.displayMax - (py - CROSS_PAD.top) / axes.pixelsPerMeter;
+    return [
+      axes.maxOffset - (px - CROSS_PAD.left) / axes.pixelsPerMeter,
+      axes.elevationMid + (display - axes.elevationMid) / axes.exaggeration,
+    ];
+  };
+}
+
+function mToPx(axes: CrossAxesOptions): (p: Pt) => string {
+  return ([offset, elevation]) => {
+    const display = axes.elevationMid + (elevation - axes.elevationMid) * axes.exaggeration;
+    const x = CROSS_PAD.left + (axes.maxOffset - offset) * axes.pixelsPerMeter;
+    const y = CROSS_PAD.top + (axes.displayMax - display) * axes.pixelsPerMeter;
+    return `${x},${y}`;
+  };
+}
+
+function pointsOf(el: Element): number[][] {
+  if (el.tagName.toLowerCase() === "line") {
+    const n = (name: string) => Number(el.getAttribute(name));
+    return [
+      [n("x1"), n("y1")],
+      [n("x2"), n("y2")],
+    ];
+  }
+  return (el.getAttribute("points") ?? "")
+    .trim()
+    .split(/\s+/)
+    .map((pair) => pair.split(",").map(Number))
+    .filter((p) => p.length === 2 && p.every(Number.isFinite));
+}
+
+/** 그림 도형 층 요소 → 고를 조각(m) — 설계 · 구조물 선은 같은 방향 토막을 직선 하나로 합친 뒤 나눔. */
+export function collectPieces(elements: Element[], axes: CrossAxesOptions): SplitPiece[] {
+  const toM = pxToM(axes);
+  const runs: Parameters<typeof mergeStraightPieces>[0] = [];
+  const others: SplitPiece[] = [];
+  for (const el of elements) {
+    const points = pointsOf(el).map(toM);
+    if (points.length < 2) continue;
+    if (el.classList.contains("b06-chart__design-cross"))
+      runs.push({
+        points: points.map(([offset, elevation]) => ({ offset, elevation })),
+        structure: !el.hasAttribute(DESIGN_LINE_ATTR),
+      });
+    else if (el.classList.contains("b06-chart__cross-profile"))
+      others.push({ line: "ground", points });
+    else if (el.classList.contains("b06-chart__spoil-fill")) others.push({ line: "spoil", points });
+  }
+  const straight = mergeStraightPieces(runs).map((piece): SplitPiece => ({
+    line: piece.structure ? "structure" : "design",
+    points: [
+      [piece.from.offset, piece.from.elevation],
+      [piece.to.offset, piece.to.elevation],
+    ],
+  }));
+  return splitAtCrossings([...straight, ...others]);
+}
+
+/** 고름 바꿈 — 더하기(Shift/Ctrl) = 넣고 빼기 · 아니면 그 하나(다시 누르면 비움). */
+export function toggleSelection(selected: number[], index: number, additive: boolean): number[] {
+  if (additive)
+    return selected.includes(index) ? selected.filter((i) => i !== index) : [...selected, index];
+  return selected.length === 1 && selected[0] === index ? [] : [index];
+}
+
+const LINE_NAME: Record<SplitPiece["line"], string> = {
+  design: "설계선",
+  structure: "구조물 선",
+  ground: "원지반선",
+  spoil: "사토장선",
+};
+
+/** 고른 것 값 두 줄 — 하나 = 길이 · 경사비율 / 수평 · 높이(카드 꼴) · 여럿 = 길이 합 / 넓이. */
+export function selectionLabel(design: CrossDesign | undefined, pieces: SplitPiece[]): string {
+  if (!pieces.length) return "";
+  if (pieces.length === 1) {
+    const [piece] = pieces;
+    const from = piece.points[0];
+    const to = piece.points[piece.points.length - 1];
+    if (design && piece.points.length === 2 && piece.line !== "ground" && piece.line !== "spoil")
+      return pieceLabel(design, {
+        from: { offset: from[0], elevation: from[1] },
+        to: { offset: to[0], elevation: to[1] },
+        structure: piece.line === "structure",
+      });
+    return (
+      `${LINE_NAME[piece.line]} 길이 ${pathLength(piece.points).toFixed(2)}m\n` +
+      `수평 ${Math.abs(to[0] - from[0]).toFixed(2)}m · 높이 ${Math.abs(to[1] - from[1]).toFixed(2)}m`
+    );
+  }
+  const total = pieces.reduce((sum, piece) => sum + pathLength(piece.points), 0);
+  const area = ringArea(pieces.map((piece) => piece.points));
+  return (
+    `${pieces.length}개 · 길이 합 ${total.toFixed(2)}m\n` +
+    (area === null ? "면적 닫히지 않음" : `면적 ${area.toFixed(2)}㎡`)
+  );
+}
+
+/** 고른 조각 → 칸 출처(209-1 저장 꼴) — 면적은 닫혀야 · 길이는 하나 이상. */
+export function selectionSource(
+  kind: "area" | "length",
+  pieces: SplitPiece[],
+): { src: "area" | "length"; pieces: CrossPickPiece[] } | null {
+  if (!pieces.length) return null;
+  if (kind === "area" && ringArea(pieces.map((piece) => piece.points)) === null) return null;
+  return { src: kind, pieces: pieces.map(pieceSource) };
+}
+
+/* ── 모달 배선 ─────────────────────────────────────────────────────────── */
+
+export interface DetailSelect {
+  /** 그림을 새로 그린 뒤 — 조각 · 판정 선 · 값 칸 다시(고름 지움). */
+  redraw: () => void;
+  /** 고르기 갈래(표 우클릭) — 있으면 [칸에 넣기] 단추 · 면적이면 누름 = 늘 더하기. */
+  setMode: (kind: "area" | "length" | null) => void;
+  source: (kind: "area" | "length") => ReturnType<typeof selectionSource>;
+  clear: () => void;
+  detach: () => void;
+}
+
+export function attachDetailSelect(input: {
+  cad: HTMLElement;
+  design: () => CrossDesign | undefined;
+  axes: () => CrossAxesOptions | null;
+  /** 조각 누름 뒤(더하기 여부) — 표가 길이 고르기 한 번 누름이면 바로 칸에 넣음. */
+  picked: (additive: boolean) => void;
+  /** [칸에 넣기] 단추. */
+  commit: () => void;
+}): DetailSelect {
+  const { cad } = input;
+  let pieces: SplitPiece[] = [];
+  let hits: SVGPolylineElement[] = [];
+  let selected: number[] = [];
+  let mode: "area" | "length" | null = null;
+
+  const label = document.createElement("span");
+  label.className = "b06-cross-card__line-dims b06-detail__measure";
+  const put = document.createElement("button");
+  put.type = "button";
+  put.className = "b06-cross-card__zoom-btn b06-detail__commit";
+  put.textContent = "칸에 넣기";
+  put.title = "고른 선을 칸에 넣음(Enter)";
+  put.addEventListener("click", (event) => {
+    event.stopPropagation();
+    input.commit();
+  });
+
+  const show = (): void => {
+    const chosen = selected.map((i) => pieces[i]);
+    hits.forEach((hit, i) => hit.classList.toggle("is-selected", selected.includes(i)));
+    label.textContent = selectionLabel(input.design(), chosen);
+    label.hidden = !chosen.length;
+    put.hidden = !mode || !selectionSource(mode, chosen);
+    // [+ − ⤢] 왼쪽(카드 꼴) — 그림을 다시 그리면 막대가 새로 생김
+    const bar = cad.querySelector(".b06-cross-card__zoom");
+    if (bar && label.parentElement !== bar) bar.prepend(label, put);
+  };
+
+  const onClick = (event: MouseEvent): void => {
+    const hit = (event.target as Element).closest?.(`.${PIECE_HIT_CLASS}`);
+    const additive = event.shiftKey || event.ctrlKey || event.metaKey || mode === "area";
+    if (!hit) {
+      if (!additive && !mode && selected.length) {
+        selected = [];
+        show();
+      }
+      return;
+    }
+    event.stopPropagation();
+    selected = toggleSelection(selected, hits.indexOf(hit as SVGPolylineElement), additive);
+    show();
+    input.picked(additive);
+  };
+  cad.addEventListener("click", onClick);
+
+  return {
+    redraw() {
+      selected = [];
+      const axes = input.axes();
+      const layer = cad.querySelector<SVGGElement>("g.b06-chart__plot-layer");
+      pieces = axes && layer ? collectPieces([...layer.querySelectorAll("*")], axes) : [];
+      const toPx = axes ? mToPx(axes) : null;
+      hits = toPx
+        ? pieces.map((piece) => {
+            const hit = document.createElementNS(SVG_NS, "polyline");
+            hit.setAttribute("points", piece.points.map(toPx).join(" "));
+            hit.setAttribute("class", `${PIECE_HIT_CLASS} ${PIECE_HIT_CLASS}--${piece.line}`);
+            layer?.append(hit);
+            return hit;
+          })
+        : [];
+      show();
+    },
+    setMode(kind) {
+      mode = kind;
+      show();
+    },
+    source: (kind) =>
+      selectionSource(
+        kind,
+        selected.map((i) => pieces[i]),
+      ),
+    clear() {
+      selected = [];
+      show();
+    },
+    detach() {
+      cad.removeEventListener("click", onClick);
+    },
+  };
+}
diff --git a/B06_Section/B06_Section_UI_Cross_Detail_Table.ts b/B06_Section/B06_Section_UI_Cross_Detail_Table.ts
index 4413240e1..24bf4203d 100644
--- a/B06_Section/B06_Section_UI_Cross_Detail_Table.ts
+++ b/B06_Section/B06_Section_UI_Cross_Detail_Table.ts
@@ -6,7 +6,9 @@
  *   값은 서버(`B07_DesignDetail_Engine_Cross_Table_Edit`)가 그릴 때마다 다시 셈 — 모달 · B07 도면 표 한 벌.
  *   조작 직후 그 칸 글만 `localCellValue` 로 즉시 — 짝(① 파이썬 · TS) · 거울 시험
  *   `resources/tester/test_179_4_detail_table.py`.
- * 고르기: 면적 = 면적 띠 · 사토장(띠 → 표 키) · 길이 = 보라 판정 선 두 끝(화면 px → m · 축 옵션).
+ * 고르기: 면적 = 면적 띠 · 사토장(띠 → 표 키) 또는 닫힌 선 조각들 · 길이 = 선 조각(들) —
+ *   조각 = 선이 만나는 점에서 나눈 것(209-1 · `_Cross_Detail_Select`) · 저장 = 조각 두 끝 목록.
+ *   길이는 한 번 누름 = 바로 칸에 · Shift/Ctrl+누름 = 여럿 → Enter · [칸에 넣기].
  * ========================================================================== */
 
 import { readState, writeState } from "../A00_Common/b_page_state";
@@ -17,8 +19,10 @@ import type {
   CrossDetailTable,
   CrossSection,
 } from "./B06_Section_Api_Fetch";
+import type { SectionSample } from "./B06_Section_Api_Types";
 import type { CrossAxesOptions } from "./B06_Section_UI_Cross_Axes";
-import { CROSS_PAD } from "./B06_Section_UI_Section_Common";
+import { pickLines, piecesValue } from "./B06_Section_UI_Cross_Detail_Geom";
+import { attachDetailSelect, PIECE_HIT_CLASS } from "./B06_Section_UI_Cross_Detail_Select";
 
 /** 서버 `MAX_ROWS` · `MAX_COLUMNS` · `LINE_TOLERANCE_M` 와 같은 값. */
 export const MAX_ROWS = 12;
@@ -162,7 +166,6 @@ const AREA_BANDS: ReadonlyArray<[string, string]> = [
   ["b06-chart__spoil-fill", "spoil_fill"],
 ];
 export const AREA_PICK_SELECTOR = ".b06-chart__area, .b06-chart__spoil-fill";
-export const LENGTH_PICK_SELECTOR = ".b06-chart__design-hit";
 
 export function areaSourceOf(target: Element): CrossCellSource | null {
   const hit = target.closest(AREA_PICK_SELECTOR);
@@ -170,27 +173,6 @@ export function areaSourceOf(target: Element): CrossCellSource | null {
   return band ? { src: "area", key: band[1] } : null;
 }
 
-const round4 = (value: number): number => Math.round(value * 1e4) / 1e4;
-
-/** 판정 선 두 끝 → [offset, 표고](m) — 도형 층 좌표(카드 `x` · `toDisplayY` 의 역). */
-export function lengthSourceOf(target: Element, axes: CrossAxesOptions): CrossCellSource | null {
-  const hit = target.closest(LENGTH_PICK_SELECTOR);
-  const points = (hit?.getAttribute("points") ?? "")
-    .trim()
-    .split(/\s+/)
-    .map((pair) => pair.split(",").map(Number));
-  if (points.length < 2 || points.some((p) => p.length !== 2 || !p.every(Number.isFinite)))
-    return null;
-  const toM = ([px, py]: number[]): [number, number] => {
-    const display = axes.displayMax - (py - CROSS_PAD.top) / axes.pixelsPerMeter;
-    return [
-      round4(axes.maxOffset - (px - CROSS_PAD.left) / axes.pixelsPerMeter),
-      round4(axes.elevationMid + (display - axes.elevationMid) / axes.exaggeration),
-    ];
-  };
-  return { src: "length", start: toM(points[0]), end: toM(points[points.length - 1]) };
-}
-
 /* ── 칸 값(짝 ① · 서버 `cell_value` 거울) ─────────────────────────────────── */
 
 const AREA_DESIGN: Readonly<Record<string, string>> = {
@@ -219,9 +201,15 @@ function onLine([px, py]: [number, number], line: ReadonlyArray<[number, number]
   return false;
 }
 
-/** 조작 직후 칸 숫자(서버가 [저장] · 다시 받을 때 정본으로 다시 셈) — 글 · 못 셈 = null. */
-export function localCellValue(source: CrossCellSource, design: CrossDesign | undefined) {
+/** 조작 직후 칸 숫자(서버가 [저장] · 다시 받을 때 정본으로 다시 셈) — 글 · 못 셈 = null.
+ *  `samples` = 측점 원지반(조각 검산 · 209-1). */
+export function localCellValue(
+  source: CrossCellSource,
+  design: CrossDesign | undefined,
+  samples?: ReadonlyArray<SectionSample>,
+) {
   const record = (design ?? {}) as unknown as Record<string, unknown>;
+  if ("pieces" in source) return piecesValue(source.src, source.pieces, pickLines(design, samples));
   if (source.src === "area") return finite(record[AREA_DESIGN[source.key] ?? ""]);
   if (source.src !== "length") return null;
   const line = (design?.design_line ?? [])
@@ -292,12 +280,16 @@ export interface DetailTableHost {
 let menu: ReturnType<typeof createMapContextMenu> | null = null;
 
 const PICK_HINT = {
-  area: "면적 띠를 누름 · Esc 취소",
-  length: "보라 선을 누름 · Esc 취소",
+  area: "면적 띠를 누름 · 또는 닫힌 영역의 선들을 차례로 누름 → Enter · Esc 취소",
+  length: "선을 누름 · Shift/Ctrl+누름 = 여럿 → Enter · Esc 취소",
 } as const;
 
-/** 표 우클릭 · 그래프 고르기 · 더한 칸 글 손질을 검. 돌려준 함수 = 떼기(모달 닫힐 때). */
-export function attachDetailTable(host: DetailTableHost): () => void {
+/** 표 우클릭 · 그래프 고르기 · 더한 칸 글 손질을 검. detach = 떼기(모달 닫힐 때) ·
+ *  redraw = 그림을 새로 그린 뒤(선 조각 · 판정 선 다시 · 209-1). */
+export function attachDetailTable(host: DetailTableHost): {
+  detach: () => void;
+  redraw: () => void;
+} {
   menu ??= createMapContextMenu("b06-detail");
   const ctxMenu = menu;
   if (!ctxMenu.element.isConnected) {
@@ -318,9 +310,30 @@ export function attachDetailTable(host: DetailTableHost): () => void {
     picking = null;
     delete cad.dataset.pick;
     delete cad.dataset.pickHint;
+    select.setMode(null);
     document.removeEventListener("keydown", onKey, true);
   };
+  /** 고른 출처를 칸에 — 칸 글 즉시(짝 ①) · 세션 초안 → 서버 표 다시 받음. */
+  const commit = (source: CrossCellSource | null): void => {
+    if (!picking || !source) return;
+    const { key } = picking;
+    stopPick();
+    select.clear();
+    const section = host.section();
+    const shown = localCellValue(source, section.design, section.samples);
+    const td = tableBox.querySelector<HTMLElement>(`td[data-cell="${CSS.escape(key)}"]`);
+    if (td) td.textContent = shown === null ? "다시 고름" : shown.toFixed(2);
+    edit((table) => setCell(table, key, source));
+  };
+  const commitSelection = (): void => {
+    if (picking) commit(select.source(picking.kind));
+  };
   const onKey = (event: KeyboardEvent): void => {
+    if (event.key === "Enter") {
+      event.preventDefault();
+      commitSelection();
+      return;
+    }
     if (event.key !== "Escape") return;
     event.stopPropagation(); // 모달은 그대로 — 고르기만 취소
     stopPick();
@@ -329,29 +342,30 @@ export function attachDetailTable(host: DetailTableHost): () => void {
     picking = { kind, key };
     cad.dataset.pick = kind;
     cad.dataset.pickHint = PICK_HINT[kind];
+    select.setMode(kind);
     document.addEventListener("keydown", onKey, true);
   };
+  // 선 조각 고름(209-1) — 길이 한 번 누름(더하기 아님) = 바로 칸에
+  const select = attachDetailSelect({
+    cad,
+    design: () => host.section().design,
+    axes: host.axes,
+    picked: (additive) => {
+      if (picking?.kind === "length" && !additive) commitSelection();
+    },
+    commit: commitSelection,
+  });
+  // 면적 띠 · 사토장 누름 = 그 띠 면적(179-4 그대로) — 선 조각 누름은 위가 맡음
   const onPick = (event: MouseEvent): void => {
-    if (!picking) return;
-    const selector = picking.kind === "area" ? AREA_PICK_SELECTOR : LENGTH_PICK_SELECTOR;
-    // 겹친 요소(띠 위 판정 선 등) 아래까지 — 그 자리 맨 위 대상
+    if (picking?.kind !== "area" || (event.target as Element).closest(`.${PIECE_HIT_CLASS}`))
+      return;
     const hit = document
       .elementsFromPoint(event.clientX, event.clientY)
-      .find((el) => cad.contains(el) && el.closest(selector));
-    const axes = host.axes();
-    const source = !hit
-      ? null
-      : picking.kind === "area"
-        ? areaSourceOf(hit)
-        : axes && lengthSourceOf(hit, axes);
+      .find((el) => cad.contains(el) && el.closest(AREA_PICK_SELECTOR));
+    const source = hit ? areaSourceOf(hit) : null;
     if (!source) return;
     event.stopPropagation();
-    const { key } = picking;
-    stopPick();
-    const shown = localCellValue(source, host.section().design);
-    const td = tableBox.querySelector<HTMLElement>(`td[data-cell="${CSS.escape(key)}"]`);
-    if (td) td.textContent = shown === null ? "다시 고름" : shown.toFixed(2);
-    edit((table) => setCell(table, key, source));
+    commit(source);
   };
   cad.addEventListener("click", onPick);
 
@@ -401,12 +415,16 @@ export function attachDetailTable(host: DetailTableHost): () => void {
   tableBox.addEventListener("focusout", onBlur);
   tableBox.addEventListener("keydown", onEnter);
 
-  return () => {
-    stopPick();
-    ctxMenu.close();
-    cad.removeEventListener("click", onPick);
-    tableBox.removeEventListener("contextmenu", onMenu);
-    tableBox.removeEventListener("focusout", onBlur);
-    tableBox.removeEventListener("keydown", onEnter);
+  return {
+    detach: () => {
+      stopPick();
+      ctxMenu.close();
+      select.detach();
+      cad.removeEventListener("click", onPick);
+      tableBox.removeEventListener("contextmenu", onMenu);
+      tableBox.removeEventListener("focusout", onBlur);
+      tableBox.removeEventListener("keydown", onEnter);
+    },
+    redraw: () => select.redraw(),
   };
 }
diff --git a/B06_Section/B06_Section_UI_Cross_FillSlope_Notice.ts b/B06_Section/B06_Section_UI_Cross_FillSlope_Notice.ts
index 2ceacd67b..0ab8bcb08 100644
--- a/B06_Section/B06_Section_UI_Cross_FillSlope_Notice.ts
+++ b/B06_Section/B06_Section_UI_Cross_FillSlope_Notice.ts
@@ -41,10 +41,13 @@ function rows(warnings: FillSlopeWarning[], stationInterval: number): NoticeChip
   });
 }
 
-export function createFillSlopeNotice(onPick: (stationId: string) => void): FillSlopeNotice {
+export function createFillSlopeNotice(
+  onPick: (stationId: string) => void,
+  selected: () => string | null,
+): FillSlopeNotice {
   const root = document.createElement("div");
   root.className = "b06-section__notice-bar";
-  const chips = createNoticeChips(onPick);
+  const chips = createNoticeChips(onPick, selected);
   root.append(chips.root);
 
   return {
diff --git a/B06_Section/B06_Section_UI_Cross_Notice_Chips.ts b/B06_Section/B06_Section_UI_Cross_Notice_Chips.ts
index 648236959..54760e806 100644
--- a/B06_Section/B06_Section_UI_Cross_Notice_Chips.ts
+++ b/B06_Section/B06_Section_UI_Cross_Notice_Chips.ts
@@ -3,6 +3,8 @@
  * 횡단 알림 줄 칩 꼴(196-1) — 항목 = 짧은 이름 + 측점 수 칩 한 줄 · 긴 설명 = 공용 호버.
  * 줄 아래 내용 칸 하나를 같이 씀 — 누른 칩의 측점 목록만 · 같은 칩 다시 누르면 닫힘 ·
  * 다른 칩 누르면 바뀜(한 번에 하나). 측점 단추 누름 = `onPick`(그 카드로).
+ * ⭐ 207-1 — 내용 칸은 줄 아래 카드 위에 겹쳐 뜸(흐름 밖 · CSS) · 측점 누르면 접힘 ·
+ * 열 때 지금 고른 측점(`selected`) 단추 강조.
  * 무엇을 셀지는 부르는 쪽(`_FillSlope_Notice`) — 여기는 그리기만.
  * ========================================================================== */
 
@@ -29,7 +31,10 @@ export interface NoticeChips {
   update: (items: NoticeChipItem[]) => void;
 }
 
-export function createNoticeChips(onPick: (stationId: string) => void): NoticeChips {
+export function createNoticeChips(
+  onPick: (stationId: string) => void,
+  selected: () => string | null = () => null,
+): NoticeChips {
   const root = document.createElement("div");
   root.className = "b06-section__notice-blocks";
   const chips = document.createElement("div");
@@ -57,12 +62,14 @@ export function createNoticeChips(onPick: (stationId: string) => void): NoticeCh
     );
     panel.hidden = !open;
     panel.classList.toggle("is-info", open?.tone === "info");
+    const picked = open ? selected() : null;
     panel.replaceChildren(
       ...(open?.rows ?? []).map((row) => {
         const button = document.createElement("button");
         button.type = "button";
         button.textContent = row.text;
         button.dataset.stationId = row.stationId;
+        button.classList.toggle("is-selected", row.stationId === picked);
         return button;
       }),
     );
@@ -77,7 +84,10 @@ export function createNoticeChips(onPick: (stationId: string) => void): NoticeCh
   });
   panel.addEventListener("click", (event) => {
     const id = (event.target as HTMLElement).closest("button")?.dataset.stationId;
-    if (id) onPick(id);
+    if (!id) return;
+    openKey = null;
+    render();
+    onPick(id);
   });
   attachHoverInfo(
     chips,
diff --git a/B06_Section/B06_Section_UI_Cross_Panel_Base.ts b/B06_Section/B06_Section_UI_Cross_Panel_Base.ts
index 08da4506a..6833d8a20 100644
--- a/B06_Section/B06_Section_UI_Cross_Panel_Base.ts
+++ b/B06_Section/B06_Section_UI_Cross_Panel_Base.ts
@@ -80,7 +80,9 @@ if (typeof document !== "undefined")
   document.addEventListener(
     "pointerdown",
     (event) => {
-      lastPointer = event.target instanceof Element ? event.target : null;
+      // 새 창 종단도가 넘긴 누름은 다른 창 요소라 instanceof Element 가 거짓 — closest 로 가림(219-1)
+      const target = event.target as Element | null;
+      lastPointer = typeof target?.closest === "function" ? target : null;
     },
     true,
   );
@@ -90,6 +92,14 @@ export function arrowsBelongToProfile(): boolean {
   return !!lastPointer?.closest(".b05-route-profile");
 }
 
+/** 조정창 없는 고름(관 · 도수로/돌붙임 띠)이 방향키를 삼키나 — 그 동안 방향키는 아무것도 안 옮김.
+ *  안 삼키면 종단도 듣개가 받아 관 기준측점을 0.1 m 씩 몰래 옮겼음(219-1). 종단도를 눌렀으면 종단도 몫. */
+export function swallowsArrows(side: string | undefined, key: string): boolean {
+  return (
+    (side === "pipe" || side === "chute") && key.startsWith("Arrow") && !arrowsBelongToProfile()
+  );
+}
+
 /** 고른 구조물의 도형 — 벽 · 집수정 · 측벽은 `culvert` 계열, BOX 끝은 판정면이 켜진다. */
 const ACTIVE_SHAPES = '[class*="culvert"].is-active, .b06-chart__box-hit.is-active';
 
diff --git a/B06_Section/B06_Section_UI_Cross_Structure_Panel.ts b/B06_Section/B06_Section_UI_Cross_Structure_Panel.ts
index b5549919b..0dec26028 100644
--- a/B06_Section/B06_Section_UI_Cross_Structure_Panel.ts
+++ b/B06_Section/B06_Section_UI_Cross_Structure_Panel.ts
@@ -21,6 +21,7 @@ import type { SpanValues } from "./B06_Section_UI_Cross_Culvert_Wire";
 import { L } from "./B06_Section_UI_Section_Common";
 import {
   arrowsBelongToProfile,
+  swallowsArrows,
   bindDragHandle,
   dragReadout,
   makeButton,
@@ -437,6 +438,14 @@ export function buildStructurePanel(
       document.removeEventListener("keydown", onArrowKey);
       return;
     }
+    // 관 · 도수로 띠 고름(조정창 없음) = 방향키 삼킴 · 보기가 보일 때만(219-1)
+    if (
+      swallowsArrows(root.dataset.side, event.key) &&
+      root.parentElement?.getClientRects().length
+    ) {
+      event.preventDefault();
+      return;
+    }
     const slot = ARROW_SLOT[event.key];
     // 보기가 숨었으면(한 페이지 두 보기 · 계획서 24-3a) 다른 보기의 방향키를 먹지 않는다.
     if (!slot || root.classList.contains("is-hidden") || !root.getClientRects().length) return;
@@ -503,7 +512,10 @@ export function buildStructurePanel(
       root.dataset.side = pick === "pipe" || pick === "chute" ? pick : "";
       document.removeEventListener("keydown", onArrowKey);
       drag.detach();
-      if (!key) return;
+      if (!key) {
+        if (!opts?.dock && root.dataset.side) document.addEventListener("keydown", onArrowKey);
+        return;
+      }
       if (!opts?.dock) {
         document.addEventListener("keydown", onArrowKey);
         drag.attach();
diff --git a/B06_Section/B06_Section_UI_Page_Structures_Panel.ts b/B06_Section/B06_Section_UI_Page_Structures_Panel.ts
index 0abc4bfc5..e3c76208c 100644
--- a/B06_Section/B06_Section_UI_Page_Structures_Panel.ts
+++ b/B06_Section/B06_Section_UI_Page_Structures_Panel.ts
@@ -38,6 +38,7 @@ import {
 } from "../common_util/common_util_summary_item";
 import { readStructurePick } from "../B05_Profile/B05_Profile_UI_Structure_Pick_Session";
 import {
+  coversAtStation,
   coversChainage,
   NO_SELECTION,
   PIPE_MATCH_M,
@@ -163,7 +164,7 @@ export function createB06StructuresPanel(deps: B06StructuresPanelDeps): B06Struc
   let markTypes: StructureType[] = [];
   /** 카드 누름이 덮어 여는 구조물 — 노면공(G군)은 뺌(152-5 · 목록 · 알약 고름은 id 길로 그대로). */
   const coverable = (entry: StructureInstance): boolean =>
-    markTypes.find((type) => type.type_id === entry.type_id)?.group !== "G";
+    coversAtStation(markTypes.find((type) => type.type_id === entry.type_id)?.group);
   /** 다음 카드 고름이 열 구조물 — 같은 측점에 관이 있어도 누른 것이 먼저다(52-15). */
   let preferredId: string | null = null;
   /** 그 구조물로 갈 카드 측점 — 구간형은 범위 안 카드 중 기준점에 가까운 것(경계 기준점이 범위 밖 카드로 안 감 · 165-2). */
@@ -475,7 +476,11 @@ export function createB06StructuresPanel(deps: B06StructuresPanelDeps): B06Struc
     const hit = pipeFacilities.find(
       (entry) => Math.abs(entry.chainage_m - fromChainageM) < PIPE_MATCH_M,
     );
-    if (hit) hit.chainage_m = to;
+    if (hit) {
+      // 그 관 측점의 계획고 편집도 새 자리로 — 옛 키가 유령 꼭짓점으로 남지 않게(213-2)
+      deps.shared.profile?.resetStationEdit(hit.chainage_m, to);
+      hit.chainage_m = to;
+    }
     if (currentChainageM !== null && Math.abs(currentChainageM - fromChainageM) < PIPE_MATCH_M)
       currentChainageM = to;
     pipeFacilities.sort((left, right) => left.chainage_m - right.chainage_m);
diff --git a/B06_Section/B06_Section_UI_Section_Common.ts b/B06_Section/B06_Section_UI_Section_Common.ts
index bfda291de..105bcddb9 100644
--- a/B06_Section/B06_Section_UI_Section_Common.ts
+++ b/B06_Section/B06_Section_UI_Section_Common.ts
@@ -106,6 +106,8 @@ interface StaleCandidate {
     geometry_preset?: string;
     two_stage_slope?: boolean;
     surface_drop_m?: number;
+    section_mode?: string;
+    ditch_enabled?: boolean;
   } | null;
 }
 
@@ -120,6 +122,8 @@ function isStaleSection(
   // 이 조건이 B06 페이지에만 있어 B05는 재계산을 건너뛰었고, 같은 데이터인데 두 화면의
   // 절토량이 갈렸다(2026-09-03 실측 228.52㎡ ↔ 270.12㎡). 판정을 여기 한 곳으로 모은다.
   if (design.geometry_preset === "rock" && design.two_stage_slope === undefined) return true;
+  // 옛 엔진이 양측 성토에 측구를 세워 둔 저장분(206-1) — 지금 엔진으로 다시 셈.
+  if (design.section_mode === "both_fill" && design.ditch_enabled === true) return true;
   if (!profiles?.length) return false;
   const planned = designElevationAt(profiles, section.chainage_m);
   if (planned === undefined) return false;
diff --git a/B06_Section/B06_Section_UI_Section_View.ts b/B06_Section/B06_Section_UI_Section_View.ts
index a67009b38..bc95835f8 100644
--- a/B06_Section/B06_Section_UI_Section_View.ts
+++ b/B06_Section/B06_Section_UI_Section_View.ts
@@ -124,8 +124,9 @@ export function createSectionView(
   } = { balloonScope: "-" };
 
   // 성토사면 5m 초과 경고 줄(2026-09-14 브레인 (나)) — 카드 위 · 측점 누르면 그 카드로.
-  const fillSlopeNotice = createFillSlopeNotice((id) =>
-    selectedStationId === id ? revealCard(id, "smooth") : selectStation(id, true),
+  const fillSlopeNotice = createFillSlopeNotice(
+    (id) => (selectedStationId === id ? revealCard(id, "smooth") : selectStation(id, true)),
+    () => selectedStationId,
   );
   // 열 수 칸(138-3) — 고정 알림 줄 오른쪽 끝 · 1~6 · 바꾸면 카드 전부 다시 그림
   const columnsField = createInputField({
diff --git a/B06_Section/B06_Section_UI_Style_Cross.css b/B06_Section/B06_Section_UI_Style_Cross.css
index 8a0d5fdd7..6bd6c56e3 100644
--- a/B06_Section/B06_Section_UI_Style_Cross.css
+++ b/B06_Section/B06_Section_UI_Style_Cross.css
@@ -124,7 +124,8 @@
 }
 
 /* 알림 줄(138-3) — 카드 칸 맨 위 고정 · 알림 없어도 줄 유지 · 오른쪽 끝 열 수 칸.
-   위 여백(카드 칸 padding)만큼 끌어올려 그 틈으로 카드가 비치지 않게 */
+   위 여백(카드 칸 padding)만큼 끌어올려 그 틈으로 카드가 비치지 않게.
+   217-1 — 칩 줄 위 여백 16→8 · 칩 줄 ↔ 첫 카드 28→16(카드 칸 gap 24 에서 8 을 당김) */
 .b06-section__notice-bar {
   position: sticky;
   top: calc(-1 * var(--spacing-16));
@@ -132,8 +133,8 @@
   display: flex;
   align-items: flex-start;
   gap: var(--spacing-8);
-  margin-top: calc(-1 * var(--spacing-16));
-  padding-block: var(--spacing-16) var(--spacing-4);
+  margin-block: calc(-1 * var(--spacing-16)) calc(-1 * var(--spacing-8));
+  padding-block: var(--spacing-8) 0;
   background: var(--color-bg);
 }
 
@@ -172,9 +173,10 @@
 }
 
 .b06-section__notice-chip {
-  padding: 0 var(--spacing-8);
+  padding: 2px var(--spacing-8);
   border: 1px solid currentColor;
-  border-radius: var(--radius-sm);
+  /* 둥근 사각(207-1) — 공용 단추 반경 · 알약 아님 */
+  border-radius: var(--radius-buttons);
   background: transparent;
   color: var(--color-warning);
   font-size: var(--text-caption);
@@ -193,14 +195,24 @@
   font-weight: 600;
 }
 
-/* 내용 칸 하나(누른 칩의 측점 목록) — 길면 줄 안에서 스크롤 · 고정 줄이 카드 칸을 다 덮지 않게 */
+/* 내용 칸 하나(누른 칩의 측점 목록) — 길면 칸 안에서 스크롤 · 고정 줄이 카드 칸을 다 덮지 않게.
+   207-1 — 줄 아래 카드 위에 겹쳐 뜸(흐름 밖) · 열고 닫아도 줄 높이 · 카드 자리 그대로 */
 .b06-section__notice-list {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  right: 0;
+  z-index: 1;
   display: flex;
   flex-wrap: wrap;
   gap: var(--spacing-4);
   max-height: 30vh;
   overflow: auto;
-  padding-top: var(--spacing-4);
+  padding: var(--spacing-8);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-cards);
+  background: var(--color-surface-raised);
+  box-shadow: var(--shadow-lg);
   color: var(--color-warning);
 }
 
@@ -213,6 +225,13 @@
   white-space: nowrap;
 }
 
+/* 지금 고른 측점(207-1) — 카드 고름 색과 같음 */
+.b06-section__notice-list > button.is-selected {
+  outline: 2px solid var(--color-danger);
+  outline-offset: -1px;
+  font-weight: 600;
+}
+
 .b06-cross-card {
   cursor: pointer;
   transition:
diff --git a/B06_Section/B06_Section_UI_Style_Cross_Detail.css b/B06_Section/B06_Section_UI_Style_Cross_Detail.css
index ab0354901..2f14f0637 100644
--- a/B06_Section/B06_Section_UI_Style_Cross_Detail.css
+++ b/B06_Section/B06_Section_UI_Style_Cross_Detail.css
@@ -164,11 +164,42 @@
 
 /* 그래프에서 고르기 — 고를 대상만 손가락 · 왼쪽 아래(눈금 자리) 안내 글 */
 .b06-detail__cad[data-pick="area"] .b06-chart__area > polygon,
-.b06-detail__cad[data-pick="area"] .b06-chart__spoil-fill,
-.b06-detail__cad[data-pick="length"] .b06-chart__design-hit {
+.b06-detail__cad[data-pick="area"] .b06-chart__spoil-fill {
   cursor: pointer;
 }
 
+/* 선 조각 판정 선(209-1) — 투명 굵은 선 · 배율 무관 굵기 · 고른 조각 = 붉은 띠 */
+.b06-detail__piece {
+  fill: none;
+  stroke: transparent;
+  stroke-width: 10;
+  stroke-linecap: round;
+  vector-effect: non-scaling-stroke;
+  pointer-events: stroke;
+  cursor: pointer;
+}
+
+.b06-detail__piece:hover {
+  stroke: color-mix(in srgb, var(--color-accent) 25%, transparent);
+}
+
+.b06-detail__piece.is-selected {
+  stroke: color-mix(in srgb, var(--color-danger) 55%, transparent);
+  stroke-width: 6;
+}
+
+/* 고른 것 값(카드 179-1 꼴) · [칸에 넣기] — [+ − ⤢] 왼쪽 */
+.b06-detail__commit {
+  width: auto;
+  padding: 0 var(--spacing-4);
+  color: var(--color-accent);
+  white-space: nowrap;
+}
+
+.b06-detail__commit[hidden] {
+  display: none;
+}
+
 .b06-detail__cad[data-pick]::after {
   content: attr(data-pick-hint);
   position: absolute;
diff --git a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts
index 696c3f773..2efd5bcc4 100644
--- a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts
+++ b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts
@@ -41,6 +41,8 @@ export interface CadDrawing {
   stale_layout?: boolean;
   /** 횡단 장 — 지금과 다른 표 · 글 배율로 확정된 저장본(180-2). */
   stale_scale?: boolean;
+  /** 횡단 장 — 측점 도면층(212-2) 앞에 확정된 저장본. [수정]을 누르면 측점 층으로 다시 만든다. */
+  stale_layers?: boolean;
   layers: {
     id: string;
     name: string;
diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py
index e2b8d5eb5..1dc94c77b 100644
--- a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py
+++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py
@@ -5,6 +5,8 @@
 칸 가운데 · 작성 척도 1/100 그대로(큰 단면이 칸을 넘으면 겹침 — 사용자 배치로 고침).
 칸 = 인쇄되는 표 격자선 · 블록 테두리 없음 · 칸보다 큰 단면은 `overflow_cells`(169-2).
 칸 안 = 표를 칸 아래 가운데에 먼저 · 그 위 글 · 그림(도로 중심 = 칸 가운데)(174-1).
+측점마다 도면층 하나(「횡단 No.3」) = 원지반 · 계획선 · 구조물 · 암 그림 · 종류는 색 · 선 꼴
+· 표 · 글은 수량표 층(212-2).
 """
 
 import re
@@ -52,6 +54,10 @@ CROSS_SHEET_ID = re.compile(r"cross_s(\d{2,}(?:\.\d{2})?)m?")
 _BORDER_PAD_MM = CROSS_BORDER_PAD_MM
 # 칸 아래선 ~ 표 아래선 여백(mm) — 같은 행 표가 한 높이(174-1)
 CELL_TABLE_PAD_MM = 5.0
+# 측점 도면층 id 머리(212-2) — 뒤에 측점 · DXF 층 이름도 이 id
+STATION_LAYER_PREFIX = "b08-station-"
+# 측점 층으로 옮길 그림 종류 층 — 표 · 글(수량표 층)은 그대로
+_DRAWING_LAYER_IDS = {GROUND_LAYER_ID, DESIGN_LAYER_ID, STRUCTURE_LAYER_ID, ROCK_LAYER_ID}
 
 
 def _design_points(design_line: list[Any] | None) -> list[tuple[float, float]]:
@@ -178,11 +184,20 @@ def _grid_lines(sheet_id: str, cols: int, rows: int) -> list[dict[str, Any]]:
     ]
 
 
+def _move_to_layer(entity: dict[str, Any], layer_id: str) -> None:
+    """그림 종류 층 개체(자식 선까지)를 측점 층으로 — id 는 그대로(212-2)."""
+    if entity.get("layerId") in _DRAWING_LAYER_IDS:
+        entity["layerId"] = layer_id
+        for child in entity.get("children") or []:
+            child["layerId"] = layer_id
+
+
 def build_cross_sheet(sheet: dict[str, Any], sections: list[dict[str, Any]]) -> dict[str, Any]:
     """한 장을 만든다. sections는 이 장에 담을 측점 입력들(배치 순서대로)."""
     entities: list[dict[str, Any]] = []
     placements: list[dict[str, Any]] = []
     overflow: list[list[float]] = []
+    station_layers: list[dict[str, Any]] = []
     slots = sheet.get("slots") or []
     cols, rows = sheet.get("grid") or (4, 4)
     usable_w, usable_h = usable_area()
@@ -222,8 +237,17 @@ def build_cross_sheet(sheet: dict[str, Any], sections: list[dict[str, Any]]) ->
         group_id = str(uuid5(_ENTITY_NS, f"{seed_id}:group"))
         for entity in placed["entities"]:
             entity["groupId"] = group_id
+        # 측점 도면층(212-2) — 층 관리에서 그 측점 그림만 고르기 · 켜고 끄기 · 잠그기
+        layer_id = f"{STATION_LAYER_PREFIX}{section['chainage']}"
+        title = section.get("title") or f"{section['chainage']}"
+        station_layers.append(_layer(layer_id, f"횡단 {title}"))
+        design_ids = [e["id"] for e in placed["entities"] if e["layerId"] == DESIGN_LAYER_ID]
+        for entity in placed["entities"]:
+            _move_to_layer(entity, layer_id)
         for placement in placed.get("cross_placements") or []:
             placement["group_id"] = group_id
+            placement["layer_id"] = layer_id
+            placement["design_ids"] = design_ids  # 화면이 다시 그려 갈아 끼울 서버 설계선
         entities.extend(placed["entities"])
         placements.extend(placed.get("cross_placements") or [])
 
@@ -246,10 +270,7 @@ def build_cross_sheet(sheet: dict[str, Any], sections: list[dict[str, Any]]) ->
         # 칸보다 큰 단면의 칸 [x0, y0, x1, y1] — 라우터가 CAD 가이드 붉은 틀로 보냄(169-2)
         "overflow_cells": overflow,
         "layers": [
-            _layer(GROUND_LAYER_ID, "원지반"),
-            _layer(DESIGN_LAYER_ID, "계획선"),
-            _layer(STRUCTURE_LAYER_ID, "구조물"),
-            _layer(ROCK_LAYER_ID, "암 경계선"),
+            *station_layers,
             _layer(CROSS_TABLE_LAYER_ID, "수량 산출표"),
             _layer(FRAME_LAYER_ID, "도각", locked=True),
         ],
diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cross_Table_Edit.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cross_Table_Edit.py
index bcdb964c2..d522ab3f9 100644
--- a/B07_DesignDetail/B07_DesignDetail_Engine_Cross_Table_Edit.py
+++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cross_Table_Edit.py
@@ -6,11 +6,17 @@
     area   = 설계 면적 칸 그대로(`AREA_KEYS` · 띠 키 = 표 키)
     length = 두 끝(m · offset · 표고)이 설계선 위면 hypot · 아니면 비움 → 「다시 고름」
     text   = 글 그대로 — 더한 칸(`r:` 행 · `c:` 열)만
+    고른 조각(209-1 · `pieces` = [{line, start, end}]) — 교차점에서 나눈 선 조각 목록:
+        length = 조각 길이 합 · area = 조각이 닫힌 고리를 이루면 그 넓이(안 닫힘 → 「다시 고름」)
+        조각 길 = 그 선(설계선 · 원지반선 · 사토장선) 위 두 끝 사이 꺾은선
+        (두 끝이 선 밖 → 「다시 고름」)
+        · 구조물 선(`structure` · 브라우저 기하)은 위치 검산 없이 두 끝 직선.
 행(`rows`) = 묶음 안(이 행 아래 · 묶음이면 하위 줄) 또는 끝에 항목 줄(좌 · 중 · 우 이름 + 값).
 열(`columns`) = 오른쪽 끝 · 모든 행(비고 등).
 
 짝(① 파이썬 · TS) = `B06_Section/B06_Section_UI_Cross_Detail_Table.ts` `localCellValue`
-(조작 중 즉시 표시) · 거울 시험 `resources/tester/test_179_4_detail_table.py`.
+(조작 중 즉시 표시) · 조각 길 · 넓이 = `B06_Section/B06_Section_UI_Cross_Detail_Geom.ts` ·
+거울 시험 `resources/tester/test_179_4_detail_table.py` · `test_209_1_detail_select.py`.
 """
 
 from __future__ import annotations
@@ -46,9 +52,9 @@ def _point(value: Any) -> tuple[float, float] | None:
     return (x, y) if x is not None and y is not None else None
 
 
-def _design_line(design: dict[str, Any]) -> list[tuple[float, float]]:
+def _polyline(raw: Any) -> list[tuple[float, float]]:
     points = []
-    for point in design.get("design_line") or []:
+    for point in raw if isinstance(raw, list) else []:
         if isinstance(point, dict):
             x, y = _num(point.get("offset_m")), _num(point.get("elevation_m"))
             if x is not None and y is not None:
@@ -56,6 +62,24 @@ def _design_line(design: dict[str, Any]) -> list[tuple[float, float]]:
     return points
 
 
+def _design_line(design: dict[str, Any]) -> list[tuple[float, float]]:
+    return _polyline(design.get("design_line"))
+
+
+def ground_runs(samples: Any) -> list[list[tuple[float, float]]]:
+    """원지반선 — 무효 표고 샘플마다 끊은 꺾은선들(카드 `appendGroundProfile` 과 같은 규칙)."""
+    runs: list[list[tuple[float, float]]] = [[]]
+    for sample in samples if isinstance(samples, list) else []:
+        sample = sample if isinstance(sample, dict) else {}
+        x = _num(sample.get("offset_m"))
+        y = _num(sample.get("elevation_m", sample.get("z")))
+        if sample.get("valid") is False or x is None or y is None:
+            runs.append([])
+        else:
+            runs[-1].append((x, y))
+    return [run for run in runs if len(run) > 1]
+
+
 def _on_line(point: tuple[float, float], line: list[tuple[float, float]]) -> bool:
     """점이 설계선(꺾은선) 조각 하나에서 `LINE_TOLERANCE_M` 안인가."""
     px, py = point
@@ -68,12 +92,119 @@ def _on_line(point: tuple[float, float], line: list[tuple[float, float]]) -> boo
     return False
 
 
+Point = tuple[float, float]
+
+
+def _locate(point: Point, run: list[Point]) -> float | None:
+    """선 위 자리(앞 끝에서 잰 길이 m) — 허용 안 가장 가까운 곳 · 없으면 None."""
+    best: tuple[float, float] | None = None
+    along = 0.0
+    for (ax, ay), (bx, by) in zip(run, run[1:]):
+        dx, dy = bx - ax, by - ay
+        size = hypot(dx, dy)
+        t = 0.0 if size == 0 else ((point[0] - ax) * dx + (point[1] - ay) * dy) / size**2
+        t = max(0.0, min(1.0, t))
+        gap = hypot(point[0] - (ax + t * dx), point[1] - (ay + t * dy))
+        if gap <= LINE_TOLERANCE_M and (best is None or gap < best[0]):
+            best = (gap, along + t * size)
+        along += size
+    return best[1] if best else None
+
+
+def _at(run: list[Point], s: float) -> Point:
+    """선 위 자리 s(m) 의 점."""
+    for (ax, ay), (bx, by) in zip(run, run[1:]):
+        size = hypot(bx - ax, by - ay)
+        if s <= size:
+            t = 0.0 if size == 0 else s / size
+            return (ax + t * (bx - ax), ay + t * (by - ay))
+        s -= size
+    return run[-1]
+
+
+def sub_path(run: list[Point], s0: float, s1: float) -> list[Point]:
+    """선 위 두 자리 사이 꺾은선(s0 → s1 차례) — 사이 꼭짓점 포함."""
+    lo, hi = min(s0, s1), max(s0, s1)
+    inner: list[Point] = []
+    along = 0.0
+    for a, b in zip(run, run[1:]):
+        along += hypot(b[0] - a[0], b[1] - a[1])
+        if lo < along < hi:
+            inner.append(b)
+    path = [_at(run, lo), *inner, _at(run, hi)]
+    return path if s0 <= s1 else path[::-1]
+
+
+def piece_path(piece: Any, lines: dict[str, list[list[Point]]]) -> list[Point] | None:
+    """고른 조각 하나 → 그 선 위 꺾은선 · 두 끝이 선 밖이면 None(구조물 선 = 두 끝 직선)."""
+    if not isinstance(piece, dict):
+        return None
+    start, end = _point(piece.get("start")), _point(piece.get("end"))
+    if not start or not end:
+        return None
+    if piece.get("line") == "structure":
+        return [start, end]
+    for run in lines.get(str(piece.get("line")), []):
+        s0, s1 = _locate(start, run), _locate(end, run)
+        if s0 is not None and s1 is not None:
+            return sub_path(run, s0, s1)
+    return None
+
+
+def path_length(path: list[Point]) -> float:
+    return sum(hypot(b[0] - a[0], b[1] - a[1]) for a, b in zip(path, path[1:]))
+
+
+def _near(a: Point, b: Point) -> bool:
+    return hypot(a[0] - b[0], a[1] - b[1]) <= LINE_TOLERANCE_M
+
+
+def ring_area(paths: list[list[Point]]) -> float | None:
+    """조각 길들을 끝끼리 이어 한 고리가 되면 그 넓이(㎡) · 안 닫힘 · 남는 조각 = None."""
+    if not paths:
+        return None
+    ring = list(paths[0])
+    rest = [list(path) for path in paths[1:]]
+    while rest:
+        index = next(
+            (i for i, p in enumerate(rest) if _near(p[0], ring[-1]) or _near(p[-1], ring[-1])),
+            None,
+        )
+        if index is None:
+            return None
+        path = rest.pop(index)
+        ring += (path if _near(path[0], ring[-1]) else path[::-1])[1:]
+    if len(ring) < 4 or not _near(ring[0], ring[-1]):
+        return None
+    ring.append(ring[0])  # 끝이 허용 안에서만 맞음 — 닫는 변을 꼭 넣음
+    area = abs(sum(a[0] * b[1] - b[0] * a[1] for a, b in zip(ring, ring[1:]))) / 2
+    return area if area > 1e-9 else None
+
+
+def pick_lines(design: dict[str, Any], samples: Any = None) -> dict[str, list[list[Point]]]:
+    """서버가 아는 선 — 고른 조각 위치 검산 대상(설계선 · 원지반선 · 사토장선)."""
+    return {
+        "design": [_design_line(design)],
+        "ground": ground_runs(samples),
+        "spoil": [_polyline(design.get("spoil_fill_line"))],
+    }
+
+
 def cell_value(
-    source: dict[str, Any], design: dict[str, Any] | None
+    source: dict[str, Any], design: dict[str, Any] | None, samples: Any = None
 ) -> tuple[float | None, str | None, bool]:
-    """출처 하나 → (숫자, 글, 다시 고름)."""
+    """출처 하나 → (숫자, 글, 다시 고름). `samples` = 측점 원지반 샘플(조각 검산)."""
     design = design if isinstance(design, dict) else {}
     kind = source.get("src")
+    pieces = source.get("pieces")
+    if kind in ("length", "area") and isinstance(pieces, list):
+        lines = pick_lines(design, samples)
+        paths = [piece_path(piece, lines) for piece in pieces]
+        valid = [path for path in paths if path is not None]
+        if not valid or len(valid) != len(paths):
+            return None, None, True
+        number = sum(map(path_length, valid)) if kind == "length" else ring_area(valid)
+        return number, None, number is None
     if kind == "area":
         return _num(design.get(_AREA_DESIGN.get(str(source.get("key")), ""))), None, False
     if kind == "length":
@@ -89,9 +220,9 @@ def cell_value(
 
 
 def edited_cells(
-    design: dict[str, Any] | None,
+    design: dict[str, Any] | None, samples: Any = None
 ) -> tuple[dict[str, float | None], dict[str, str], list[str]]:
-    """patch 칸 출처 → (숫자 칸, 글 칸, 다시 고를 칸). 글은 더한 칸만."""
+    """patch 칸 출처 → (숫자 칸, 글 칸, 다시 고를 칸). 글은 더한 칸만 · `samples` = 원지반."""
     values: dict[str, float | None] = {}
     texts: dict[str, str] = {}
     repick: list[str] = []
@@ -99,7 +230,7 @@ def edited_cells(
     for key, source in (cells if isinstance(cells, dict) else {}).items():
         if not isinstance(source, dict):
             continue
-        number, text, again = cell_value(source, design)
+        number, text, again = cell_value(source, design, samples)
         if text is not None:
             if key[:2] in ("r:", "c:"):
                 texts[key] = text
diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support.py b/B07_DesignDetail/B07_DesignDetail_Router_Support.py
index b63a43981..a351e69c7 100644
--- a/B07_DesignDetail/B07_DesignDetail_Router_Support.py
+++ b/B07_DesignDetail/B07_DesignDetail_Router_Support.py
@@ -18,6 +18,7 @@ from B05_Profile.B05_Profile_Engine_Sections import (
 from B06_Section.B06_Section_Engine_Design import compute_cross_design, curve_widening_args
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad import (
     DRAWING_FORMAT,
+    GROUND_LAYER_ID,
     build_cross_drawing,
     infer_station_interval,
     station_no_label,
@@ -32,6 +33,7 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Cad_MassHaul import build_mass_hau
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_PlanKinds import build_plan_kind_drawing
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import (
     CROSS_SHEET_ID,
+    STATION_LAYER_PREFIX,
     build_cross_sheet,
     plan_cross_sheets,
 )
@@ -313,7 +315,7 @@ def _quantity_table(
     for key in QUANTITY_VALUE_KEYS:
         table.setdefault(key, num(quantities.get(key)))
     # [상세] 표 손질(179-4) — 고른 칸 · 더한 칸을 서버가 다시 셈(모달 · B07 도면 한 벌)
-    table.update(edited_cells(design)[0])
+    table.update(edited_cells(design, source.get("samples"))[0])
     return table
 
 
@@ -462,12 +464,22 @@ def _read_drawing(
             else:
                 kind = "longitudinal" if _LONG_ID.fullmatch(drawing_id) else "cross"
             label = str(manifest_entry.get("label") or drawing_id)
+            layers = [layer for layer in saved.get("layers") or [] if isinstance(layer, dict)]
+            if kind == "cross":
+                # 180-1 앞 확정본 = 원지반 층 잠금째 저장 — 열 때 풂(212-1)
+                for layer in layers:
+                    if layer.get("id") == GROUND_LAYER_ID:
+                        layer["isLocked"] = False
             if kind == "cross" and manifest_entry.get("layout") != CROSS_SHEET_LAYOUT:
                 saved["stale_layout"] = True  # 화면이 [수정] → 새 배치로 다시 만들기를 안내
             elif kind == "cross" and drawing_id.startswith("cross_s"):
                 scale = read_cross_layout(project_root)["table_scale"]
                 if manifest_entry.get("table_scale", 1.0) != scale:
                     saved["stale_scale"] = True  # 옛 배율로 확정한 장 — 그대로 두고 안내(180-2)
+                elif not any(
+                    str(layer.get("id")).startswith(STATION_LAYER_PREFIX) for layer in layers
+                ):
+                    saved["stale_layers"] = True  # 측점 층 앞 확정본 — [수정] 때 측점 층(212-2)
             stored_table = manifest_entry.get("quantity_table")
             table = stored_table if kind == "cross" and isinstance(stored_table, dict) else None
             return kind, label, saved, True, table
diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Cad_Structures.ts b/B07_DesignDetail/B07_DesignDetail_UI_Cad_Structures.ts
index f0e55d6ba..c4e446c65 100644
--- a/B07_DesignDetail/B07_DesignDetail_UI_Cad_Structures.ts
+++ b/B07_DesignDetail/B07_DesignDetail_UI_Cad_Structures.ts
@@ -34,6 +34,16 @@ export interface CrossPlacement {
   frame?: number[];
   /** 측점 한 벌 묶음(180-1) — 덧그림도 같은 묶음으로 함께 골라짐. */
   group_id?: string;
+  /** 측점 도면층(212-2) — 덧그림도 그 층에. */
+  layer_id?: string;
+  /** 갈아 끼울 서버 설계선 id(212-2) — 측점 층이면 층으로는 못 가림. */
+  design_ids?: string[];
+}
+
+/** 개체(자식 선까지)를 측점 층으로(212-2). */
+function moveToLayer(entity: Entity, layerId: string): void {
+  entity.layerId = layerId;
+  for (const child of (entity.children as Entity[] | undefined) ?? []) moveToLayer(child, layerId);
 }
 
 /** 측점과 도면 배치를 같은 자리로 볼 허용 오차(m). 정본이 누가거리를 0.01m로 끊어 쓴다. */
@@ -62,6 +72,7 @@ export async function appendStructureEntities(
   let added = 0;
   const fresh: Entity[] = [];
   const replaced: number[][] = [];
+  const designIds = new Set<string>();
   for (const placement of placements) {
     const section = sections.find(
       (item) => Math.abs(item.chainage_m - placement.chainage_m) <= CHAINAGE_TOLERANCE_M,
@@ -81,6 +92,8 @@ export async function appendStructureEntities(
     }
     if (!entities.length) continue;
     if (placement.group_id) for (const entity of entities) entity.groupId = placement.group_id;
+    if (placement.layer_id) for (const entity of entities) moveToLayer(entity, placement.layer_id);
+    for (const id of placement.design_ids ?? []) designIds.add(id);
     // 이 블록 설계선은 우리가 다시 그렸다 — 서버가 낸 트림 전 설계선은 걷어낸다.
     replaced.push(frame);
     fresh.push(...entities);
@@ -89,7 +102,7 @@ export async function appendStructureEntities(
   if (replaced.length) {
     // 걷어내기는 새 엔티티를 넣기 **전에** 한다 — 뒤에 하면 우리 것까지 같이 지운다.
     drawing.entities = drawing.entities.filter((entity) => {
-      if (entity.layerId !== DESIGN_LAYER_ID) return true;
+      if (entity.layerId !== DESIGN_LAYER_ID && !designIds.has(entity.id as string)) return true;
       const box = entityBox(entity);
       if (!box) return true;
       return !replaced.some(
diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Page.ts b/B07_DesignDetail/B07_DesignDetail_UI_Page.ts
index 22499e06f..4ee7d0a34 100644
--- a/B07_DesignDetail/B07_DesignDetail_UI_Page.ts
+++ b/B07_DesignDetail/B07_DesignDetail_UI_Page.ts
@@ -365,6 +365,11 @@ export async function renderB07DesignDetail(root: HTMLElement): Promise<void> {
           "옛 표 배율로 확정된 장입니다. [수정]을 누르면 지금 배율로 다시 만듭니다.",
           "info",
         );
+      } else if (response.drawing.stale_layers) {
+        showToast(
+          "측점 도면층 앞에 확정된 장입니다. [수정]을 누르면 측점마다 층(횡단 No.)으로 다시 만듭니다.",
+          "info",
+        );
       }
     } catch (error) {
       cad.fail(error instanceof Error ? error.message : "CAD 도면을 불러오지 못했습니다.");
diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts
index 0f214f7c5..68426a2fa 100644
--- a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts
+++ b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts
@@ -185,8 +185,9 @@ export interface CrossLayoutExtras {
 }
 
 /**
- * 횡단 장 배치 칸(140-3 · 153-1) — 「배치 열 [4] 행 [4] [이 장] [모든 장]」 + 「표 배율 [1] [적용]」.
- * `onApply` 가 없으면(장이 아닌 도면) [이 장]을 끔.
+ * 횡단 장 배치 칸(140-3 · 153-1) — 줄마다 한 일(212-3):
+ * 「배치 열 [4] 행 [4]」 · 「[이 장] [모든 장]」 · 「표 배율 [1] [배율 적용]」 · (부르는 쪽이 붙이는 [안내선 숨기기]).
+ * 단추 · 숫자 칸 = 줄 위 작은 단추 한 규격(`--btn-bar-*`) · `onApply` 가 없으면(장이 아닌 도면) [이 장]을 끔.
  */
 export function buildCrossLayoutControls(
   grid: [number, number],
@@ -196,6 +197,12 @@ export function buildCrossLayoutControls(
 ): HTMLElement {
   const box = document.createElement("div");
   box.className = "b07-cross-layout";
+  const row = (...items: HTMLElement[]): HTMLElement => {
+    const line = document.createElement("div");
+    line.className = "b07-cross-layout__row";
+    line.append(...items);
+    return line;
+  };
   const number = (value: number, label: string) =>
     createInputField({
       label,
@@ -227,10 +234,11 @@ export function buildCrossLayoutControls(
     return button;
   };
   box.append(
-    cols.root,
-    rows.root,
-    action("이 장", "이 장만 이 배치로", onApply),
-    action("모든 장", "모든 장을 이 배치로(장마다 값 지움)", onAllDefault),
+    row(cols.root, rows.root),
+    row(
+      action("이 장", "이 장만 이 배치로", onApply),
+      action("모든 장", "모든 장을 이 배치로(장마다 값 지움)", onAllDefault),
+    ),
   );
   if (extras.scale) {
     const { onApply: applyScale } = extras.scale;
@@ -255,7 +263,7 @@ export function buildCrossLayoutControls(
       },
     });
     button.title = "모든 장의 표 · 표 위 글 크기(기본 1)";
-    box.append(scale.root, button);
+    box.append(row(scale.root, button));
   }
   return box;
 }
diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Style.css b/B07_DesignDetail/B07_DesignDetail_UI_Style.css
index e99f64b41..71c501fb3 100644
--- a/B07_DesignDetail/B07_DesignDetail_UI_Style.css
+++ b/B07_DesignDetail/B07_DesignDetail_UI_Style.css
@@ -225,8 +225,9 @@
   color: var(--color-text-muted);
 }
 
-/* 횡단 장 배치(153-1) — 횡단도 묶음 맨 아래 전체 폭: 배치 열 [4] 행 [4] [이 장] [모든 장].
-   좌측이 182px 까지 줄어드니 줄바꿈 허용 · 공용 칸의 오류 자리는 접음. */
+/* 횡단 장 배치(153-1 · 212-3) — 횡단도 묶음 맨 아래 전체 폭 · 한 줄에 한 일:
+   배치 열 · 행 / [이 장] [모든 장] / 표 배율 [배율 적용] / [안내선 숨기기].
+   단추 · 숫자 칸 = 줄 위 작은 단추 한 규격(`--btn-bar-*` · 높이 16) · 한 줄 안 같은 너비 · 오류 자리는 접음. */
 .b07-cross-layout-slot {
   grid-column: 1 / -1;
 }
@@ -237,25 +238,45 @@
 
 .b07-cross-layout {
   display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: var(--spacing-4) var(--spacing-8);
+  flex-direction: column;
+  gap: var(--spacing-4);
 }
 
-.b07-cross-layout > .ui-field {
+.b07-cross-layout__row {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-8);
+}
+
+.b07-cross-layout__row > * {
+  flex: 1 1 0;
+  min-width: 0;
+}
+
+.b07-cross-layout .ui-field {
   display: flex;
   flex-direction: row;
   align-items: center;
   gap: var(--spacing-4);
 }
 
+.b07-cross-layout .ui-btn,
+.b07-cross-layout .ui-field .ui-input {
+  height: auto;
+  padding: var(--btn-bar-padding);
+  font-size: var(--btn-bar-font-size);
+  line-height: 1;
+}
+
 .b07-cross-layout .ui-field__label {
   margin: 0;
+  font-size: var(--btn-bar-font-size);
   white-space: nowrap;
 }
 
-.b07-cross-layout .ui-input {
-  width: 48px;
+.b07-cross-layout .ui-field .ui-input {
+  width: 100%;
+  min-width: 0;
 }
 
 .b07-cross-layout .ui-field__error {
diff --git a/B07_DesignDetail/openwebcad/src/components/ViewControls.tsx b/B07_DesignDetail/openwebcad/src/components/ViewControls.tsx
index 6b0b707ae..c5c16e0c2 100644
--- a/B07_DesignDetail/openwebcad/src/components/ViewControls.tsx
+++ b/B07_DesignDetail/openwebcad/src/components/ViewControls.tsx
@@ -1,13 +1,30 @@
-/** 화면 우하단 탐색 막대 (줌 표시·전체 보기) */
+/** 화면 우하단 탐색 막대 (줌 표시·전체 보기) — 제목줄이 없는 화면(M02)은 되돌리기 · 다시 하기도 */
 import type { FC } from 'react';
 import { runCommandInput } from '../commands/run-command';
-import { getScreenCanvasDrawController } from '../state';
+import {
+	getScreenCanvasDrawController,
+	isDrawingReadOnly,
+	isHostSave,
+	isViewOnly,
+} from '../state';
 
 export const ViewControls: FC = () => {
 	const zoom = getScreenCanvasDrawController()?.getScreenScale() ?? 1;
+	// 제목줄(빠른 막대)이 없는 M02 양식 · 구조물 카드 — 고칠 수 있을 때만
+	const showUndo = isHostSave() && !isViewOnly() && !isDrawingReadOnly();
 
 	return (
 		<div className="cad-view-controls controls">
+			{showUndo && (
+				<>
+					<button type="button" onClick={() => runCommandInput('UNDO')} title="실행 취소 (Ctrl+Z)">
+						↶
+					</button>
+					<button type="button" onClick={() => runCommandInput('REDO')} title="다시 실행 (Ctrl+Y)">
+						↷
+					</button>
+				</>
+			)}
 			<button
 				type="button"
 				className="cad-view-controls__fit"
diff --git a/B07_DesignDetail/openwebcad/src/inputController/input-controller.ts b/B07_DesignDetail/openwebcad/src/inputController/input-controller.ts
index bc2957016..87cbce18c 100644
--- a/B07_DesignDetail/openwebcad/src/inputController/input-controller.ts
+++ b/B07_DesignDetail/openwebcad/src/inputController/input-controller.ts
@@ -60,6 +60,7 @@ import {
 	isPlainSpace,
 } from './ime-sink.ts';
 import { drawInputField } from './input-field-draw.ts';
+import { ctrlShortcut } from './input-shortcut.ts';
 import { wheelZoom } from './input-wheel.ts';
 import {
 	ABSOLUTE_POINT_REGEXP,
@@ -339,7 +340,9 @@ export class InputController {
 		if (target !== this.ime.element && target?.closest('input, textarea, select')) {
 			return;
 		}
-		if (isImeKey(evt)) return; // 한글 조합 중 — 단축키가 먹지 않게 IME 에 넘김
+		const shortcut = ctrlShortcut(evt);
+		// 한글 조합 중 — 단축키가 먹지 않게 IME 에 넘김(Ctrl 단축키는 조합 중에도 먹음)
+		if (isImeKey(evt) && !shortcut) return;
 		console.log(`key pressed: ${evt.key}`);
 		if (evt.key === 'F12') {
 			// F12 => open developer tools
@@ -386,19 +389,16 @@ export class InputController {
 		}
 		evt.preventDefault();
 		evt.stopPropagation();
-		if (evt.ctrlKey && !evt.shiftKey && evt.key === 'z') {
+		if (shortcut === 'undo') {
 			// User wants to undo the last action
 			this.handleUndo(evt);
-		} else if (evt.ctrlKey && evt.shiftKey && evt.key === 'z') {
+		} else if (shortcut === 'redo') {
 			// User wants to redo the last action
 			this.handleRedo(evt);
-		} else if (evt.ctrlKey && evt.key === 'y') {
-			// User wants to redo the last action
-			this.handleRedo(evt);
-		} else if (evt.ctrlKey && evt.key === 's') {
+		} else if (shortcut === 'save') {
 			// 부모 페이지가 저장을 맡은 화면(M02 양식)만 — B07 은 예전처럼 아무 일 없음
 			if (isHostSave()) requestHostSave();
-		} else if (evt.ctrlKey && evt.key === 'a') {
+		} else if (shortcut === 'selectAll') {
 			// User wants to select everything
 			setSelectedEntityIds(getPickableEntities().map((entity) => entity.id));
 		} else if (evt.key === 'Backspace') {
diff --git a/B07_DesignDetail/openwebcad/src/inputController/input-shortcut.ts b/B07_DesignDetail/openwebcad/src/inputController/input-shortcut.ts
new file mode 100644
index 000000000..aad585a8c
--- /dev/null
+++ b/B07_DesignDetail/openwebcad/src/inputController/input-shortcut.ts
@@ -0,0 +1,10 @@
+/**
+ * Ctrl 단축키 판정 — 공용 `A00_Common/key_shortcut.ts`(214-2)를 그대로 내보냄.
+ * 한글 자판은 `key` 가 「ㅋ」·「ㅛ」로 와 글자로는 안 맞아 자판 자리(`code`)로 본다.
+ */
+export {
+	ctrlShortcut,
+	isCtrlKey,
+	keyLetter,
+	type CtrlShortcut,
+} from '../../../../A00_Common/key_shortcut';
diff --git a/B07_DesignDetail/openwebcad/tsconfig.app.json b/B07_DesignDetail/openwebcad/tsconfig.app.json
index 26a85a544..5ce3e3e8e 100644
--- a/B07_DesignDetail/openwebcad/tsconfig.app.json
+++ b/B07_DesignDetail/openwebcad/tsconfig.app.json
@@ -25,6 +25,6 @@
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true
   },
-  "include": ["src"],
+  "include": ["src", "../../A00_Common/key_shortcut.ts"],
   "exclude": ["node_modules"]
 }
diff --git a/B08_Quantity/B08_Quantity_Router_Summary.py b/B08_Quantity/B08_Quantity_Router_Summary.py
index 3ac853296..104bcc4ac 100644
--- a/B08_Quantity/B08_Quantity_Router_Summary.py
+++ b/B08_Quantity/B08_Quantity_Router_Summary.py
@@ -187,11 +187,13 @@ def _revets(
     sides: list[tuple[str, str | None]],
     empty_height: float | None,
     names: dict[str, str],
+    inlet_empty_height: float | None = None,
 ) -> None:
     """흙막이 — 유입 · 유출(흙막이일 때 · `sides`) + 흙막이 n(container_rows 가 선 단까지만 냄).
 
     저장 키 = 필수는 `{쪽}_revet_{칸}_m` · 선택 흙막이는 `soil_add_{n}_{칸}`(명세 인스턴스 키) ·
-    빈 높이 = `empty_height`(None 이면 「미입력」 열) · 머리 글은 관 정의 이름(공용 열).
+    빈 높이 = `empty_height`(None 이면 「미입력」 열 · 관 유입 쪽만 `inlet_empty_height` · 211-1) ·
+    머리 글은 관 정의 이름(공용 열).
     """
     sources = [(f"{side}_revet_", "_m", side, combo) for side, combo in sides]
     sources += [
@@ -203,7 +205,9 @@ def _revets(
         form = str(options.get(f"{head}form") or "")
         height = _num(options.get(f"{head}height{unit}"))
         if height is None:
-            height = empty_height
+            height = (
+                inlet_empty_height if container == "inlet" and inlet_empty_height else empty_height
+            )
         height_text = fill._label("height_m", height)
         sheet.add(
             at,
@@ -588,7 +592,8 @@ def pipe_summary(
         )
         wall_options = {**options, **moved}
         wall = pipe_wall_min_height_m(diameter / 1000) if diameter else None
-        _revets(sheet, at, wall_options, links, sources, wall, names)
+        wall_in = pipe_wall_min_height_m(diameter / 1000, "inlet") if diameter else None
+        _revets(sheet, at, wall_options, links, sources, wall, names, wall_in)
         _chutes(sheet, at, options, links, names)
 
     out = sheet.result()
diff --git a/B08_Quantity/B08_Quantity_UI_Earthwork.ts b/B08_Quantity/B08_Quantity_UI_Earthwork.ts
index da26b1d54..f8c318187 100644
--- a/B08_Quantity/B08_Quantity_UI_Earthwork.ts
+++ b/B08_Quantity/B08_Quantity_UI_Earthwork.ts
@@ -152,13 +152,13 @@ export function note(text: string): HTMLElement {
   return p;
 }
 
-/** 표 한 장 — 공용 컨테이너(카드) 안에 설명 · 공용 표 · 아래 줄 */
+/** 표 한 장 — 공용 컨테이너(카드) 안에 공용 표 · 아래 줄 · 맨 아래 안내 · 경고 줄(202-1) */
 export function tableCard(
   info: HTMLElement[],
   table: HTMLElement,
   after: HTMLElement[] = [],
 ): HTMLElement {
-  return createCard({ body: [...info, table, ...after] });
+  return createCard({ body: [table, ...after, ...info] });
 }
 
 function stationRow(row: EarthworkRow, first: boolean, interval: number): DataRow {
diff --git a/B08_Quantity/B08_Quantity_UI_Earthwork_Sheets.ts b/B08_Quantity/B08_Quantity_UI_Earthwork_Sheets.ts
index 420100cc8..e7acf989c 100644
--- a/B08_Quantity/B08_Quantity_UI_Earthwork_Sheets.ts
+++ b/B08_Quantity/B08_Quantity_UI_Earthwork_Sheets.ts
@@ -40,6 +40,7 @@ export function renderEarthworkSummary(host: HTMLElement, table: EarthworkTable)
       note: row.note || " ",
     })),
     frozen: 1,
+    mergeSame: ["group", "spec"], // 201-1 같은 구분 · 규격 이어지면 세로 병합(빈칸은 안 합침)
     caption: "토공집계표",
     fillViewport: true,
   });
diff --git a/B08_Quantity/B08_Quantity_UI_Material.ts b/B08_Quantity/B08_Quantity_UI_Material.ts
index 5316e7f84..53d2223ed 100644
--- a/B08_Quantity/B08_Quantity_UI_Material.ts
+++ b/B08_Quantity/B08_Quantity_UI_Material.ts
@@ -109,6 +109,8 @@ interface Table {
   editable: (index: number, key: string) => boolean;
   /** 고친 칸 → 사용자 값 자리 [표, 줄 키, 칸 키] */
   target: (index: number, key: string) => [Record<string, Cells> | Cells, string, string | null];
+  /** 같은 값 세로 병합 열(201-1 · 공용 표 mergeSame) */
+  mergeSame?: string[];
 }
 
 function quantityTable(s: MaterialSheets, o: MaterialOverrides): Table {
@@ -218,10 +220,10 @@ function concreteWhy(s: MaterialSheets, source: SummarySource): string {
 function concreteTable(s: MaterialSheets, o: MaterialOverrides): Table {
   const { rows, total } = s.concrete;
   const keep = rows.map((_row, i) => i); // 5줄 늘 보임(163-5) — 수량 없으면 빈칸 · 배합은 늘 고침
-  const rowsOut: DataRow[] = keep.map((at, i) => {
+  const rowsOut: DataRow[] = keep.map((at) => {
     const row = rows[at];
     const out: DataRow = {
-      name: i > 0 && rows[keep[i - 1]].name === row.name ? "" : row.name,
+      name: row.name, // 위 줄과 같으면 세로 병합(201-1)
       spec: row.spec,
       qty: row.qty,
     };
@@ -256,6 +258,7 @@ function concreteTable(s: MaterialSheets, o: MaterialOverrides): Table {
     rows: rowsOut,
     total: totalRow,
     frozen: 2,
+    mergeSame: ["name"],
     editable: (_i, key) => key.startsWith("per:"),
     target: (i, key) => [o.mix, rows[keep[i]].key, key.slice(4)],
   };
@@ -275,10 +278,10 @@ function totalTable(s: MaterialSheets, o: MaterialOverrides): Table {
       numberColumn({ key: "amount", label: "합계", width: 96 }),
       { key: "note", label: "비고", width: 96 },
     ],
-    rows: keep.map((at, i) => {
+    rows: keep.map((at) => {
       const row = rows[at];
       return {
-        group: i > 0 && rows[keep[i - 1]].group === row.group ? "" : row.group,
+        group: row.group, // 위 줄과 같으면 세로 병합(201-1)
         spec: row.spec,
         unit: row.unit,
         qty: row.qty,
@@ -295,6 +298,7 @@ function totalTable(s: MaterialSheets, o: MaterialOverrides): Table {
     }),
     total: null,
     frozen: 2,
+    mergeSame: ["group"],
     editable: (i, key) =>
       key === "surcharge" && !rows[keep[i]].panel && rows[keep[i]].key !== DEDUCT_KEY,
     target: (i) => [o.surcharge, rows[keep[i]].key, null],
@@ -356,7 +360,7 @@ export async function renderMaterialSheet(
   const concreteNote = note(""); // 콘크리트 전용 빈 까닭(163-5) — 조작마다 다시
   concreteNote.dataset.b08MaterialConcreteWhy = "";
   if (sheet === "concrete") notes.append(concreteNote);
-  toolbar.append(notes, save);
+  toolbar.append(save);
 
   let built = BUILD[sheet](sheets, overrides);
   const table = createDataTable({
@@ -364,6 +368,7 @@ export async function renderMaterialSheet(
     rows: built.rows,
     total: built.total,
     frozen: built.frozen,
+    mergeSame: built.mergeSame,
     empty: "",
     caption: BASIS,
     fillViewport: true,
@@ -395,7 +400,7 @@ export async function renderMaterialSheet(
     concreteNote.hidden = !concreteNote.textContent;
   };
   redraw();
-  host.replaceChildren(createCard({ body: [toolbar, table.root, excel] }));
+  host.replaceChildren(createCard({ body: [toolbar, table.root, excel, notes] })); // 202-1 안내 · 경고 = 맨 아래
   onOptionsChange(host, () => {
     sheets = calc();
     redraw();
diff --git a/B08_Quantity/B08_Quantity_UI_Page.css b/B08_Quantity/B08_Quantity_UI_Page.css
index f1c338629..cf2275cd9 100644
--- a/B08_Quantity/B08_Quantity_UI_Page.css
+++ b/B08_Quantity/B08_Quantity_UI_Page.css
@@ -28,7 +28,7 @@
 .b08-material__toolbar {
   display: flex;
   align-items: flex-start;
-  justify-content: space-between;
+  justify-content: flex-end;
   gap: var(--spacing-16);
   margin-bottom: var(--spacing-8);
 }
diff --git a/B08_Quantity/B08_Quantity_UI_Summary.ts b/B08_Quantity/B08_Quantity_UI_Summary.ts
index b54932b76..ba9a28b1e 100644
--- a/B08_Quantity/B08_Quantity_UI_Summary.ts
+++ b/B08_Quantity/B08_Quantity_UI_Summary.ts
@@ -281,8 +281,7 @@ export async function renderStructureSummary(host: HTMLElement, projectId: strin
           )
         : note(L("B08_Quantity_Summary_NoStation"));
     let table = draw();
-    parts.push(table);
-    host.replaceChildren(createCard({ body: parts })); // 공용 카드 안(토공 표와 같은 꼴 · 143-3)
+    host.replaceChildren(createCard({ body: [table, ...parts] })); // 공용 카드 안(토공 표와 같은 꼴 · 143-3) · 안내 · 경고 = 표 아래(202-1)
     onOptionsChange(host, () => {
       const next = draw();
       table.replaceWith(next);
diff --git a/B09_Estimation/B09_Estimation_Bill_Library.py b/B09_Estimation/B09_Estimation_Bill_Library.py
new file mode 100644
index 000000000..b1c1a16c6
--- /dev/null
+++ b/B09_Estimation/B09_Estimation_Bill_Library.py
@@ -0,0 +1,134 @@
+"""B09 설계내역서 연결 — 서고 구조물조합 · 일위대가 사전조합 → 프로젝트 사본(PLAN 204-2).
+
+자리 = 프로젝트 `B09_Estimation/v1/library/{폴더}/` · 폴더 = `{종류}@{층}@{주인}@{키}`
+(주인 `/` → `-` · 마스터 `-`) — 같은 것을 다시 고르면 새로 안 들여오고 있는 사본(같은 호표):
+    combo     구조물조합 = B08 구조물 사본과 한 꼴(`M02_Item_Snapshot.build_snapshot` — 집계 ·
+              도면 · 면적 · 일위대가 · 단가 · 입력값 · 고른자재 첫 값)
+    precombo  사전조합 = `일위대가.json` {줄: {담은로직: [{참조, 수량: {손: 1}}]}, 참조사본} ·
+              `단가.json`(`M02_Item_Source.price_bundle` — 사본 단가 묶음 한 벌)
+사본 = 원본이 바뀌거나 지워져도 그대로(굳힘) ·
+대가 블록 = `Labor_Source.daega_inputs`(`libs` {폴더: 블록 id}) ·
+단가 수요 = `Linked.linked_resource_keys` · 줄 연결 = {tab: dg, key: 블록 id, lib: 폴더} ·
+[저장] 때 줄이 안 쓰는 사본은 지움(`prune`) · 층 읽기 권한 = 부르는 쪽(`M02_Layer_Access.grant`).
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+from pathlib import Path
+from typing import Any
+
+from B09_Estimation.B09_Estimation_Store import folder as store_folder
+from common_util.common_util_json import atomic_write_json
+from M02_MasterTemplete import M02_Labor_Ref as refs
+from M02_MasterTemplete.M02_Item_Snapshot import MANIFEST_NAME, build_snapshot, now_text, origin_of
+from M02_MasterTemplete.M02_Item_Source import (
+    LABOR_FILE,
+    PRICE_FILE,
+    item_name,
+    labor_doc_rows,
+    price_bundle,
+    read_json,
+)
+
+LIBRARY = "library"
+KINDS = ("combo", "precombo")
+#: 폴더 이름 — 종류 · 층 · 주인 · 키(영문 · 숫자 · `-` `_`)
+NAME = re.compile(r"^(combo|precombo)@(system|company|personal)@[0-9-]+@[A-Za-z0-9_-]{1,40}$")
+
+
+def library_dir(project_root: str | Path) -> Path:
+    return store_folder(project_root) / LIBRARY
+
+
+def folder_name(kind: str, layer: str, owner: str | None, key: str) -> str:
+    """고른 서고 것 → 사본 폴더 이름 — 규칙 밖이면 ValueError."""
+    name = f"{kind}@{layer}@{(owner or '-').replace('/', '-')}@{key}"
+    if not NAME.match(name):
+        raise ValueError(f"서고 항목 모양이 틀림 「{name}」")
+    return name
+
+
+def _precombo_files(layer: str, owner: str | None, key: str) -> dict[str, Any]:
+    ref = {"층": layer, "주인": owner, "키": key}
+    doc = refs.read_ref(ref)
+    if doc is None or doc.get("종류") != refs.TITLE["precombo"]:
+        raise LookupError(f"사전조합 {key} 이 {layer} 층에 없음")
+    line = {"참조": ref, "수량": {"손": 1}}
+    labor = labor_doc_rows({"이름": doc.get("이름"), "단위": doc.get("단위"), "담은로직": [line]})
+    return {
+        LABOR_FILE: labor,
+        PRICE_FILE: price_bundle(labor, refs.folder_of(layer, owner)),
+        "_원본": {"참조": ref, "name": doc.get("이름") or key, "단위": doc.get("단위") or ""},
+    }
+
+
+def import_copy(
+    project_root: str | Path,
+    kind: str,
+    layer: str,
+    owner: str | None,
+    key: str,
+    who: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """서고 것 하나를 프로젝트 사본으로 — `{폴더, 만듦}` · 이미 있으면 그대로(만듦 거짓) ·
+    원본이 없으면 LookupError · 모양이 틀리면 ValueError."""
+    if kind not in KINDS:
+        raise ValueError(f"서고 종류는 {', '.join(KINDS)} 중 하나")
+    name = folder_name(kind, layer, owner, key)
+    target = library_dir(project_root) / name
+    if isinstance(read_json(target / MANIFEST_NAME), dict):
+        return {"폴더": name, "만듦": False}
+    if kind == "combo":
+        item = {"layer": layer, "owner": owner, "key": key}
+        item["name"] = item_name(item)
+        files, origin = build_snapshot(item), origin_of(item)
+    else:
+        files = _precombo_files(layer, owner, key)
+        origin = files.pop("_원본")
+    if target.is_dir():  # 끊긴 쓰기(manifest 없음) 자리
+        shutil.rmtree(target)
+    target.mkdir(parents=True)
+    for file, content in files.items():
+        atomic_write_json(target / file, content)
+    stamp = now_text()
+    manifest = {"종류": kind, "원본": origin, "가져온날": stamp, "가져온이": who}
+    atomic_write_json(target / MANIFEST_NAME, manifest)  # 마지막 — 있으면 다 쓴 폴더
+    return {"폴더": name, "만듦": True}
+
+
+def copies(project_root: str | Path) -> list[tuple[Path, dict[str, Any]]]:
+    """다 쓴 사본 `(폴더, manifest)` — 폴더 이름 차례."""
+    base = library_dir(project_root)
+    out = []
+    for child in sorted(base.iterdir()) if base.is_dir() else []:
+        manifest = read_json(child / MANIFEST_NAME)
+        if child.is_dir() and NAME.match(child.name) and isinstance(manifest, dict):
+            out.append((child, manifest))
+    return out
+
+
+def used_folders(user: dict[str, Any]) -> set[str]:
+    """설계내역서 덮개 줄이 잇는 서고 사본 폴더."""
+    rows = ((user or {}).get("bill") or {}).get("rows") or []
+    return {
+        str(ref["lib"])
+        for row in rows
+        if isinstance(row, dict)
+        and isinstance(ref := row.get("ref"), dict)
+        and ref.get("tab") == "dg"
+        and ref.get("lib")
+    }
+
+
+def prune(project_root: str | Path, user: dict[str, Any]) -> list[str]:
+    """[저장] 뒤 — 줄이 안 잇는 사본 폴더를 지움(다시 고르면 새로 들여옴) · 지운 이름."""
+    keep = used_folders(user)
+    base = library_dir(project_root)
+    gone = []
+    for child in sorted(base.iterdir()) if base.is_dir() else []:
+        if child.is_dir() and NAME.match(child.name) and child.name not in keep:
+            shutil.rmtree(child)
+            gone.append(child.name)
+    return gone
diff --git a/B09_Estimation/B09_Estimation_Calc_Bill.py b/B09_Estimation/B09_Estimation_Calc_Bill.py
index c9f4db36e..30b69f9c4 100644
--- a/B09_Estimation/B09_Estimation_Calc_Bill.py
+++ b/B09_Estimation/B09_Estimation_Calc_Bill.py
@@ -2,7 +2,7 @@
 
 ⚠ 짝 = `B09_Estimation_Calc_Bill.ts`(같은 식 · 같은 차례 · 같은 끝수) — 한쪽을 고치면 다른 쪽도 ·
   거울 시험 `resources/tester/test_145_3_b09_bill.py` · `test_182_b09_bill_level.py`(레벨) ·
-  `test_184_2_b09_bill_free.py`(자유 편집).
+  `test_184_2_b09_bill_free.py`(자유 편집) · `test_204_1_b09_bill_drag.py`(묶음 자동).
 
 실무 엑셀 설계내역서 꼴 · 기본 공종 나무(초기값) = 엑셀 꼴(`SECTIONS` · 공구 안 나눔):
     1 토공사(1.1~1.6) · 2 구조물공(2.1~2.3) · 3 운반공 · 4 자재대 · 관급자재대(제외금액)
@@ -33,7 +33,9 @@
     `rows` 에 없고 `gone` 에도 없는 자동 줄(B08 새 열 · 대비표 새 표시) =
         기본 부모 끝 + 비고 「새 자동 줄」(기본 부모가 없으면 표 끝 맨 위) ·
         원천이 안 낸 키 = 안 보임 ·
-    부모 못 찾음 · 묶음 아님 · 돎 = 자동 줄 기본 부모 / 새 줄 맨 위 · `sec:G` = 맨 위 고정 ·
+    부모 못 찾음 · 자재 줄(`mat:`) · 돎 = 자동 줄 기본 부모 / 새 줄 맨 위 · `sec:G` = 맨 위 고정 ·
+    항목 줄에 자식이 생김 = 저절로 묶음(204 · 금액 = 자손 합 · 제 수량 · 연결은 덮개에 남음 —
+    자식이 다 빠지면 다시 항목) ·
     관급 자재 줄 = `sec:G` 밖 못 감(밖이면 `sec:G` 아래) · 깊이 5 넘음 = 레벨 4 조상 아래.
     옛 꼴(v 없음 · 166-2 · 182) = `qty{줄 키: 수}` 수량 덮개 + `rows[]` 손 줄(`section` ·
         `after` 앞 줄 뒤에 끼움 · `parent` = 같은 공종 손 묶음) — 그대로 읽음(화면 첫 손질 때 v2).
@@ -331,7 +333,7 @@ def _order_v2(bill: dict, titles: list[dict], items: list[dict], hands: list[tup
 
 
 def _tree(order: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """부모 바로잡기(없음 · 항목 · 돎 = 기본 부모 / 맨 위 · `sec:G` 맨 위 ·
+    """부모 바로잡기(없음 · 자재 줄 · 돎 = 기본 부모 / 맨 위 · `sec:G` 맨 위 ·
     관급 자재 줄 = `sec:G` 안) → 표 차례(부모 먼저 · 형제 = 저장 차례) · level · cost · section
     (깊이 5 넘음 = 레벨 4 조상 아래)."""
     by_key = {row["key"]: row for row in order}
@@ -353,7 +355,7 @@ def _tree(order: list[dict[str, Any]]) -> list[dict[str, Any]]:
         up = by_key.get(row.get("parent") or "")
         if row["key"] == "sec:G":
             row["parent"] = None
-        elif up is None or up["kind"] == "item" or up is row:
+        elif up is None or up["key"].startswith("mat:") or up is row:
             row["parent"] = row["_home"] if row["_home"] in by_key else None
     for row in order:
         if loops(row):
@@ -383,6 +385,11 @@ def _tree(order: list[dict[str, Any]]) -> list[dict[str, Any]]:
             row["section"] = chain[-1]["section"] if chain else None
         rows.append(row)
         stack.extend((kid, [*chain, row]) for kid in reversed(kids.get(row["key"], [])))
+    parents = {row["parent"] for row in rows}
+    for row in rows:  # 자식이 생긴 항목 = 저절로 묶음(204)
+        if row["kind"] == "item" and row["key"] in parents:
+            row.update({"kind": "group", "qty": None, "ref": None, "_gaps": []})
+            row.update({f"price_{p}": None for p in (*PARTS, "sum")})
     return rows
 
 
diff --git a/B09_Estimation/B09_Estimation_Calc_Bill.ts b/B09_Estimation/B09_Estimation_Calc_Bill.ts
index 249a23463..3a5702b8e 100644
--- a/B09_Estimation/B09_Estimation_Calc_Bill.ts
+++ b/B09_Estimation/B09_Estimation_Calc_Bill.ts
@@ -3,7 +3,8 @@
  * B09 설계내역서 셈(PLAN 145-3) — 화면 없음 · 저장 안 함 · import 는 짝 바탕 셈 하나(시험이 이어 붙임).
  *
  * ⚠ 짝 = `B09_Estimation_Calc_Bill.py`(같은 식 · 같은 차례 · 같은 끝수) — 한쪽을 고치면 다른 쪽도 ·
- *   거울 시험 `resources/tester/test_145_3_b09_bill.py` · `test_182_b09_bill_level.py`(레벨) · `test_184_2_b09_bill_free.py`(자유 편집).
+ *   거울 시험 `resources/tester/test_145_3_b09_bill.py` · `test_182_b09_bill_level.py`(레벨) · `test_184_2_b09_bill_free.py`(자유 편집) ·
+ *   `test_204_1_b09_bill_drag.py`(묶음 자동).
  *
  *   공종 나무 = 엑셀 꼴 고정(1 토공사 · 2 구조물공 · 3 운반공 · 4 자재대 · 관급자재대(제외금액)) · 공구 안 나눔
  *   항목 = 서버가 B08 수량으로 짠 줄 + 대비표 「별도」(4 자재대) · 「관급」(관급자재대) 자재 + 조달수수료
@@ -304,7 +305,8 @@ function orderV2(bill: Row, titles: Row[], items: Row[], hands: Hands): Row[] {
   return out;
 }
 
-/** 부모 바로잡기(없음 · 항목 · 돎 = 기본 부모 / 맨 위 · sec:G 맨 위 · 관급 자재 줄 = sec:G 안) →
+/** 부모 바로잡기(없음 · 자재 줄 · 돎 = 기본 부모 / 맨 위 · sec:G 맨 위 · 관급 자재 줄 = sec:G 안) →
+ *  자식이 생긴 항목 = 저절로 묶음(204 · 자식이 다 빠지면 다시 항목) →
  *  표 차례(부모 먼저 · 형제 = 저장 차례) · level · cost · section(깊이 5 넘음 = 레벨 4 조상 아래) */
 function tree(order: Row[]): Row[] {
   const byKey = new Map<string, Row>();
@@ -325,7 +327,7 @@ function tree(order: Row[]): Row[] {
   for (const row of order) {
     const up = byKey.get(row.parent ?? "");
     if (row.key === "sec:G") row.parent = null;
-    else if (!up || up.kind === "item" || up === row) row.parent = home(row);
+    else if (!up || up.key.startsWith("mat:") || up === row) row.parent = home(row);
   }
   for (const row of order) {
     if (!loops(row)) continue;
@@ -354,6 +356,13 @@ function tree(order: Row[]): Row[] {
     rows.push(row);
     for (const kid of [...(kids.get(row.key) || [])].reverse()) stack.push([kid, [...chain, row]]);
   }
+  const parents = new Set(rows.map((row) => row.parent));
+  for (const row of rows) {
+    // 자식이 생긴 항목 = 저절로 묶음(204)
+    if (row.kind !== "item" || !parents.has(row.key)) continue;
+    Object.assign(row, { kind: "group", qty: null, ref: null, _gaps: [] });
+    for (const p of [...PARTS, "sum"]) row[`price_${p}`] = null;
+  }
   return rows;
 }
 
diff --git a/B09_Estimation/B09_Estimation_Labor_Source.py b/B09_Estimation/B09_Estimation_Labor_Source.py
index cb49e0f09..578f7dc74 100644
--- a/B09_Estimation/B09_Estimation_Labor_Source.py
+++ b/B09_Estimation/B09_Estimation_Labor_Source.py
@@ -26,6 +26,7 @@ from decimal import Decimal
 from pathlib import Path
 from typing import Any
 
+from B09_Estimation import B09_Estimation_Bill_Library as library
 from B09_Estimation import B09_Estimation_Sangeun as sg
 from B09_Estimation import B09_Estimation_Sangeun_Text as st
 from M02_MasterTemplete import M02_Item_Prices as item_prices
@@ -282,6 +283,19 @@ class Builder:
             }
         )
 
+    def library(self, folder: Path, manifest: dict[str, Any]) -> str | None:
+        """설계내역서 서고 사본(204-2) — 구조물조합 = 조합 블록 · 사전조합 = 겹 대가 블록 그대로."""
+        if manifest.get("종류") != "precombo":
+            return self.combo(folder)
+        labor = read_json(folder / LABOR_FILE)
+        ref = (manifest.get("원본") or {}).get("참조")
+        copies = (labor or {}).get("참조사본") or {}
+        doc = copies.get(refs.ref_id(ref)) if isinstance(ref, dict) else None
+        if not isinstance(doc, dict):
+            return None
+        whole = item_prices.load_prices(read_json(folder / PRICE_FILE) or {})
+        return self.precombo(whole, ref, doc, copies, 1)
+
 
 def _material(whole: Any, mat: dict, qty: Any) -> dict[str, Any]:
     """자재 줄 — 조합 사용자 자재 · 사전조합 자재(175-2) 한 꼴 · 이름 · 규격 · 단위 = 사본 단가."""
@@ -327,9 +341,11 @@ def _plain(value: Any) -> Any:
 
 
 def daega_inputs(project_root: str | Path) -> dict[str, Any]:
-    """대가 셈 입력 — `{blocks: [...], owners: {구조물 id: 블록 id}}` · 사본 없으면 빈 것.
+    """대가 셈 입력 — `{blocks: [...], owners: {구조물 id: 블록 id}}` · 사본 없으면 빈 것 ·
+    설계내역서 서고 사본(204-2)이 있으면 `libs` {폴더: 블록 id}.
 
-    차례 = 조합(구조물 id 차례) → 사전조합 → 일위대가화(품셈 · 처음 본 차례) — 호표 번호 = 이 차례.
+    차례 = 조합(구조물 id 차례 → 서고 사본) → 사전조합 → 일위대가화(품셈 · 처음 본 차례) —
+    호표 번호 = 이 차례.
     """
     base = structures_dir(project_root)
     build = Builder()
@@ -343,6 +359,15 @@ def daega_inputs(project_root: str | Path) -> dict[str, Any]:
             bid = None  # 한 사본이 막혀도 나머지 블록은 셈 — 그 구조물은 없음
         if bid:
             owners[owner] = bid
+    libs: dict[str, str] = {}
+    for folder, manifest in library.copies(project_root):
+        try:
+            bid = build.library(folder, manifest)
+        except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
+            bid = None
+        if bid:
+            libs[folder.name] = bid
     order = {"조합": 0, "사전조합": 1, "품셈": 2}
     blocks = sorted(build.blocks.values(), key=lambda b: order[b["kind"]])
-    return _plain({"blocks": blocks, "owners": owners})
+    out = {"blocks": blocks, "owners": owners}
+    return _plain({**out, "libs": libs} if libs else out)
diff --git a/B09_Estimation/B09_Estimation_Linked.py b/B09_Estimation/B09_Estimation_Linked.py
index ff2427dd3..868e8e7e3 100644
--- a/B09_Estimation/B09_Estimation_Linked.py
+++ b/B09_Estimation/B09_Estimation_Linked.py
@@ -67,13 +67,19 @@ def used_keys(folder: Path) -> list[str]:
 
 
 def linked_resource_keys(project_root: str | Path) -> list[str]:
-    """연결된 사본 전부가 부른 자원 키 — 구조물 id 차례 · 겹침 없음."""
+    """연결된 사본 전부가 부른 자원 키 — 구조물 id 차례 → 설계내역서 서고 사본(204-2) ·
+    겹침 없음."""
+    from B09_Estimation.B09_Estimation_Bill_Library import copies
+
     base = structures_dir(project_root)
+    folders = [
+        base / linked["폴더"]
+        for _owner, linked in sorted(linked_snapshots(project_root).items())
+        if "일위대가" in linked.get("부분", [])
+    ]
     out: list[str] = []
-    for _owner, linked in sorted(linked_snapshots(project_root).items()):
-        if "일위대가" not in linked.get("부분", []):
-            continue
-        for key in used_keys(base / linked["폴더"]):
+    for folder in [*folders, *(f for f, _ in copies(project_root))]:
+        for key in used_keys(folder):
             if key not in out:
                 out.append(key)
     return out
diff --git a/B09_Estimation/B09_Estimation_Prices.py b/B09_Estimation/B09_Estimation_Prices.py
index 87badd217..e8dd8d916 100644
--- a/B09_Estimation/B09_Estimation_Prices.py
+++ b/B09_Estimation/B09_Estimation_Prices.py
@@ -15,6 +15,7 @@
 
 from __future__ import annotations
 
+import json
 from datetime import datetime
 from decimal import Decimal
 from typing import Any
@@ -197,6 +198,23 @@ def refresh_book(keys: list[str]) -> dict[str, Any]:
     }
 
 
+def book_stale(book: dict[str, Any] | None, keys: list[str]) -> str | None:
+    """203-1 [업데이트] 배지 — 지금 M01 로 새로 굳힌 책(`refresh_book`)과 견줌 · 다른 것 한 줄(같으면 None)."""
+    if book is None:
+        return "단가 아직 안 굳힘"
+    fresh = json.loads(json.dumps(refresh_book(keys), ensure_ascii=False))  # 저장 꼴(JSON)로 견줌
+    rows = book.get("rows") or {}
+    new = sum(key not in rows for key in fresh["rows"])
+    changed = sum(key in rows and rows[key] != row for key, row in fresh["rows"].items())
+    parts = [
+        f"새 단가 줄 {new}" if new else "",
+        f"M01 에서 바뀐 단가 {changed}" if changed else "",
+        "운전사 계수 바뀜" if book.get("driver_factor") != fresh["driver_factor"] else "",
+        "환율 바뀜" if book.get("fx") != fresh["fx"] else "",
+    ]
+    return " · ".join(p for p in parts if p) or None
+
+
 def extend_book(book: dict[str, Any] | None, keys: list[str]) -> dict[str, Any]:
     """[저장] — 책에 없는 새 줄만 더함(있는 줄 · 계수 · 환율은 안 바꿈) · 책이 없으면 새로 굳힘."""
     if book is None:
diff --git a/B09_Estimation/B09_Estimation_Router.py b/B09_Estimation/B09_Estimation_Router.py
index b4a7d7185..62ccb65e8 100644
--- a/B09_Estimation/B09_Estimation_Router.py
+++ b/B09_Estimation/B09_Estimation_Router.py
@@ -6,6 +6,10 @@
         [저장] — 사용자 값 · 책에 없는 새 단가 줄만 굳힘 → 서버가 정본으로 다시 셈
     POST /api/projects/{id}/estimation/prices
         [단가 갱신] — 수요 단가 전부를 지금 M01 값으로 새로 굳힘
+    POST /api/projects/{id}/estimation/library   {kind, layer, owner, key}
+        설계내역서 연결 고르기(204-2) — 서고 구조물조합 · 사전조합을 프로젝트 사본으로
+        (있으면 그대로) → {폴더, 만듦, key = 대가 블록 id, payload} ·
+        층 읽기 권한 = `M02_Layer_Access` · 줄 연결은 화면 캐시 → [저장] 때 안 쓰는 사본 지움(`Bill_Library.prune`)
 
 저장 자리 = 프로젝트 안 `B09_Estimation/v1/`(`B09_Estimation_Store`) ·
 단가 = `B09_Estimation_Prices` ·
@@ -20,11 +24,13 @@ from pathlib import Path
 from typing import Any
 from uuid import UUID
 
-from fastapi import APIRouter, Body
+from fastapi import APIRouter, Body, Depends, HTTPException
+from pydantic import BaseModel
 
 from B08_Quantity.B08_Quantity_Router_Earthwork import earthwork_table
 from B08_Quantity.B08_Quantity_Router_Hydro import _project_root
 from B08_Quantity.B08_Quantity_Router_Material import material_sheets
+from B09_Estimation import B09_Estimation_Bill_Library as library
 from B09_Estimation import B09_Estimation_Prices as prices
 from B09_Estimation import B09_Estimation_Sangeun as sangeun
 from B09_Estimation import B09_Estimation_Store as store
@@ -38,6 +44,9 @@ from B09_Estimation.B09_Estimation_Linked import linked_resource_keys
 from B09_Estimation.B09_Estimation_Rates import rate_candidates, rate_table
 from B09_Estimation.B09_Estimation_Router_Quotes import router as quotes_router
 from B09_Estimation.B09_Estimation_Summary import compute_summary, hopyo_lines, used_materials
+from common_util.common_util_auth import verify_session
+from M02_MasterTemplete import M02_Layer_Access as access
+from M02_MasterTemplete.M02_Item_Snapshot import importer
 
 router = APIRouter(prefix="/api/projects", tags=["B09 Estimation"])
 
@@ -121,6 +130,8 @@ async def payload(project_id: UUID, root: Path) -> dict[str, Any]:
         "inputs": inputs,
         "user": user,
         "book": {"made": book.get("made")} if book else None,
+        # 203-1 [업데이트] 배지 까닭(지금 M01 과 다른 것 한 줄 · 같으면 None)
+        "stale": await asyncio.to_thread(prices.book_stale, book, keys),
         "sheets": sheets,
         "rate_candidates": rate_candidates(),
         "rate_table": rate_table(),
@@ -139,7 +150,8 @@ async def estimation(project_id: UUID) -> dict[str, Any]:
 @router.put("/{project_id}/estimation")
 async def save_estimation(project_id: UUID, body: dict[str, Any] = Body(...)) -> dict[str, Any]:
     root = await _project_root(project_id)
-    await asyncio.to_thread(store.write_user, root, body.get("user"))
+    user = await asyncio.to_thread(store.write_user, root, body.get("user"))
+    await asyncio.to_thread(library.prune, root, user)  # 204-2 줄이 안 잇는 서고 사본
     keys = await _demand(root)
     book = await asyncio.to_thread(store.read_book, root)
     book = await asyncio.to_thread(prices.extend_book, book, keys)
@@ -156,5 +168,31 @@ async def refresh_prices(project_id: UUID) -> dict[str, Any]:
     return await payload(project_id, root)
 
 
+class LibraryBody(BaseModel):
+    kind: str
+    layer: str
+    owner: str | None = None
+    key: str
+
+
+@router.post("/{project_id}/estimation/library")
+async def import_library(
+    project_id: UUID, body: LibraryBody, session: dict[str, Any] = Depends(verify_session)
+) -> dict[str, Any]:
+    got = access.grant(session, body.layer, body.owner)  # 못 읽는 층 = 403 · 회사 없음 = 409
+    root = await _project_root(project_id)
+    try:
+        made = await asyncio.to_thread(
+            library.import_copy, root, body.kind, got.layer, got.owner, body.key, importer(session)
+        )
+    except LookupError as error:
+        raise HTTPException(status_code=404, detail=str(error)) from error
+    except ValueError as error:
+        raise HTTPException(status_code=400, detail=str(error)) from error
+    out = await payload(project_id, root)
+    key = ((out["inputs"].get("daega") or {}).get("libs") or {}).get(made["폴더"])
+    return {**made, "key": key, "payload": out}
+
+
 # 166-4 견적서 파일 길 — 같은 머리 · 같은 권한
 router.include_router(quotes_router)
diff --git a/B09_Estimation/B09_Estimation_Store.py b/B09_Estimation/B09_Estimation_Store.py
index da7557fbd..0f1c5862a 100644
--- a/B09_Estimation/B09_Estimation_Store.py
+++ b/B09_Estimation/B09_Estimation_Store.py
@@ -95,12 +95,14 @@ def _text(value: Any) -> str:
 
 
 def _clean_ref(ref: Any) -> dict[str, Any] | None:
-    """손 줄 연결 — dg · sg = 호표 키 · logic = M01 로직(입력값 · 켜쌓기율 · 고름)."""
+    """손 줄 연결 — dg · sg = 호표 키 · logic = M01 로직(입력값 · 켜쌓기율 · 고름) ·
+    dg `lib` = 서고 사본 폴더(204-2 · [저장] 때 안 쓰는 사본 지움)."""
     if not isinstance(ref, dict):
         return None
     tab = ref.get("tab")
     if tab in ("dg", "sg") and isinstance(ref.get("key"), str) and ref["key"]:
-        return {"tab": tab, "key": ref["key"]}
+        lib = ref.get("lib") if tab == "dg" else None
+        return {"tab": tab, "key": ref["key"], **({"lib": lib} if isinstance(lib, str) else {})}
     if tab == "logic" and isinstance(ref.get("code"), str) and ref["code"]:
         given = ref.get("given") if isinstance(ref.get("given"), dict) else {}
         picks = ref.get("picks") if isinstance(ref.get("picks"), dict) else None
diff --git a/B09_Estimation/B09_Estimation_UI_Check.ts b/B09_Estimation/B09_Estimation_UI_Check.ts
new file mode 100644
index 000000000..5bb00b5e9
--- /dev/null
+++ b/B09_Estimation/B09_Estimation_UI_Check.ts
@@ -0,0 +1,93 @@
+/* =============================================================================
+ * B09_Estimation_UI_Check.ts
+ * B09 좌측 「데이터 점검」 묶음(PLAN 203-1) — [업데이트] · 연결 점검(옛 「연결 점검」 탭 내용).
+ *
+ *   [업데이트] = 단가를 지금 M01 값으로 새로 굳힘 · 서버가 낡았다고 보면(`payload.stale` 까닭 한 줄)
+ *     단추에 점 배지(`is-pending`) · 굳힌 시각 · 까닭 = 공용 호버
+ *   연결 점검 = 「연결 없음」 줄 목록(누르면 그 탭 그 줄로 · 까닭 = 공용 호버) + 서버 알림 · M01 에 없는 키
+ * ========================================================================== */
+
+import { attachHoverInfo } from "@ui/ui_template_hover_info";
+import type { Row } from "./B09_Estimation_Calc_Base";
+import { tabName, type Link, type TabId } from "./B09_Estimation_UI_Tabs";
+
+export interface CheckItem {
+  link: Link;
+  tab: string;
+  name: string;
+  why: string;
+}
+
+/** 빠진 연결 줄 · 알림 글(서버 알림 + M01 에 없는 키) */
+export function checkItems(sheets: Row, payload: Row): { items: CheckItem[]; notes: string[] } {
+  const gaps: Row[] = sheets.gaps || [];
+  const items = gaps.map((g) => ({
+    link: { tab: g.tab as TabId, key: g.key },
+    tab: tabName(g.tab),
+    name: String(g.name ?? ""),
+    why: String(g.why ?? ""),
+  }));
+  const notes: string[] = [...(payload.notes || [])];
+  const missing: string[] = payload.inputs?.missing || [];
+  if (missing.length) notes.push(`M01 에 없는 키 ${missing.length} — ${missing.join(" · ")}`);
+  return { items, notes };
+}
+
+/** [업데이트] 호버 글 — 굳힌 시각 + 낡은 까닭 */
+export function refreshTip(payload: Row | null): string {
+  const made = payload?.book?.made;
+  const when = made ? `단가 굳힘 ${String(made).replace("T", " ")}` : "단가 아직 안 굳힘";
+  const stale = payload?.stale;
+  return `${when} · 누르면 지금 M01 값으로 새로 굳힘${stale ? ` · 업데이트 필요 — ${stale}` : ""}`;
+}
+
+export interface CheckPanel {
+  /** 묶음 안 연결 점검 자리 */
+  list: HTMLElement;
+  draw: (payload: Row, sheets: Row) => void;
+}
+
+export function createCheckPanel(refresh: HTMLElement, goto: (link: Link) => void): CheckPanel {
+  let payload: Row | null = null;
+  let items: CheckItem[] = [];
+  attachHoverInfo(refresh, () => refreshTip(payload));
+  const list = document.createElement("div");
+  list.className = "b09-check";
+  attachHoverInfo(list, (row) => items[Number(row.dataset.i)]?.why, "[data-i]");
+
+  const draw = (next: Row, sheets: Row): void => {
+    payload = next;
+    refresh.classList.toggle("is-pending", Boolean(next.stale));
+    const made = checkItems(sheets, next);
+    items = made.items;
+    const head = document.createElement("p");
+    head.className = "b09-check__head";
+    head.textContent = `연결 없음 ${items.length}곳`;
+    const rows = document.createElement("div");
+    rows.className = "ui-sidebar-list";
+    rows.append(
+      ...items.map((item, i) => {
+        const row = document.createElement("button");
+        row.type = "button";
+        row.className = "ui-sidebar-row";
+        row.dataset.i = String(i);
+        const name = document.createElement("span");
+        name.textContent = item.name;
+        const tab = document.createElement("span");
+        tab.className = "b09-check__tab";
+        tab.textContent = item.tab;
+        row.append(name, tab);
+        row.addEventListener("click", () => goto(item.link));
+        return row;
+      }),
+    );
+    const notes = made.notes.map((text) => {
+      const p = document.createElement("p");
+      p.className = "b09-check__note";
+      p.textContent = text;
+      return p;
+    });
+    list.replaceChildren(head, ...(items.length ? [rows] : []), ...notes);
+  };
+  return { list, draw };
+}
diff --git a/B09_Estimation/B09_Estimation_UI_Page.css b/B09_Estimation/B09_Estimation_UI_Page.css
index 9f9a4b97a..9e41af3dc 100644
--- a/B09_Estimation/B09_Estimation_UI_Page.css
+++ b/B09_Estimation/B09_Estimation_UI_Page.css
@@ -36,58 +36,63 @@
   overflow-wrap: anywhere;
 }
 
-/* 171-3 묶음 탭 머리 — 안내 글 + 보기 단추 */
-.b09-estimation__bar {
+/* 202-1 보조 탭 줄 오른쪽 도구(박스보기 · 가로 열 수) — 빈 보조 줄에서도 보임 · 단추 · 글 한 줄 */
+.b09-estimation__tools {
   display: flex;
-  align-items: flex-start;
-  justify-content: space-between;
+  flex: none;
+  flex-wrap: nowrap;
+  align-items: center;
   gap: var(--spacing-8);
+  margin-left: auto;
 }
 
-/* 185-2 보기 단추 글 한 줄 */
-.b09-estimation__bar .ui-btn {
+.b09-estimation__tools .ui-btn,
+.b09-estimation__tools .ui-group-cards__label {
   flex: none;
   white-space: nowrap;
 }
 
-/* 182 설계내역서 레벨 — 글자 크기(줄 높이 28px 고정 → 16px 까지) · 첫 칸 들여쓰기 1em × (레벨 − 1) */
-.b09-estimation .ui-data-table__table tbody tr.is-lv1 td {
-  font-size: var(--text-body);
+/* 202-1 안내 줄 = 표 · 카드 판 아래(묶음 탭은 한 줄 줄임표 · 전문 = 공용 호버) */
+.b09-estimation .ui-data-table + .ui-general-block__empty,
+.b09-estimation .ui-group-cards + .ui-general-block__empty {
+  margin: var(--spacing-8) 0 0;
 }
 
-.b09-estimation .ui-data-table__table tbody tr:is(.is-lv2, .is-lv3) td {
-  font-size: var(--text-body-sm);
-}
-
-.b09-estimation .ui-data-table__table tbody tr:is(.is-lv4, .is-lv5, .is-lv6) td {
-  font-size: 13px;
+.b09-estimation__line-hint {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: var(--text-caption);
 }
 
+/* 182 설계내역서 묶음 줄 굵게 · 레벨 들여쓰기 = 공용 표 level 옵션(201-1) */
 .b09-estimation .ui-data-table__table tbody tr.is-group td {
   font-weight: var(--font-weight-bold);
 }
 
-.b09-estimation .ui-data-table__table tbody tr.is-lv2 td:first-child {
-  padding-left: calc(var(--spacing-8) + 1em);
-}
-
-.b09-estimation .ui-data-table__table tbody tr.is-lv3 td:first-child {
-  padding-left: calc(var(--spacing-8) + 2em);
-}
-
-.b09-estimation .ui-data-table__table tbody tr.is-lv4 td:first-child {
-  padding-left: calc(var(--spacing-8) + 3em);
-}
-
-.b09-estimation .ui-data-table__table tbody tr:is(.is-lv5, .is-lv6) td:first-child {
-  padding-left: calc(var(--spacing-8) + 4em);
-}
-
 /* 166-2 설계내역서 손 줄 — 사용자가 더한 줄 표시(왼쪽 띠) */
 .b09-estimation .ui-data-table__table tbody tr.is-hand td:first-child {
   background-image: linear-gradient(to right, var(--color-primary) 3px, transparent 3px);
 }
 
+/* 200-2 설계내역서 글 칸 왼쪽 맞춤(수량만 오른쪽) */
+.b09-estimation [data-b09-table="bill"] .ui-data-table__input:not([data-k="qty"]) {
+  text-align: left;
+}
+
+/* 200-2 레벨 도구 줄 — 단추 넷 + 안내 한 줄 */
+.b09-estimation__level {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-8);
+}
+
+.b09-estimation__level .b09-estimation__hint {
+  margin: 0;
+}
+
 /* 181-2 표 보기 — 목록표에서 고른 호표 줄 구간 전체 붉은 외곽선(머리 accent 밑줄은 덮음) */
 .b09-estimation .ui-data-table__table tbody tr.is-pick td {
   --pick-t: inset 0 0 0 0 transparent;
@@ -119,20 +124,51 @@
   font-weight: var(--font-weight-bold);
 }
 
-/* 185-1 총괄 · 원가계산서 레벨 — 글자 크기 = 위 is-lvN · 들여쓰기 = 명칭 칸(is-indent) · 앞 칸(is-flat)은 그대로 */
-.b09-estimation .ui-data-table__table tbody tr[class*="is-lv"] td.is-flat:first-child {
-  padding-left: var(--spacing-8);
-}
-
-.b09-estimation .ui-data-table__table tbody tr.is-lv2 td.is-indent {
-  padding-left: calc(var(--spacing-8) + 1em);
-}
-
-.b09-estimation .ui-data-table__table tbody tr.is-lv3 td.is-indent {
-  padding-left: calc(var(--spacing-8) + 2em);
-}
-
 /* 184-3 설계내역서 고친 칸 — 자동 값과 다른 칸(풍선 = 자동 값) */
 .b09-estimation .ui-data-table__table tbody td.is-edited {
   background: color-mix(in srgb, var(--color-warning) 22%, var(--color-canvas));
 }
+
+/* 203-1 좌측 「데이터 점검」 — [업데이트] 필요 = 단추 위 점 배지(B05 [3D 업데이트] 꼴) */
+.b09-options .ui-btn.is-pending {
+  position: relative;
+  border-color: var(--color-warning);
+}
+
+.b09-options .ui-btn.is-pending::after {
+  content: "";
+  position: absolute;
+  top: 4px;
+  right: 4px;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--color-warning);
+}
+
+/* 연결 점검 목록 — 이름 · 탭(작게) · 알림 글 */
+.b09-check__head,
+.b09-check__note {
+  margin: var(--spacing-8) 0 0;
+  color: var(--color-text-secondary);
+  font-size: var(--text-caption);
+}
+
+.b09-check__tab {
+  flex: none;
+  color: var(--color-text-secondary);
+  font-size: var(--text-caption);
+}
+
+/* 줄 끌기(204-1) — 놓을 자리 · 레벨 미리 보기 선 · 못 놓는 자리 = 빨간 점선 */
+.b09-estimation__drop {
+  position: fixed;
+  z-index: 1000;
+  height: 0;
+  border-top: 2px solid var(--color-primary);
+  pointer-events: none;
+}
+
+.b09-estimation__drop.is-bad {
+  border-top: 2px dashed var(--color-danger);
+}
diff --git a/B09_Estimation/B09_Estimation_UI_Shell.ts b/B09_Estimation/B09_Estimation_UI_Shell.ts
index cc619ea1f..c3c67a6c6 100644
--- a/B09_Estimation/B09_Estimation_UI_Shell.ts
+++ b/B09_Estimation/B09_Estimation_UI_Shell.ts
@@ -4,7 +4,7 @@
  *
  *   원본 = 기번3 공통 원가산출 엑셀 · 탭 하나 = 화면 표 하나(`…_UI_Tabs` 차례) · 옛 원가 코드 안 봄
  *   자료 = GET …/estimation(입력 · 사용자 값 · 서버가 셈한 표) · 조작 = 캐시(`b09-estimation`) +
- *   짝 계산(`…_Calc_*.ts`)으로 바로 다시 셈 · [저장] = PUT → 서버 정본 · [단가 갱신] = POST …/prices
+ *   짝 계산(`…_Calc_*.ts`)으로 바로 다시 셈 · [저장] = PUT → 서버 정본 · [업데이트] = POST …/prices
  *   호표 칸 누름 = 그 탭 그 줄로 이동 · 자동 저장 없음
  * ========================================================================== */
 
@@ -20,7 +20,7 @@ import {
   showToast,
 } from "@ui/ui_template_elements";
 import { attachCollapsible } from "@ui/ui_template_collapsible";
-import { createDataTable, type DataTable } from "@ui/ui_template_data_table";
+import { cellColumn, createDataTable, type DataTable } from "@ui/ui_template_data_table";
 import { attachHoverInfo } from "@ui/ui_template_hover_info";
 import { ui_locales, currentLanguageIndex } from "@ui/ui_template_locale";
 import { clearState, readState, writeState } from "../A00_Common/b_page_state";
@@ -31,9 +31,9 @@ import { computeEstimation } from "./B09_Estimation_Calc_Bill";
 import { computeLabor, daegaPrice } from "./B09_Estimation_Calc_Labor";
 import { computeTotal } from "./B09_Estimation_Calc_Total";
 import { createTabBars } from "./B09_Estimation_UI_TabBar";
+import { createCheckPanel } from "./B09_Estimation_UI_Check";
 import { buildDaegaBlocks, buildDaegaList } from "./B09_Estimation_UI_Tabs_Labor";
 import {
-  buildCheck,
   rowIndex,
   TABS,
   type Link,
@@ -52,6 +52,7 @@ import {
 } from "./B09_Estimation_UI_Tabs_Base";
 import { buildBill } from "./B09_Estimation_UI_Tabs_Bill";
 import { attachRowMenu, openMenuAt, type BillTable } from "./B09_Estimation_UI_Tabs_Bill_Edit";
+import { levelBar, pickedClass } from "./B09_Estimation_UI_Tabs_Bill_Level";
 import {
   buildSumExpense,
   buildSumLabor,
@@ -69,7 +70,6 @@ function L(key: keyof typeof ui_locales): string {
 const LATER: Record<string, string> = {};
 
 const BUILDERS: Partial<Record<TabId, TabBuild>> = {
-  check: buildCheck,
   dg_list: buildDaegaList,
   dg: buildDaegaBlocks,
   bill: buildBill,
@@ -151,7 +151,7 @@ export function renderB09Estimation(root: HTMLElement): void {
   let payload: Row | null = null;
   let user: Row = {};
   let sheets: Row = {};
-  let current: TabId = "check";
+  let current: TabId = TABS[0][0];
 
   // 181-1 위 탭(md) · 아래 탭(sm) 두 줄 — 줄 그리기 = `…_UI_TabBar`
   const bars = createTabBars((tab) => show(tab));
@@ -162,11 +162,10 @@ export function renderB09Estimation(root: HTMLElement): void {
   body.className = "b09-estimation";
   body.append(bars.top, bars.sub, panel);
 
-  const made = document.createElement("p");
-  made.className = "b09-estimation__hint";
-
   const recompute = (): void => {
-    if (payload) sheets = computeSheets(payload, user);
+    if (!payload) return;
+    sheets = computeSheets(payload, user);
+    check.draw(payload, sheets); // 203-1 좌측 연결 점검 · [업데이트] 배지
   };
 
   const setUser = (next: Row): void => {
@@ -184,6 +183,7 @@ export function renderB09Estimation(root: HTMLElement): void {
   const show = (tab: TabId, focus?: string): void => {
     current = tab;
     bars.draw(tab);
+    bars.setTools([]); // 보기 단추 · 열 수는 묶음 탭만 다시 채움(202-1)
     if (!projectId) return void panel.replaceChildren(note("프로젝트를 먼저 고르세요."));
     if (!payload) return void panel.replaceChildren(note("원가 자료를 불러오는 중…"));
     const build = BUILDERS[tab];
@@ -209,6 +209,8 @@ export function renderB09Estimation(root: HTMLElement): void {
           ? (i) => [spec.rowClass?.(i), extra(i)].filter(Boolean).join(" ") || null
           : spec.rowClass,
         cellClass: spec.cellClass,
+        level: spec.level,
+        mergeSame: spec.mergeSame,
         onCellClick: (i, key) => {
           if (spec.onCell) spec.onCell(i, key);
           if (spec.link && !spec.editable?.(i, key)) goto(spec.link(i, key));
@@ -222,7 +224,7 @@ export function renderB09Estimation(root: HTMLElement): void {
       if (spec.choices)
         made.root.addEventListener("click", (event) => {
           const cell = (event.target as Element).closest<HTMLTableCellElement>("tr[data-i] td");
-          const column = cell ? spec.columns[cell.cellIndex] : undefined;
+          const column = cell ? spec.columns[cellColumn(cell)] : undefined;
           const items =
             cell && column && spec.choices?.(Number(cell.parentElement?.dataset.i), column.key);
           if (!cell || !items?.length) return;
@@ -234,7 +236,7 @@ export function renderB09Estimation(root: HTMLElement): void {
         attachHoverInfo(
           made.root,
           (cell) => {
-            const column = spec.columns[(cell as HTMLTableCellElement).cellIndex];
+            const column = spec.columns[cellColumn(cell as HTMLTableCellElement)];
             return column && spec.tip?.(Number(cell.parentElement?.dataset.i), column.key);
           },
           "tr[data-i] td",
@@ -246,11 +248,23 @@ export function renderB09Estimation(root: HTMLElement): void {
     if (isGroupTab(tab)) {
       const redraw = (): void => show(tab);
       return void panel.replaceChildren(
-        ...renderGroupPanel({ tab, spec, hint, focus, goto, makeTable, redraw }),
+        ...renderGroupPanel({
+          tab,
+          spec,
+          hint,
+          focus,
+          goto,
+          makeTable,
+          redraw,
+          setTools: bars.setTools,
+        }),
       );
     }
-    const table = makeTable();
-    panel.replaceChildren(...(hint ? [hint] : []), table.root);
+    // 200-2 설계내역서 = 표 위 레벨 도구 줄 · 고른 줄 강조 · 202-1 안내 줄 = 표 아래
+    const bill = (spec as BillTable).menu ? (spec as BillTable) : null;
+    const table = makeTable(bill ? (i) => pickedClass(bill.rows[i]) : undefined);
+    const level = bill ? levelBar(table.root, bill) : null;
+    panel.replaceChildren(...(level ? [level] : []), table.root, ...(hint ? [hint] : []));
     if (focus !== undefined) {
       const index = rowIndex(spec.rows, focus);
       if (index >= 0) requestAnimationFrame(() => table.focusRow(index));
@@ -262,9 +276,6 @@ export function renderB09Estimation(root: HTMLElement): void {
     const draft = projectId && !fromServer ? readState<Row>("b09-estimation", projectId) : null;
     user = draft ?? next.user ?? {};
     recompute();
-    made.textContent = next.book?.made
-      ? `단가 굳힘 ${String(next.book.made).replace("T", " ")} — [단가 갱신] 때만 새로`
-      : "단가 아직 안 굳힘 — [저장] 이나 [단가 갱신] 때 M01 값을 굳힘";
     show(current);
   };
 
@@ -293,12 +304,13 @@ export function renderB09Estimation(root: HTMLElement): void {
   });
   save.dataset.b09Save = "";
   const refresh = createButton({
-    label: "단가 갱신",
+    label: "업데이트",
     variant: "ghost",
     onClick: () =>
       void run("/estimation/prices", "POST", "단가를 지금 M01 값으로 새로 굳혔습니다."),
   });
   refresh.dataset.b09Refresh = "";
+  const check = createCheckPanel(refresh, (link) => show(link.tab, link.key));
   // 184-3 내역 초기화 — 설계내역서 덮개(user.bill) 지우고 바로 저장 → 기본 로직 내역
   const reset = createButton({
     label: "내역 초기화",
@@ -318,8 +330,8 @@ export function renderB09Estimation(root: HTMLElement): void {
   section.className = "ui-collapsible ui-sidebar-section ui-sidebar-card";
   const heading = document.createElement("h3");
   heading.className = "ui-collapsible__title";
-  heading.textContent = "원가 단가";
-  section.append(heading, made, refresh);
+  heading.textContent = "데이터 점검";
+  section.append(heading, refresh, check.list);
   const actions = document.createElement("div");
   actions.className = "ui-sidebar-actions";
   actions.append(save, reset);
diff --git a/B09_Estimation/B09_Estimation_UI_TabBar.ts b/B09_Estimation/B09_Estimation_UI_TabBar.ts
index c80caaf7e..3ce0e2a2f 100644
--- a/B09_Estimation/B09_Estimation_UI_TabBar.ts
+++ b/B09_Estimation/B09_Estimation_UI_TabBar.ts
@@ -5,6 +5,7 @@
  *   위 탭 = `TAB_GROUPS`(`…_UI_Tabs`) · 아래 탭 하나뿐인 위 탭 = 보이지 않는 sm 단추 한 줄(높이만 채움)
  *   위 탭 누름 = 그 묶음에서 마지막으로 본 아래 탭(이 화면 안 Map · 저장 안 함) · 없으면 첫 아래 탭
  *   탭 이동은 `draw(탭)` — 이동이 묶음을 넘어도 위 탭이 따라 켜짐
+ *   보기 단추 · 가로 열 수(202-1) = 아래 줄 오른쪽 맞춤 자리(`setTools`) · 빈 줄에서도 보임
  * ========================================================================== */
 
 import { createButton } from "@ui/ui_template_elements";
@@ -15,6 +16,8 @@ export interface TabBars {
   sub: HTMLElement;
   /** 이 탭이 켜진 꼴로 두 줄을 다시 그림 */
   draw: (tab: TabId) => void;
+  /** 아래 줄 오른쪽 도구(박스보기 · 가로 열 수) — 빈 목록 = 비움 */
+  setTools: (tools: HTMLElement[]) => void;
 }
 
 function tabButton(label: string, on: boolean, size: "sm" | undefined, pick: () => void) {
@@ -35,6 +38,8 @@ export function createTabBars(onPick: (tab: TabId) => void): TabBars {
   top.setAttribute("role", "tablist");
   const sub = document.createElement("div");
   sub.className = "b09-estimation__tabs";
+  const tools = document.createElement("div");
+  tools.className = "b09-estimation__tools";
   const lastSeen = new Map<TabId, TabId>();
 
   const draw = (tab: TabId): void => {
@@ -53,11 +58,11 @@ export function createTabBars(onPick: (tab: TabId) => void): TabBars {
     const single = picked.length === 1;
     sub.classList.toggle("b09-estimation__tabs--blank", single);
     sub.setAttribute("role", single ? "presentation" : "tablist");
-    sub.setAttribute("aria-hidden", String(single));
     if (single) {
       const ghost = createButton({ label: tabName(picked[0]), variant: "ghost", size: "sm" });
       ghost.tabIndex = -1;
-      return void sub.replaceChildren(ghost);
+      ghost.setAttribute("aria-hidden", "true"); // 도구는 보이는 줄이라 줄 전체를 숨기지 않음
+      return void sub.replaceChildren(ghost, tools);
     }
     sub.replaceChildren(
       ...picked.map((id) => {
@@ -65,7 +70,9 @@ export function createTabBars(onPick: (tab: TabId) => void): TabBars {
         button.dataset.b09Tab = id;
         return button;
       }),
+      tools,
     );
   };
-  return { top, sub, draw };
+  const setTools = (items: HTMLElement[]): void => tools.replaceChildren(...items);
+  return { top, sub, draw, setTools };
 }
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs.ts b/B09_Estimation/B09_Estimation_UI_Tabs.ts
index 8f68f8ead..1a3405e96 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs.ts
@@ -2,17 +2,17 @@
  * B09_Estimation_UI_Tabs.ts
  * B09 탭 목록 · 표 짜기 공용(PLAN 144-1) — 탭 하나 = 화면 표 하나(실무 엑셀 탭 차례).
  *
- *   탭 = 연결 점검(목차 · 안내) · 원가 · 총괄 · 내역 · 대가 둘 · 산근 둘 · 기초 · 중기 둘 · 단가 넷 · 집계표 넷
+ *   탭 = 원가 · 총괄 · 내역 · 대가 둘 · 산근 둘 · 기초 · 중기 둘 · 단가 넷 · 집계표 넷
  *   표 = 공용 `createDataTable` · 「연결 없음」 칸 = 빈칸 · 호표 칸 누름 = 그 탭 그 줄로 이동(`link`)
- *   탭별 표 = `…_UI_Tabs_Base`(144) · `…_UI_Tabs_Cost`(145) · 여기는 차례 · 꼴 · 연결 점검만
+ *   탭별 표 = `…_UI_Tabs_Base`(144) · `…_UI_Tabs_Cost`(145) · 여기는 차례 · 꼴만
+ *   연결 점검(옛 첫 탭) = 좌측 「데이터 점검」 묶음(203-1 `…_UI_Check`)
  * ========================================================================== */
 
 import type { MapContextMenuItem } from "@ui/ui_template_context_menu";
-import type { DataColumn, DataRow } from "@ui/ui_template_data_table";
+import type { DataColumn, DataRow, DataTableOptions } from "@ui/ui_template_data_table";
 import type { Row } from "./B09_Estimation_Calc_Base";
 
 export type TabId =
-  | "check"
   | "cost"
   | "total"
   | "bill"
@@ -34,7 +34,6 @@ export type TabId =
 
 /** 엑셀 탭 차례 — [id, 탭 이름] */
 export const TABS: Array<[TabId, string]> = [
-  ["check", "연결 점검"],
   ["cost", "공사원가계산서"],
   ["total", "총괄설계내역서"],
   ["bill", "설계내역서"],
@@ -59,7 +58,6 @@ export const tabName = (id: string): string => TABS.find(([t]) => t === id)?.[1]
 
 /** 위 탭(181-1) — [위 탭 이름, 아래 탭들] · 아래 탭 하나뿐 = 위 탭 단독 · 첫 아래 탭 = 위 탭 키 */
 export const TAB_GROUPS: Array<[string, TabId[]]> = [
-  ["연결 점검", ["check"]],
   ["공사원가계산서", ["cost"]],
   ["총괄설계내역서", ["total"]],
   ["설계내역서", ["bill"]],
@@ -112,10 +110,20 @@ export interface TabTable {
   cellClass?: (index: number, key: string) => string | null | undefined;
   /** 칸 누름 고르기 메뉴(183-3 · 칸 아래 공용 메뉴 · 빈 것 = 안 엶) */
   choices?: (index: number, key: string) => MapContextMenuItem[] | null;
+  /** 레벨(201-1 · 공용 표 level · 보기 전용) — 그 열 들여쓰기 */
+  level?: DataTableOptions["level"];
+  /** 같은 값 세로 병합할 열(201-1 · 공용 표 mergeSame) */
+  mergeSame?: string[];
 }
 
 export type TabBuild = (ctx: TabContext) => TabTable | string;
 
+/** 201-1 호표 묶음 레벨(보기 전용) — 머리 · 합계(제목 줄) = 1 · 그 밖 = 2 · key 열을 들여씀 */
+export const blockLevel = (key: string, top: (index: number) => boolean): TabTable["level"] => ({
+  key,
+  of: (i) => (top(i) ? 1 : 2),
+});
+
 /* ── 열 꼴 ────────────────────────────────────────────────────────────── */
 
 export const text = (key: string, label: string, width?: number, group?: string[]): DataColumn => ({
@@ -156,36 +164,3 @@ export function parseNumber(value: string): number | null | undefined {
 export function rowIndex(rows: DataRow[], key: string): number {
   return rows.findIndex((row) => row.key === key);
 }
-
-/* ── 연결 점검(목차 · 안내) ───────────────────────────────────────────── */
-
-export const buildCheck: TabBuild = ({ sheets, payload }): TabTable => {
-  const gaps: Row[] = sheets.gaps || [];
-  const rows: DataRow[] = gaps.map((g, i) => ({
-    no: i + 1,
-    key: `${g.tab}|${g.key}|${i}`,
-    tab: tabName(g.tab),
-    name: g.name,
-    why: g.why,
-  }));
-  const notes: string[] = [...(payload.notes || [])];
-  const missing: string[] = payload.inputs?.missing || [];
-  if (missing.length) notes.push(`M01 에 없는 키 ${missing.length} — ${missing.join(" · ")}`);
-  return {
-    columns: [
-      qty("no", "번호", 0),
-      text("tab", "탭", 150),
-      text("name", "명칭", 260),
-      text("why", "까닭", 320),
-    ],
-    rows,
-    frozen: 1,
-    hint:
-      `연결 없음 ${gaps.length}곳 — 줄을 누르면 그 탭 그 줄로 · 빈칸 = 값을 낸 원천이 없음(0 을 채우지 않음)` +
-      (notes.length ? ` · ${notes.join(" · ")}` : ""),
-    link: (i) => {
-      const g = gaps[i];
-      return g ? { tab: g.tab as TabId, key: g.key } : null;
-    },
-  };
-};
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Base.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Base.ts
index e16abf10f..fdd74a838 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Base.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Base.ts
@@ -19,6 +19,7 @@ import type { DataRow } from "@ui/ui_template_data_table";
 import { SOURCES, type Row } from "./B09_Estimation_Calc_Base";
 import { openQuotes } from "./B09_Estimation_UI_Tabs_Base_Quote";
 import {
+  blockLevel,
   money,
   parseNumber,
   qty,
@@ -51,14 +52,14 @@ export const buildLabor: TabBuild = ({ sheets, payload }) =>
   priceList(
     sheets.labor || [],
     "단가(원/인)",
-    `노임 = 굳힌 단가(${madeText(payload)}) · M01 인력 · 바꾸려면 [단가 갱신]`,
+    `노임 = 굳힌 단가(${madeText(payload)}) · M01 인력 · 바꾸려면 [업데이트]`,
   );
 
 export const buildExpense: TabBuild = ({ sheets, payload }) =>
   priceList(
     sheets.expense || [],
     "기준가(천원)",
-    `기계 손료 기준가 = 굳힌 단가(${madeText(payload)}) · M01 기계 가격 · 바꾸려면 [단가 갱신]`,
+    `기계 손료 기준가 = 굳힌 단가(${madeText(payload)}) · M01 기계 가격 · 바꾸려면 [업데이트]`,
   );
 
 function madeText(payload: Row): string {
@@ -102,6 +103,7 @@ export const buildBasis: TabBuild = ({ sheets }): TabTable => {
     ],
     rows,
     frozen: 2,
+    mergeSame: ["part"],
     hint: "운전사 시간 노임 = ROUNDDOWN(일당 × 1/8 × 16/12 × 25/20, 0)(M01 CC000336 · 건협기술-2230) · 환율 = M01 한국은행 · 인건비 줄 누름 = 노무비목록표",
     link: (i) => {
       const row = rows[i];
@@ -344,7 +346,7 @@ export const buildMachineBlocks: TabBuild = ({ sheets }): TabTable => {
       const amt = (part: string): number | null => (ln.kind === part ? ln.amount : null);
       rows.push({
         key: `${b.key}|${ln.name}`,
-        name: `  ${ln.name}`,
+        name: ln.name,
         spec: ln.spec,
         qty: ln.qty,
         unit: ln.unit,
@@ -361,7 +363,7 @@ export const buildMachineBlocks: TabBuild = ({ sheets }): TabTable => {
     }
     rows.push({
       key: `${b.key}|합계`,
-      name: "  합  계",
+      name: "합  계",
       sum: b.sum,
       labor: b.labor,
       material: b.material,
@@ -388,5 +390,6 @@ export const buildMachineBlocks: TabBuild = ({ sheets }): TabTable => {
     frozen: 1,
     hint: "손료 = 기준가(천원) × 손료계수 ÷ 10,000 · 운전사 = 인 × 시간 노임 · 연료 = ℓ/hr × 적용 단가 · 잡품 = 연료 금액 × % · 줄 ROUNDDOWN 1 · 비목 합 ROUNDDOWN 0 · 줄 누름 = 단가를 낸 탭",
     link: (i) => links[i] ?? null,
+    level: blockLevel("name", (i) => !String(rows[i]?.key).includes("|")),
   };
 };
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts
index c14b71c14..314939f03 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts
@@ -7,7 +7,7 @@
  *   고칠 칸 = 항목 줄 명칭 · 규격 · 단위 · 수량 · 묶음 줄 이름 · 조달수수료 율(%) — 자동 줄은 덮개
  *     고친 칸 = 칸 강조(셈 줄 `auto_{칸}` 있음) · 풍선 = 자동 값
  *   줄 누름 = 단가를 낸 탭 줄(자재 → 재료비목록표 · 구조물 → 일위대가목록표)
- *   레벨 = 줄 `level`(셈이 냄) → class is-lvN · 글자 크기 · 첫 칸 들여쓰기(CSS)
+ *   레벨 = 줄 `level`(셈이 냄) → 공용 표 level 옵션(공종 · 명칭 칸 들여쓰기 · 201-1) · 다루기 = `…_Bill_Level`
  *   「연결 ▾」 칸 = 항목 줄(자재 · 조달수수료 빼고) · 누름 = 우클릭 [연결] 과 같은 메뉴
  * ========================================================================== */
 
@@ -16,6 +16,7 @@ import type { Row } from "./B09_Estimation_Calc_Base";
 import { money, parseNumber, qty, text, type TabBuild, type TabId } from "./B09_Estimation_UI_Tabs";
 import {
   billMenu,
+  dropMove,
   editCell,
   linkable,
   openLinkMenu,
@@ -93,9 +94,11 @@ export const buildBill: TabBuild = (ctx): BillTable => {
       const r = rows[i];
       if (!r) return null;
       const title = r.kind === "title" ? "is-title" : r.kind === "group" ? "is-group" : "";
-      return [`is-lv${r.level ?? 1}`, title, r.auto ? "" : "is-hand"].filter((c) => c).join(" ");
+      return [title, r.auto ? "" : "is-hand"].filter((c) => c).join(" ") || null;
     },
+    level: { key: "name", of: (i) => rows[i]?.level as number | undefined },
     menu: (i) => billMenu(ctx, raw, i),
+    drop: (i, parent, before) => dropMove(ctx, raw, i, parent, before),
     onCell: (i, key) => {
       if (key === "connect") openLinkMenu(ctx, raw, i);
     },
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Drag.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Drag.ts
new file mode 100644
index 000000000..786ccc285
--- /dev/null
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Drag.ts
@@ -0,0 +1,127 @@
+/* =============================================================================
+ * B09_Estimation_UI_Tabs_Bill_Drag.ts
+ * B09 설계내역서 줄 끌기(PLAN 204-1) — 줄을 잡아 위아래 = 자리 · 좌우 = 레벨(한 칸 = 1em) · 공용 표 위 덧그림.
+ *
+ *   놓을 자리 = 줄 사이 틈(포인터가 줄 가운데 위 = 그 줄 앞) · 끄는 줄 자손 = 함께 감 · 자기 자손 안 = 못 놓음
+ *   레벨 = 위 줄 + 1(위 줄 아래로 · 항목이면 저절로 묶음) ~ 아래 줄 레벨 · 맨 위(1) = 맨 위 줄만
+ *   놓기 = 표 drop(`…_Bill_Edit` dropMove — 메뉴와 같은 지킬 것) · 미리 보기 선(못 놓음 = is-bad · 커서 not-allowed)
+ *   잡기 = 글 칸 · 단추 밖 아무 칸 · 6px 넘게 움직여야 끌기(그냥 누름 = 줄 고름)
+ * ========================================================================== */
+
+import type { DataRow } from "@ui/ui_template_data_table";
+import type { BillTable } from "./B09_Estimation_UI_Tabs_Bill_Edit";
+
+export interface DropAt {
+  parent: string | null;
+  before: string | null;
+  level: number;
+}
+
+const holds = (row: DataRow): boolean => row.key !== "fee" && !String(row.key).startsWith("mat:");
+
+/** 틈 gap(0 ~ 줄 수 · 그 줄 앞) · 바라는 레벨 → 놓을 자리 · 같은 자리 · 못 놓음 = null */
+export function dropAt(rows: DataRow[], from: number, gap: number, want: number): DropAt | null {
+  const row = rows[from];
+  if (!row) return null;
+  const lv = (r: DataRow | undefined): number => Number(r?.level ?? 1);
+  let end = from + 1;
+  while (end < rows.length && lv(rows[end]) > lv(row)) end += 1;
+  if (gap > from && gap < end) return null; // 자기 자손 안
+  const rest = [...rows.slice(0, from), ...rows.slice(end)];
+  const g = gap <= from ? gap : gap - (end - from);
+  const up = rest[g - 1];
+  const down = rest[g];
+  const max = up ? lv(up) + (holds(up) ? 1 : 0) : 1;
+  const min = Math.max(down ? lv(down) : 1, lv(row) === 1 ? 1 : 2);
+  if (min > max) return null;
+  const level = Math.min(max, Math.max(min, want));
+  if (level === lv(row) && (gap === from || gap === end)) return null; // 제자리
+  let parent: DataRow | undefined = up;
+  const byKey = new Map(rest.map((r) => [String(r.key), r]));
+  while (parent && lv(parent) >= level) parent = byKey.get(String(parent.parent ?? ""));
+  return {
+    parent: parent ? String(parent.key) : null,
+    before: down && lv(down) === level ? String(down.key) : null,
+    level,
+  };
+}
+
+/** 표 root 에 줄 끌기를 붙임 — 놓으면 done(끈 줄 키) 뒤 drop 실행 */
+export function attachDrag(root: HTMLElement, table: BillTable, done: (key: string) => void): void {
+  let endAt = 0;
+  // 끌고 난 누름 = 줄 고름 아님
+  root.addEventListener(
+    "click",
+    (event) => {
+      if (Date.now() - endAt < 300) event.stopPropagation();
+    },
+    true,
+  );
+  root.addEventListener("pointerdown", (down) => {
+    const target = down.target as Element;
+    if (down.button !== 0 || !table.drop || target.closest("input,textarea,select,button,a"))
+      return;
+    const tr = target.closest<HTMLElement>("tr[data-i]");
+    if (!tr || !root.contains(tr)) return;
+    const from = Number(tr.dataset.i);
+    const step = parseFloat(getComputedStyle(tr).fontSize) || 14;
+    const line = document.createElement("div");
+    line.className = "b09-estimation__drop";
+    let on = false;
+    let run: (() => void) | null = null;
+    let seen = "";
+    const move = (event: PointerEvent): void => {
+      const dx = event.clientX - down.clientX;
+      if (!on && Math.abs(dx) + Math.abs(event.clientY - down.clientY) < 6) return;
+      if (!on) {
+        on = true;
+        document.body.append(line);
+        document.body.style.userSelect = "none";
+        window.getSelection()?.removeAllRanges();
+      }
+      const trs = table.rows.map((_r, i) => root.querySelector<HTMLElement>(`tr[data-i="${i}"]`));
+      let gap = trs.length;
+      let y = trs.at(-1)?.getBoundingClientRect().bottom ?? 0;
+      for (const [i, el] of trs.entries()) {
+        const box = el?.getBoundingClientRect();
+        if (box && event.clientY < box.top + box.height / 2) {
+          [gap, y] = [i, box.top];
+          break;
+        }
+      }
+      const want = Number(table.rows[from]?.level ?? 1) + Math.round(dx / step);
+      const at = dropAt(table.rows, from, gap, want);
+      const key = `${gap}|${at?.level}`;
+      if (key !== seen) {
+        seen = key;
+        run = at ? table.drop!(from, at.parent, at.before) : null;
+      }
+      const box = root.getBoundingClientRect();
+      const left = box.left + ((at?.level ?? want) - 1) * step + 8;
+      Object.assign(line.style, {
+        top: `${y - 1}px`,
+        left: `${left}px`,
+        width: `${Math.max(box.right - left, 40)}px`,
+      });
+      line.classList.toggle("is-bad", !run);
+      document.body.style.cursor = run ? "grabbing" : "not-allowed";
+    };
+    const stop = (event: PointerEvent): void => {
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", stop);
+      window.removeEventListener("pointercancel", stop);
+      line.remove();
+      document.body.style.userSelect = "";
+      document.body.style.cursor = "";
+      if (!on) return;
+      endAt = Date.now();
+      if (event.type === "pointerup" && run) {
+        done(String(table.rows[from].key));
+        run();
+      }
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", stop);
+    window.addEventListener("pointercancel", stop);
+  });
+}
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts
index 105b3ff80..d8ea35242 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts
@@ -11,6 +11,8 @@
  *   막음 = 조달수수료 · 관급자재대 제목 옮기기 · 지우기 · 자재(mat:) 줄 맨 위 묶음 돈 갈래(관급 · 직접비)
  *     바뀌는 옮김 · 자재 줄 지우기(주인 = 대비표 표시) · 깊이 5 넘음 · 자식 있는 맨 위 묶음 지우기
  *   연결 고르기 창 = `…_UI_Tabs_Bill_Link` · 우클릭 = 공용 메뉴(`ui_template_context_menu` · 화면 고정 자리)
+ *   묶음 자동(204) = 줄 아래로 들임 · 끌어 놓음 → 그 줄 저절로 묶음(셈) · 자식이 다 빠진 새 묶음 = 항목(kind 지움 ·
+ *     맨 위 공종은 그대로) · 줄을 옮기면 자손이 함께 감(부모 키 그대로) · 끌어 놓기 = `dropMove`(`…_Bill_Drag`)
  * ========================================================================== */
 
 import type { DataRow } from "@ui/ui_template_data_table";
@@ -24,7 +26,11 @@ import type { TabContext, TabTable } from "./B09_Estimation_UI_Tabs";
 import { linkItems, type ApplyRef } from "./B09_Estimation_UI_Tabs_Bill_Link";
 
 /** 설계내역서 표 = 탭 표 + 줄 우클릭 메뉴 */
-export type BillTable = TabTable & { menu?: (index: number) => MapContextMenuItem[] };
+export type BillTable = TabTable & {
+  menu?: (index: number) => MapContextMenuItem[];
+  /** 끌어 놓기(204) — 줄 index 를 parent(null = 맨 위) 아래 before 앞(null = 끝)으로 · 못 하면 null */
+  drop?: (index: number, parent: string | null, before: string | null) => (() => void) | null;
+};
 
 const NEW_NAME = "새 줄";
 const NEW_SECTION = "새 공종";
@@ -47,6 +53,8 @@ interface Work {
 
 /** 옮기기 · 지우기 · 연결 없는 줄 — 조달수수료 · 관급자재대 제목 */
 const fixed = (key: string): boolean => key === "fee" || key === "sec:G";
+/** 자식을 둘 수 있는 줄 — 자재 · 조달수수료 빼고(항목은 저절로 묶음) */
+const canHold = (key: string): boolean => key !== "fee" && !key.startsWith("mat:");
 
 /** 연결 ▾ 있는 줄 — 항목 줄(자재 = 대비표 단가 · 조달수수료 = 율 빼고) */
 export const linkable = (row: DataRow | undefined): boolean =>
@@ -148,6 +156,11 @@ function attempt(
   const before = w.bill.rows.map((e) => ({ ...e }));
   if (change(w) === false) return null;
   w.bill.rows = tidy(w.bill.rows);
+  // 자식이 다 빠진 새 묶음 = 항목(맨 위 공종 빼고) — 자식이 생긴 항목 = 셈이 묶음으로
+  const had = new Set(before.map((e) => e.parent));
+  const has = new Set(w.bill.rows.map((e) => e.parent));
+  for (const e of w.bill.rows)
+    if (e.kind === "group" && e.parent && had.has(e.key) && !has.has(e.key)) delete e.kind;
   return fits(w, before) ? () => put(ctx, w.bill) : null;
 }
 
@@ -273,7 +286,7 @@ export function billMenu(ctx: TabContext, rows: DataRow[], i: number): MapContex
     add(2, "들여쓰기 →", (w, e) => {
       const sib = siblings(w, e.parent);
       const up = sib[sib.indexOf(e) - 1];
-      if (!up || !isGroup(w, up.key)) return false;
+      if (!up || !canHold(up.key)) return false;
       e.parent = up.key;
       w.bill.rows.push(pull(w.bill.rows, key));
     });
@@ -315,6 +328,28 @@ export function billMenu(ctx: TabContext, rows: DataRow[], i: number): MapContex
   return out;
 }
 
+/** 끌어 놓기(204) — 자손째 parent 아래 before 앞으로 · 지킬 것(깊이 · 자재 돈 갈래)은 메뉴와 같음 */
+export function dropMove(
+  ctx: TabContext,
+  rows: DataRow[],
+  i: number,
+  parent: string | null,
+  before: string | null,
+): (() => void) | null {
+  const key = String(rows[i]?.key);
+  if (!rows[i] || fixed(key) || (parent !== null && !canHold(parent))) return null;
+  return attempt(ctx, rows, (w) => {
+    const e = entryOf(w, key);
+    if (!e || (parent !== null && !entryOf(w, parent))) return false;
+    if (parent !== null && chain(w.bill.rows, parent).includes(e)) return false; // 자기 자손 아래
+    if (parent === null) delete e.parent;
+    else e.parent = parent;
+    pull(w.bill.rows, key);
+    const at = before === null ? -1 : find(w.bill.rows, before);
+    w.bill.rows.splice(at < 0 ? w.bill.rows.length : at, 0, e);
+  });
+}
+
 let shared: MapContextMenu | null = null;
 /** 마지막으로 누른 칸 — 「연결 ▾」 단추 메뉴 자리 */
 let lastCell: Element | null = null;
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Level.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Level.ts
new file mode 100644
index 000000000..6d9cb5125
--- /dev/null
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Level.ts
@@ -0,0 +1,138 @@
+/* =============================================================================
+ * B09_Estimation_UI_Tabs_Bill_Level.ts
+ * B09 설계내역서 레벨 도구 줄(PLAN 200-2) — 표 위 [→ 들여쓰기] [← 내어쓰기] [↑ 위로] [↓ 아래로] · 키 · 안내 한 줄.
+ *
+ *   동작 = 줄 우클릭 메뉴(`…_UI_Tabs_Bill_Edit` billMenu)의 같은 항목을 부름 — 메뉴에 없으면 단추 흐림 · 키 안 먹음
+ *   고른 줄 = 표 줄 누름(키로 기억 · 다시 그려도 남음) · 표시 = 줄 class is-focus(Shell 이 줄 class 곁값으로)
+ *   키 = Tab 들여쓰기 · Shift+Tab 내어쓰기 · Alt+↑↓ 옮기기 · Esc 편집 끝(편집 아니면 고름 풂)
+ *     방향키(204) = → 들여쓰기 · ← 내어쓰기 · ↑↓ 옮기기(같은 메뉴 항목) · 끌기 = `…_Bill_Drag`(놓은 줄 = 고른 줄)
+ *     글 칸 편집 중 · 초점이 표 · 도구 줄 밖이면 안 먹음 — 줄 누름이 다른 탭으로 가는 줄은 글 칸을 눌러 고름
+ * ========================================================================== */
+
+import type { DataRow } from "@ui/ui_template_data_table";
+import { createButton } from "@ui/ui_template_elements";
+import { attachHoverInfo } from "@ui/ui_template_hover_info";
+import { attachDrag } from "./B09_Estimation_UI_Tabs_Bill_Drag";
+import type { BillTable } from "./B09_Estimation_UI_Tabs_Bill_Edit";
+
+/** [단추 글, 메뉴 글] — 차례 = 들여 · 내어 · 위 · 아래 */
+const ACTS: [string, string][] = [
+  ["→ 들여쓰기", "들여쓰기 →"],
+  ["← 내어쓰기", "내어쓰기 ←"],
+  ["↑ 위로", "위로 ↑"],
+  ["↓ 아래로", "아래로 ↓"],
+];
+
+const GUIDE =
+  "레벨 — 줄을 누르고 단추 · 방향키 ←→ 레벨 · ↑↓ 옮김(Tab · Shift+Tab · Alt+↑↓ 도) · 줄 끌기";
+const GUIDE_MORE =
+  "레벨 = 공종 · 명칭 칸 왼쪽 들여쓰기(레벨마다 한 칸) · 묶음 금액 = 아래 줄 합 · " +
+  "들여쓰기 = 바로 위 줄 아래로(항목이면 저절로 묶음 · 자식이 다 빠진 묶음 = 다시 항목) · " +
+  "내어쓰기 = 부모 묶음 밖으로(맨 위 공종은 [새 공종 추가]) · " +
+  "위로 · 아래로 = 같은 부모 안에서 아래 줄째 자리 바꿈 · 못 하는 동작 = 흐린 단추 · " +
+  "끌기 = 줄을 잡아 위아래 = 자리 · 좌우 = 레벨(아래 줄째 · 빨간 선 = 못 놓음) · " +
+  "키는 글 칸 편집 중이 아닐 때(Esc = 편집 끝 · 한 번 더 Esc = 고름 풂) · " +
+  "묶음 줄로 바꾸기 · 더하기 · 지우기 = 줄 우클릭";
+
+let picked: string | null = null;
+/** 지금 그린 도구 줄 — 키가 부름 */
+let live: {
+  root: HTMLElement;
+  bar: HTMLElement;
+  run: (label: string) => void;
+  sync: () => void;
+} | null = null;
+let keysOn = false;
+
+/** 고른 줄 class — Shell 줄 class 곁값 */
+export const pickedClass = (row: DataRow | undefined): string | null =>
+  row && picked !== null && String(row.key) === picked ? "is-focus" : null;
+
+/** 그 줄 메뉴 항목(글 → 동작) — 메뉴에 없는 동작 = 못 함 */
+export function menuActs(table: BillTable, index: number): Map<string, () => void> {
+  const items = index >= 0 && table.menu ? table.menu(index) : [];
+  return new Map(items.filter((x): x is [string, () => void] => Array.isArray(x)));
+}
+
+/** 키 → 메뉴 글 · 편집 중 · 다른 키 = null */
+export function keyAct(
+  e: { key: string; shiftKey: boolean; altKey: boolean; ctrlKey?: boolean },
+  editing: boolean,
+): string | null {
+  if (editing || e.ctrlKey) return null;
+  if (e.key === "Tab" && !e.altKey) return ACTS[e.shiftKey ? 1 : 0][1];
+  if (e.shiftKey) return null;
+  const arrow = ["ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown"].indexOf(e.key);
+  // 방향키(204) — 그냥 · Alt 같음(Alt+←→ = 브라우저 뒤로 · 앞으로라 안 받음)
+  if (arrow < 0 || (e.altKey && arrow < 2)) return null;
+  return ACTS[arrow][1];
+}
+
+const editing = (at: Element | null): boolean =>
+  /^(INPUT|TEXTAREA|SELECT)$/.test(at?.tagName ?? "") ||
+  !!(at as HTMLElement | null)?.isContentEditable;
+
+function listenKeys(): void {
+  if (keysOn) return;
+  keysOn = true;
+  document.addEventListener("keydown", (event) => {
+    if (!live?.root.isConnected || picked === null) return;
+    const at = document.activeElement;
+    if (at && at !== document.body && !live.root.contains(at) && !live.bar.contains(at)) return;
+    // Esc = 편집 끝(표에 초점 · 키 받음) · 편집 아닐 때 = 고름 풂
+    if (event.key === "Escape") {
+      if (!editing(at)) {
+        picked = null;
+        return live.sync();
+      }
+      (at as HTMLElement).blur();
+      return live.root.focus();
+    }
+    const label = keyAct(event, editing(at));
+    if (!label) return;
+    event.preventDefault();
+    live.run(label);
+  });
+}
+
+/** 표 위 레벨 도구 줄 — 표 root 에 줄 누름(고름)을 붙임 */
+export function levelBar(root: HTMLElement, table: BillTable): HTMLElement {
+  const index = (): number =>
+    picked === null ? -1 : table.rows.findIndex((r) => String(r.key) === picked);
+  const run = (label: string): void => menuActs(table, index()).get(label)?.();
+  const buttons = ACTS.map(([text, label]) => {
+    const button = createButton({
+      label: text,
+      variant: "ghost",
+      size: "sm",
+      onClick: () => run(label),
+    });
+    button.dataset.b09Level = label;
+    return button;
+  });
+  const guide = document.createElement("span");
+  guide.className = "b09-estimation__hint";
+  guide.textContent = GUIDE;
+  attachHoverInfo(guide, GUIDE_MORE);
+  const bar = document.createElement("div");
+  bar.className = "b09-estimation__level";
+  bar.append(...buttons, guide);
+  const sync = (): void => {
+    const acts = menuActs(table, index());
+    ACTS.forEach(([, label], k) => (buttons[k].disabled = !acts.has(label)));
+    for (const tr of root.querySelectorAll("tr.is-focus")) tr.classList.remove("is-focus");
+    root.querySelector(`tr[data-i="${index()}"]`)?.classList.add("is-focus");
+  };
+  root.addEventListener("click", (event) => {
+    const tr = (event.target as Element).closest<HTMLElement>("tr[data-i]");
+    const row = tr ? table.rows[Number(tr.dataset.i)] : undefined;
+    if (!row) return;
+    picked = String(row.key);
+    sync();
+  });
+  attachDrag(root, table, (key) => (picked = key));
+  sync();
+  live = { root, bar, run, sync };
+  listenKeys();
+  return bar;
+}
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts
index 4bd17684e..0e384d428 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts
@@ -1,14 +1,19 @@
 /* =============================================================================
  * B09_Estimation_UI_Tabs_Bill_Link.ts
  * B09 설계내역서 연결 고르기(166-2 · 184-3) — 있는 호표(일위대가목록표 dg · 단가산출근거목록표 sg) ·
- *   M01 로직(새 산근 = 서버 셈 · [저장] 뒤 단가) · 로직 입력값 고치기 · 연결 풀기.
+ *   서고(마스터 · 회사 · 개인) 구조물조합 · 일위대가 사전조합(204-2 — 서버가 프로젝트 사본으로 들여와 새
+ *   대가 호표 · 같은 것 = 있는 사본) · M01 로직(새 산근 = 서버 셈 · [저장] 뒤 단가) · 로직 입력값 고치기 ·
+ *   연결 풀기.
  *
  *   줄에 적는 일 = 부르는 쪽 `apply(ref, from)`(`…_UI_Tabs_Bill_Edit` · 저장 꼴 모름)
- *   로직 고르기 · 입력값 = M02 창 재사용
+ *   로직 · 사전조합 고르기 · 입력값 = M02 창 재사용 · 구조물조합 고르기 = B08 [선택] 나무(173) 재사용 ·
+ *   층 읽기 권한 = 서버(`M02_Layer_Access`)
  * ========================================================================== */
 
+import { API_BASE_URL, CURRENT_PROJECT_ID_KEY } from "@config/config_frontend";
 import { showToast } from "@ui/ui_template_elements";
 import { createFindList } from "@ui/ui_template_find_list";
+import { openItemPicker } from "@ui/ui_template_item_picker";
 import { openModal } from "@ui/ui_template_modal";
 import { fetchLogicInputs } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api";
 import { openLaborInput } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Input";
@@ -86,6 +91,63 @@ function askInputs(apply: ApplyRef, code: string, name: string, old?: Row): void
   );
 }
 
+/** 서고 것 → 프로젝트 사본 · 새 대가 호표(204-2) — 서버가 들여옴 → 받은 원가 자료(대가 블록 · 산근)만
+ * 바꿔 끼우고(사용자 캐시 그대로) 줄 연결 `{tab: dg, key: 블록 id, lib: 사본 폴더}` */
+async function importLib(
+  ctx: TabContext,
+  apply: ApplyRef,
+  pick: { kind: "combo" | "precombo"; layer: string; owner: string | null; key: string },
+): Promise<void> {
+  const projectId = localStorage.getItem(CURRENT_PROJECT_ID_KEY);
+  if (!projectId) return;
+  showToast("서고에서 들여오는 중…", "info");
+  try {
+    const response = await fetch(`${API_BASE_URL}/projects/${projectId}/estimation/library`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(pick),
+    });
+    const got = (await response.json().catch(() => null)) as Row | null;
+    if (!response.ok || !got) {
+      const detail = got?.detail;
+      throw new Error(typeof detail === "string" ? detail : `HTTP ${response.status}`);
+    }
+    if (!got.key) throw new Error("사본은 들여왔으나 호표를 못 만듦");
+    const { user: _user, ...rest } = got.payload as Row;
+    Object.assign(ctx.payload, rest);
+    const from = ((rest.sheets?.daega as Row[]) || []).find((r) => r.key === got.key);
+    apply({ tab: "dg", key: got.key, lib: got.폴더 }, from);
+    showToast(
+      got.만듦 ? "새 호표로 연결함 — [저장]해야 연결이 남음" : "들여온 사본 호표로 연결함",
+      "success",
+    );
+  } catch (error) {
+    showToast(`서고에서 못 들여옴 — ${error instanceof Error ? error.message : error}`, "error");
+  }
+}
+
+/** 서고 구조물조합 — B08 [선택] 나무(마스터 · 회사 · 개인 · 보기만) */
+function pickCombo(ctx: TabContext, apply: ApplyRef): void {
+  void openItemPicker({ current: null, canCopy: false }).then((got) => {
+    if (got.action !== "apply") return;
+    const { layer, owner, key } = got.item;
+    void importLib(ctx, apply, { kind: "combo", layer, owner, key });
+  });
+}
+
+/** 서고 일위대가 사전조합 — M02 고르기 창 서고 줄만(층 단추 마스터 · 회사 · 개인) */
+function pickPrecombo(ctx: TabContext, apply: ApplyRef): void {
+  openLogicPicker(() => undefined, {
+    layer: "personal",
+    owner: null,
+    libOnly: true,
+    title: "일위대가 사전조합 고르기",
+    pick: (ref) =>
+      void importLib(ctx, apply, { kind: "precombo", layer: ref.층, owner: ref.주인, key: ref.키 }),
+  });
+}
+
 /** 항목 줄 연결 메뉴 — [고르기 셋, 그 밖(로직 입력값 · 연결 풀기)] · ref = 지금 연결 */
 export function linkItems(ctx: TabContext, ref: Row | null, apply: ApplyRef): [Leaf[], Leaf[]] {
   const more: Leaf[] = [];
@@ -95,6 +157,8 @@ export function linkItems(ctx: TabContext, ref: Row | null, apply: ApplyRef): [L
   const picks: Leaf[] = [
     ["일위대가 호표", () => pickHopyo(ctx, apply, "dg")],
     ["단가산출 호표", () => pickHopyo(ctx, apply, "sg")],
+    ["서고 구조물조합(마스터 · 회사 · 개인)", () => pickCombo(ctx, apply)],
+    ["서고 일위대가 사전조합(마스터 · 회사 · 개인)", () => pickPrecombo(ctx, apply)],
     [
       "단가산출 로직(M01 · 새 산근)",
       () => openLogicPicker((logic) => askInputs(apply, logic.키, logic.이름)),
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Groups.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Groups.ts
index 0bc6e9f87..313a30d7a 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Groups.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Groups.ts
@@ -7,10 +7,13 @@
  *   머리 줄 = 묶음 첫 줄 · 합계 줄 = 키 끝 `|합계` · `|총계` · 그 밖 = 몸 줄(표 줄 번호 그대로)
  *   목록표에서 온 호표(181-2) = 박스 붉은 외곽선 · 표 보기 = 그 호표 줄 구간 전체 붉은 외곽선
  *   보기 · 가로 열 수 기억 = `b_page_state`(`b09-group-view` · `b09-group-cols` · 탭마다) · 못 읽으면 카드 · 2
+ *   보기 단추 · 가로 열 수(202-1) = 페이지 보조 탭 줄 오른쪽(`setTools`) · 안내 글 = 표 · 카드 판 맨 아래
+ *   안내 글 길면 한 줄 줄임표 + 공용 호버로 전문(200-1)
  * ========================================================================== */
 
 import type { DataRow, DataTable } from "@ui/ui_template_data_table";
 import { createButton } from "@ui/ui_template_elements";
+import { attachHoverInfo } from "@ui/ui_template_hover_info";
 import {
   clampColumns,
   createGroupCards,
@@ -174,10 +177,18 @@ function numberFormat(spec: TabTable, key: string): (v: number | null | undefine
 
 /* ── 그리기 ───────────────────────────────────────────────────────────── */
 
+/** 안내 글 = 한 줄(줄임표) · 잘렸을 때만 마우스 올리면 전문(공용 호버 185-3) */
+function lineHint(hint: HTMLElement | null): HTMLElement | null {
+  if (!hint) return null;
+  hint.classList.add("b09-estimation__line-hint");
+  attachHoverInfo(hint, (el) => (el.scrollWidth > el.clientWidth ? el.textContent : null));
+  return hint;
+}
+
 /** 이 화면 안 보기(기억이 안 돼도 바꾼 보기 유지) */
 const chosen = new Map<TabId, GroupView>();
 
-/** 묶음 탭 — 카드 = 안내 + 카드 판(보기 단추는 가로 열 수 줄) · 표 = 머리(안내 + 보기 단추) + 표 */
+/** 묶음 탭 — 카드 = 카드 판 + 안내 글 · 표 = 표 + 안내 글 · 보기 단추 · 열 수 = `setTools`(보조 탭 줄 오른쪽) */
 export function renderGroupPanel(o: {
   tab: TabId;
   spec: TabTable;
@@ -186,8 +197,10 @@ export function renderGroupPanel(o: {
   goto: (link: Link | null) => void;
   makeTable: (rowClass?: (index: number) => string | null) => DataTable;
   redraw: () => void;
+  setTools: (tools: HTMLElement[]) => void;
 }): HTMLElement[] {
   const view = chosen.get(o.tab) ?? readGroupView(o.tab);
+  const lead = lineHint(o.hint);
   const toggle = createButton({
     label: viewLabel(view),
     variant: "ghost",
@@ -210,16 +223,15 @@ export function renderGroupPanel(o: {
       focus: at,
       money: numberFormat(o.spec, "sum"),
       qty: numberFormat(o.spec, "qty"),
-      actions: [toggle], // 185-2 가로 열 수 단추와 한 줄
+      actions: [toggle],
+      placeTools: o.setTools, // 202-1 가로 열 수 · 보기 단추 = 보조 탭 줄 오른쪽
     });
     cards.dataset.b09Table = o.tab;
-    return [...(o.hint ? [o.hint] : []), cards];
+    return [cards, ...(lead ? [lead] : [])];
   }
-  const bar = document.createElement("div");
-  bar.className = "b09-estimation__bar";
-  bar.append(...(o.hint ? [o.hint] : []), toggle);
+  o.setTools([toggle]);
   const range = pickRange(o.spec.rows, o.focus);
   const table = o.makeTable((i) => pickClass(range, i));
   if (at >= 0) requestAnimationFrame(() => table.focusRow(at));
-  return [bar, table.root];
+  return [table.root, ...(lead ? [lead] : [])];
 }
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts
index e50dfece3..50b500e2f 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts
@@ -12,6 +12,7 @@
 import type { DataRow } from "@ui/ui_template_data_table";
 import type { Row } from "./B09_Estimation_Calc_Base";
 import {
+  blockLevel,
   money,
   qty,
   text,
@@ -25,7 +26,7 @@ import { raw } from "./B09_Estimation_UI_Tabs_Sangeun";
 const EMPTY =
   "연결 없음 — 연결된 구조물 조합 사본(일위대가)이 없음 · B05 · B06 에서 조합을 고르고 [저장]";
 /** 하위 줄 앞 — 들여쓰기 + 「ㄴ」(공용 표가 앞 빈칸을 접지 않음) */
-const CHILD = "  ㄴ ";
+const CHILD = "ㄴ "; // 들여쓰기 = 공용 표 level(201-1)
 const ROUNDS = "줄 금액 ROUNDDOWN(단가 × 수량, 1) · % 줄 = 밑수 × % / 100 · 합계 ROUNDDOWN 0";
 const BLANK = "빈 줄 n = 금액 모르는 줄 · 합계 = 아는 줄 합 · 내역 단가엔 안 넘김";
 /** 「빈 줄 n」 작은 글 · 풍선 = 빈 줄 이름 */
@@ -122,7 +123,7 @@ export const buildDaegaBlocks: TabBuild = ({ sheets }): TabTable | string => {
     titles.add(rows.length);
     rows.push({
       key: `${b.id}|합계`,
-      name: "  합  계",
+      name: "합  계",
       sum: b.sum,
       labor: b.labor,
       material: b.material,
@@ -154,6 +155,7 @@ export const buildDaegaBlocks: TabBuild = ({ sheets }): TabTable | string => {
     hint: `단가 = B09 프로젝트 한 벌 굳힌 단가 · ${ROUNDS} · ${BLANK} · 줄 누름 = 단가를 낸 탭(대가 줄 = 그 블록)`,
     link: (i: number) => links[i] ?? null,
     rowClass: (i: number) => (titles.has(i) ? "is-title" : null),
+    level: blockLevel("name", (i) => titles.has(i)),
     tip: (i: number, key: string) =>
       key === "spec"
         ? raw(rows[i]?.spec, rows[i]?.spec_raw)
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts
index 1cf80dc9f..1776afdf3 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts
@@ -1,7 +1,7 @@
 /* =============================================================================
  * B09_Estimation_UI_Tabs_Sangeun.ts
  * B09 단가산출근거 · 단가산출근거목록표 탭(PLAN 145-1) — 값 = 서버 `B09_Estimation_Sangeun`
- * (서버 단독 · 이 탭엔 조작 없음 · [저장] · [단가 갱신] 때 서버가 다시 셈).
+ * (서버 단독 · 이 탭엔 조작 없음 · [저장] · [업데이트] 때 서버가 다시 셈).
  *
  *   목록표 = 산근 호표 한 줄(합계 · 노무비 · 재료비 · 경비 · 1 단위) · 줄 누름 = 그 블록
  *   풀이표(155-5 · 엑셀 단가산출근거 꼴) = 공종 · 산출내역(서버가 지은 텍스트 수식 한 칸) · 합계 ·
@@ -13,6 +13,7 @@
 import type { DataRow } from "@ui/ui_template_data_table";
 import type { Row } from "./B09_Estimation_Calc_Base";
 import {
+  blockLevel,
   money,
   qty,
   text,
@@ -99,7 +100,7 @@ export const buildSg: TabBuild = ({ sheets }): TabTable | string => {
       null,
       true,
     );
-    head.slice(1).forEach((line, n) => push({ key: `${b.key}|머리${n}`, text: `  ${line}` }));
+    head.slice(1).forEach((line, n) => push({ key: `${b.key}|머리${n}`, text: line }));
     (b.lines as Row[]).forEach((ln, n) => {
       const link = ln.ref?.key ? { tab: LINE_TAB[ln.ref.tab] ?? "compare", key: ln.ref.key } : null;
       const kind =
@@ -115,8 +116,8 @@ export const buildSg: TabBuild = ({ sheets }): TabTable | string => {
         push(
           {
             key: `${b.key}|${n}${part ? `|${part}` : ""}`,
-            kind: k === 0 ? kind : "",
-            text: `  ${texts[k] ?? fallback}`,
+            kind, // 같은 공종 줄 = 세로 병합(201-1)
+            text: texts[k] ?? fallback,
             sum: PARTS.some((p) => at(p) === null)
               ? null
               : PARTS.reduce((s, p) => s + (at(p) as number), 0),
@@ -162,6 +163,8 @@ export const buildSg: TabBuild = ({ sheets }): TabTable | string => {
       notes(sheets),
     link: (i: number) => links[i] ?? null,
     rowClass: (i: number) => (titles.has(i) ? "is-title" : null),
+    level: blockLevel("text", (i) => titles.has(i)),
+    mergeSame: ["kind"],
     tip: (i: number, key: string) =>
       key === "note" ? raw(rows[i]?.note, rows[i]?.note_raw) : null,
   };
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Summary.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Summary.ts
index 27d21fa0b..5fd4fba08 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Summary.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Summary.ts
@@ -24,7 +24,7 @@ const HINT =
 /** 안내 + 「연결 없음 n」(전개 안 한 내역 항목 — 조합 밖 토공 · 운반 산근 등) */
 const hint = (payload: Row, extra = ""): string => {
   const n = (payload.summary || {}).unlinked || 0;
-  return `${HINT}${extra}${n ? ` · 연결 없음 ${n} — 전개 안 함(연결 점검 탭)` : ""}`;
+  return `${HINT}${extra}${n ? ` · 연결 없음 ${n} — 전개 안 함(좌측 데이터 점검)` : ""}`;
 };
 
 /** 줄이 없을 때 표 위 맨 앞 안내 */
diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Total.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Total.ts
index 0614ea532..96a3691aa 100644
--- a/B09_Estimation/B09_Estimation_UI_Tabs_Total.ts
+++ b/B09_Estimation/B09_Estimation_UI_Tabs_Total.ts
@@ -8,8 +8,8 @@
  *          고칠 칸 = 요율 · 손입력(기초액 · 이윤 보정 · 부가세 조정 · 조달수수료율) ·
  *          엑셀에 없는 현행 비목 = 줄만(빈칸)
  *   원가계산서 = 총괄 값 거울 + 구성비 · 고칠 칸 = 간접재료비 · 작업설 · 줄 누름 = 총괄 그 줄로
- *   레벨(185-1) = 줄 `level`(화면이 정함 · 줄 짜임이 이 파일에 있음 · 셈 짝은 값만) → 182 is-lvN 글자 크기 ·
- *          들여쓰기 = 명칭 칸(is-indent) · 앞 칸(is-flat)은 그대로 · 1단 = 굵게(is-title)
+ *   레벨(185-1 · 201-1) = 줄 `level`(화면이 정함 · 줄 짜임이 이 파일에 있음 · 셈 짝은 값만) →
+ *          공용 표 level 옵션(명칭 칸 들여쓰기 · 보기 전용) · 1단 = 굵게(is-title)
  *          총괄 = 가.~바. 소계 1 · 그 밖 2 · 원가계산서 = 구분만 1 · 비목 소계 2 · 세목 3
  * ========================================================================== */
 
@@ -77,13 +77,12 @@ function clickEstimate(ctx: TabContext, rowKey: string, column: string, from: un
   ctx.setUser({ ...ctx.user, estimate });
 }
 
-/** 185-1 레벨 꼴 — 줄 class · 칸 class(들여쓰기 = 명칭 칸 · 앞 칸 그대로) */
-const levelClass = (r: DataRow | undefined): string | null =>
-  r ? `is-lv${r.level}${r.level === 1 ? " is-title" : ""}` : null;
-const indentClass =
-  (first: string, name: string) =>
-  (_i: number, key: string): string | null =>
-    key === name ? "is-indent" : key === first ? "is-flat" : null;
+/** 185-1 레벨 꼴 — 1단 = 굵게 · 들여쓰기 = 공용 표 level(명칭 칸) */
+const levelClass = (r: DataRow | undefined): string | null => (r?.level === 1 ? "is-title" : null);
+const nameLevel = (rows: DataRow[]) => ({
+  key: "name",
+  of: (i: number) => rows[i]?.level as number | undefined,
+});
 
 function rateText(formula: string, rate: Num): string {
   return rate === null ? `${formula}(요율 빈칸)` : formula.replace("율", `${rate}%`);
@@ -210,7 +209,8 @@ export const buildTotal: TabBuild = (ctx): TabTable => {
     rows,
     frozen: 2,
     rowClass: (i) => levelClass(rows[i]),
-    cellClass: indentClass("part", "name"),
+    level: nameLevel(rows),
+    mergeSame: ["part"],
     hint:
       "요율 = M01 조달청 제비율에서 자동(맨 위 고르는 값 · 공종 토목) — 칸에 적으면 사용자 값이 앞섬 · 지우거나 출처 칸 누르면 자동 · " +
       "2024 엑셀 요율과 연도 차로 다를 수 있음 · 자동도 없으면 그 줄 · 그 줄을 쓰는 소계 빈칸 · 끝수 = 엑셀 그대로(줄마다 원 버림 · 관급 천원 올림) · " +
@@ -290,7 +290,8 @@ export const buildCost: TabBuild = (ctx): TabTable => {
     rows,
     frozen: 3,
     rowClass: (i) => levelClass(rows[i]),
-    cellClass: indentClass("group", "name"),
+    level: nameLevel(rows),
+    mergeSame: ["group", "part"],
     hint: "총괄설계내역서 값 거울 · 구성비 = 총공사비 대비 · 고칠 칸 = 간접재료비 · 작업설(직접재료비가 그만큼 바뀌고 재료비 소계는 그대로 — 엑셀 꼴) · 줄 누름 = 총괄 그 줄",
     editable: (i, key) => key === "amount" && String(rows[i]?.key) in HAND,
     onEdit: (i, key, value) => editEstimate(ctx, String(rows[i]?.key), key, value),
diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py
index 0e95c8319..8cb590c58 100644
--- a/M01_MasterData/M01_MasterData_Store.py
+++ b/M01_MasterData/M01_MasterData_Store.py
@@ -26,6 +26,8 @@ import master_keys as mk  # noqa: E402
 import master_text as mtx  # noqa: E402
 
 from M01_MasterData import M01_MasterData_Store_Cache as cache  # noqa: E402
+from M01_MasterData.M01_MasterData_Store_Find import hit as _hit  # noqa: E402
+from M01_MasterData.M01_MasterData_Store_Find import squash as _squash  # noqa: E402
 from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape  # noqa: E402
 
 _COPY = os.environ.get("AISLO_MASTER_DIR")  # 화면 저장 시험 사본 폴더(정함 13) · 없으면 정본
@@ -88,11 +90,6 @@ def chapter_of(file: str, data: dict | None = None) -> str:
     return f"{division} {m.group(1)}장 {m.group(2).replace('_', ' ')}".strip()
 
 
-def _hit(row: dict, q: str) -> bool:
-    q = _squash(q)  # 띄어쓰기 무시 — 「골 함 석」 ↔ 「함석」
-    return not q or any(q in _squash(row.get(k, "")) for k in ("키", "원문번호", "이름", "옛이름"))
-
-
 def _book(data: dict) -> str | None:
     """머리 원문 이름 — 한 테이블 파일(기계)은 머리 「원문」 이 갈래 묶음이라 이름이 묶음 안에."""
     return data.get("원문") if isinstance(data.get("원문"), str) else None
@@ -367,6 +364,7 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "")
                             "소유",
                         )
                     },
+                    "별칭": row.get("별칭") or "",  # 없으면 빈칸(208-1)
                     "blocked": bool(reasons),
                     "reasons": reasons,
                 }
@@ -449,17 +447,14 @@ def elements(group: str, q: str, limit: int) -> dict:
             continue
         for row in data.get(items_key(data)) or []:
             if _hit(row, q):
-                hits.append({**_brief(str(row.get("키")), row), "file": name})
+                more = {"별칭": row.get("별칭") or ""} if group == "로직" else {}  # 208-1
+                hits.append({**_brief(str(row.get("키")), row), "file": name, **more})
     return {"total": len(hits), "items": hits[: min(max(limit, 1), 200)]}
 
 
 _PICK = {"price": "재료_자재품목.json", "job": "인력.json"}
 
 
-def _squash(text) -> str:
-    return "".join(str(text or "").lower().split())
-
-
 def _lowest(row: dict) -> object:
     """자재품목 줄 — 값 열 다섯 가운데 낮은 값(시험 계산용) · 값 칸이 있는 줄은 그 값 그대로."""
     if "값" in row:
diff --git a/M01_MasterData/M01_MasterData_Store_Find.py b/M01_MasterData/M01_MasterData_Store_Find.py
new file mode 100644
index 000000000..47b64ceba
--- /dev/null
+++ b/M01_MasterData/M01_MasterData_Store_Find.py
@@ -0,0 +1,20 @@
+"""찾기 맞춤 — 낱말(띄어 나눔)마다 키 · 원문번호 · 이름 · 옛이름 · 별칭 가운데 하나에 들면 맞음.
+
+띄어쓰기 · 대소문자 무시 · 별칭 = 설계자가 로직을 찾는 다른 이름(쉼표로 여럿 · 208-1).
+짝: `ui_template/ui_template_logic_find.ts` `matchLogic`(화면 쪽) ·
+거울 시험 `test_208_1_logic_alias.py`.
+"""
+
+from __future__ import annotations
+
+FIELDS = ("키", "원문번호", "이름", "옛이름", "별칭")
+
+
+def squash(text) -> str:
+    return "".join(str(text or "").lower().split())
+
+
+def hit(row: dict, q: str) -> bool:
+    words = [squash(w) for w in str(q or "").split()]
+    fields = [squash(row.get(k)) for k in FIELDS]
+    return all(any(w in f for f in fields) for w in words)
diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab.ts b/M01_MasterData/M01_MasterData_UI_LogicLab.ts
index 2dd75b26c..123b3ec9d 100644
--- a/M01_MasterData/M01_MasterData_UI_LogicLab.ts
+++ b/M01_MasterData/M01_MasterData_UI_LogicLab.ts
@@ -135,7 +135,10 @@ export async function mountM01LogicLab(
   const waiting = el("p", { className: "m01-logic__muted", text: tx("Loading") });
   let loaded = false; // 첫 목록이 오기 전에는 「0 줄」 빈 표를 보이지 않음
   const pending = el("span", { className: "m01-logic__muted" });
-  const list = buildList((item) => void open(item.id, item.sub, item.key));
+  const list = buildList(
+    (item) => void open(item.id, item.sub, item.key),
+    (item, alias) => void onAlias(item, alias),
+  );
   const back = createButton({ label: tx("Bar_Back"), variant: "ghost", onClick: () => show(null) });
 
   const persist = (): void => {
@@ -146,8 +149,10 @@ export async function mountM01LogicLab(
     }
     const marks = new Map<string, ListMark>();
     const extra: ListItem[] = [];
+    const aliases = new Map<string, string>();
     for (const [id, d] of Object.entries(drafts)) {
       marks.set(id, d.origKey === null ? "new" : d.row === null ? "deleted" : "edited");
+      if (d.row) aliases.set(id, d.row.별칭 ?? "");
       if (d.origKey === null && d.row) {
         extra.push({
           id,
@@ -156,6 +161,7 @@ export async function mountM01LogicLab(
           key: d.row.키,
           number: d.row.원문번호,
           name: d.row.이름,
+          alias: d.row.별칭 ?? "",
           unit: d.row.결과단위,
           source: d.row.출처,
           blocked: false,
@@ -163,7 +169,7 @@ export async function mountM01LogicLab(
         });
       }
     }
-    list.setMarks(marks, extra);
+    list.setMarks(marks, extra, aliases);
     const n = Object.keys(drafts).length;
     pending.textContent = n ? tx("Bar_Pending", { n }) : "";
     saveButton.disabled = discardButton.disabled = n === 0;
@@ -423,6 +429,26 @@ export async function mountM01LogicLab(
     persist();
   };
 
+  /** 목록 「별칭」 칸 고침(208-1) — 그 줄의 별칭만 바꿔 캐시에 · [저장] 때 다른 고침과 함께 나감 */
+  const onAlias = async (item: ListItem, alias: string): Promise<void> => {
+    const draft = drafts[item.id];
+    if (draft && !draft.row) return; // 지운 줄
+    try {
+      const one = draft?.origKey === null ? null : await fetchLogic(item.key);
+      const row = clone((draft?.row ?? one?.logic) as LogicRow);
+      if (alias) row.별칭 = alias;
+      else delete row.별칭;
+      if (one && JSON.stringify(row) === JSON.stringify(one.logic)) delete drafts[item.id];
+      else
+        drafts[item.id] = draft
+          ? { ...draft, row }
+          : { sub: item.sub, file: one!.file, version: one!.version, origKey: item.key, row };
+      persist();
+    } catch (error) {
+      showToast(error instanceof Error ? error.message : tx("Load_Failed"), "error");
+    }
+  };
+
   const onDelete = async (): Promise<void> => {
     if (!opened?.row) return;
     if (
diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts
index 0dcc8e932..947a8a044 100644
--- a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts
+++ b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts
@@ -42,6 +42,8 @@ export interface LogicRow {
   덧줄?: NamedFormula[];
   끝수?: string | null;
   비고?: string;
+  /** 설계자가 찾는 다른 이름 — 쉼표로 여럿 · 없으면 칸 없음(208-1) */
+  별칭?: string;
   [extra: string]: unknown;
 }
 
@@ -54,6 +56,8 @@ export interface LogicSummary {
   이름: string;
   결과단위: string;
   출처: string;
+  /** 없으면 빈칸(208-1) */
+  별칭?: string;
   blocked: boolean;
   reasons: string[];
 }
@@ -66,6 +70,8 @@ export interface ElementBrief {
   단위?: unknown;
   값?: unknown;
   값칸?: Record<string, string> | null;
+  /** 로직 그룹만 — 별칭(208-1) */
+  별칭?: string;
   /** 재료 후보 줄 — 값 열 다섯(지역·계약종별별 값) */
   값들?: Record<string, unknown>;
 }
diff --git a/M01_MasterData/M01_MasterData_UI_Logic_List.ts b/M01_MasterData/M01_MasterData_UI_Logic_List.ts
index d22b7ecde..cd9a4931d 100644
--- a/M01_MasterData/M01_MasterData_UI_Logic_List.ts
+++ b/M01_MasterData/M01_MasterData_UI_Logic_List.ts
@@ -2,9 +2,11 @@
  * M01_MasterData_UI_Logic_List.ts
  * 로직 목록 — 가운데 표 · 왼쪽 「전체」 + 구분 → 상세구분 거름이 고른 범위 + 이름 찾기
  * 파일을 가로질러 한 목록 · 쪽 나눔 · 막힘(⛔)·고침(●) 표시 · 거르기는 화면에서(목록은 한 번 받음)
+ * 「별칭」 열(208-1) — 이름 옆 · 고치면 `onAlias`(캐시에 쌓고 [저장] 때 나감) · 찾기는 공용 `matchLogic`
  * ========================================================================== */
 
 import { createInputField, el } from "@ui/ui_template_elements";
+import { aliasText, matchLogic } from "@ui/ui_template_logic_find";
 import { buildPager } from "./M01_MasterData_UI_Cells";
 import type { LogicSummary } from "./M01_MasterData_UI_Logic_Api";
 import { tx } from "./M01_MasterData_UI_Logic_Text";
@@ -19,6 +21,8 @@ export interface ListItem {
   key: string;
   number: string;
   name: string;
+  /** 쉼표로 여럿 · 없으면 빈칸 */
+  alias: string;
   unit: string;
   source: string;
   blocked: boolean;
@@ -28,8 +32,8 @@ export interface ListItem {
 export interface ListHandle {
   root: HTMLElement;
   setItems: (items: LogicSummary[]) => void;
-  /** 저장 안 한 새 로직도 목록 맨 위에 */
-  setMarks: (marks: Map<string, ListMark>, extra: ListItem[]) => void;
+  /** 저장 안 한 새 로직도 목록 맨 위에 · aliases = 캐시에 고친 별칭(id → 글) */
+  setMarks: (marks: Map<string, ListMark>, extra: ListItem[], aliases: Map<string, string>) => void;
   /** 왼쪽 거름이 고른 범위 — 비면 전체 */
   setPick: (sub: string, detail: string) => void;
   total: () => number;
@@ -38,12 +42,27 @@ export interface ListHandle {
 export const logicId = (sub: string, key: string): string => `${sub}\n${key}`;
 
 const SIZE = 30;
-const COLS = ["키", "원문번호", "구분", "상세구분", "이름", "결과 단위", "출처", ""] as const;
+const COLS = [
+  "키",
+  "원문번호",
+  "구분",
+  "상세구분",
+  "이름",
+  "별칭",
+  "결과 단위",
+  "출처",
+  "",
+] as const;
 
-export function buildList(onOpen: (item: ListItem) => void): ListHandle {
+export function buildList(
+  onOpen: (item: ListItem) => void,
+  onAlias: (item: ListItem, alias: string) => void,
+): ListHandle {
   let items: ListItem[] = [];
   let extra: ListItem[] = [];
   let marks = new Map<string, ListMark>();
+  let aliases = new Map<string, string>();
+  const aliasOf = (x: ListItem): string => aliases.get(x.id) ?? x.alias;
   let page = 1;
   const pick = { sub: "", detail: "" };
   const searchField = createInputField({ type: "search", placeholder: tx("List_Search") });
@@ -51,12 +70,19 @@ export function buildList(onOpen: (item: ListItem) => void): ListHandle {
   const grid = el("div", { className: "m01-master__grid-wrap" });
 
   const draw = (): void => {
-    const q = search.value.trim().toLowerCase();
+    const q = search.value;
     const shown = [...extra, ...items].filter(
       (x) =>
         (!pick.sub || x.sub === pick.sub) &&
         (!pick.detail || x.detail === pick.detail) &&
-        (!q || [x.key, x.number, x.name].some((v) => v.toLowerCase().includes(q))),
+        matchLogic(q, {
+          키: x.key,
+          원문번호: x.number,
+          이름: x.name,
+          구분: x.sub,
+          상세구분: x.detail,
+          별칭: aliasOf(x),
+        }).ok,
     );
     page = Math.min(page, Math.max(1, Math.ceil(shown.length / SIZE)));
     const rows = shown.slice((page - 1) * SIZE, page * SIZE).map(line);
@@ -87,24 +113,36 @@ export function buildList(onOpen: (item: ListItem) => void): ListHandle {
     ]
       .filter(Boolean)
       .join(" ");
+    const cell = (v: string): HTMLElement => el("td", { text: v, attrs: { title: v } });
     const tr = el("tr", {
       className: `m01-master__table-row${mark ? " is-changed" : ""}`,
       children: [
-        item.key,
-        item.number,
-        item.sub,
-        item.detail,
-        item.name,
-        item.unit,
-        item.source,
-        state,
-      ].map((v) => el("td", { text: v, attrs: { title: v } })),
+        ...[item.key, item.number, item.sub, item.detail, item.name].map(cell),
+        aliasCell(item, mark === "deleted"),
+        ...[item.unit, item.source, state].map(cell),
+      ],
     });
     if (item.blocked) tr.title = item.reasons.join("\n");
     tr.addEventListener("click", () => onOpen(item));
     return tr;
   };
 
+  /** 별칭 칸 — 눌러도 로직이 안 열림 · 고친 글은 「a, b」 꼴로 */
+  const aliasCell = (item: ListItem, locked: boolean): HTMLElement => {
+    const input = el("input", {
+      className: "m01-logic__alias",
+      attrs: { type: "text", value: aliasOf(item), placeholder: "—", title: tx("List_Alias") },
+    }) as HTMLInputElement;
+    input.disabled = locked;
+    input.addEventListener("click", (e) => e.stopPropagation());
+    input.addEventListener("change", () => {
+      const next = aliasText(input.value);
+      input.value = next;
+      if (next !== aliasOf(item)) onAlias(item, next);
+    });
+    return el("td", { children: [input] });
+  };
+
   search.addEventListener("input", () => go(1));
   let pager = buildPager(0, SIZE, 1, go);
 
@@ -128,6 +166,7 @@ export function buildList(onOpen: (item: ListItem) => void): ListHandle {
         key: x.키,
         number: x.원문번호,
         name: x.이름,
+        alias: x.별칭 ?? "",
         unit: x.결과단위,
         source: x.출처,
         blocked: x.blocked,
@@ -135,9 +174,10 @@ export function buildList(onOpen: (item: ListItem) => void): ListHandle {
       }));
       draw();
     },
-    setMarks: (next, more) => {
+    setMarks: (next, more, edited) => {
       marks = next;
       extra = more;
+      aliases = edited;
       draw();
     },
     setPick: (sub, detail) => {
diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Pick.ts b/M01_MasterData/M01_MasterData_UI_Logic_Pick.ts
index 9a7886955..cdeee432b 100644
--- a/M01_MasterData/M01_MasterData_UI_Logic_Pick.ts
+++ b/M01_MasterData/M01_MasterData_UI_Logic_Pick.ts
@@ -2,6 +2,7 @@
  * M01_MasterData_UI_Logic_Pick.ts
  * 고르기 두 가지
  *  ① 요소 찾기 창 — 그룹 전체에서 이름·키·원문번호로 찾아 호표 줄에 넣음(`GET /elements`)
+ *     로직 그룹은 별칭으로도 찾음(서버) · 별칭으로 맞은 줄은 그 별칭을 작게(공용 `matchLogic` · 208-1)
  *     표 고르기(소요량·계수)는 값칸 단추를 눌러 `찾기(…).칸` 으로 수량에 넣음
  *  ② 재료·기계 바꿔 고르기 — 구분 → 상세구분 → 후보 순으로 좁힘
  *     바꾼 것은 시험 계산용 복사본에만 · 정본 로직은 그대로
@@ -14,6 +15,7 @@ import {
   el,
   showToast,
 } from "@ui/ui_template_elements";
+import { aliasNote, matchLogic } from "@ui/ui_template_logic_find";
 import {
   fetchMaterials,
   searchElements,
@@ -77,7 +79,11 @@ export function openPicker(mode: PickMode, group: string, done: PickDone): void
       const found = await searchElements(select.value, search.value.trim());
       if (mine !== seq) return; // 최신 응답만
       count.textContent = tx("Pick_Total", { n: found.total });
-      list.replaceChildren(...found.items.map((item) => itemRow(item, mode, choose)));
+      const note = (item: ElementBrief): string =>
+        select.value === "로직"
+          ? aliasNote(matchLogic(search.value, { ...item, 키: item.ref, 이름: item.이름 }).alias)
+          : "";
+      list.replaceChildren(...found.items.map((item) => itemRow(item, mode, choose, note(item))));
     } catch (error) {
       showToast(error instanceof Error ? error.message : tx("Load_Failed"), "error");
     }
@@ -97,12 +103,16 @@ function itemRow(
   item: ElementBrief,
   mode: PickMode,
   choose: (item: ElementBrief, column?: string) => void,
+  note = "",
 ): HTMLElement {
   const text = el("div", {
     className: "m01-logic__stack",
     children: [
       el("strong", { text: `${item.이름 ?? ""} ${item.규격 ?? ""}`.trim() }),
-      el("span", { className: "m01-logic__muted", text: item.ref }),
+      el("span", {
+        className: "m01-logic__muted",
+        text: [item.ref, note].filter(Boolean).join(" · "),
+      }),
     ],
   });
   if (mode === "table") {
diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Style.css b/M01_MasterData/M01_MasterData_UI_Logic_Style.css
index 246bb49b9..db43968d9 100644
--- a/M01_MasterData/M01_MasterData_UI_Logic_Style.css
+++ b/M01_MasterData/M01_MasterData_UI_Logic_Style.css
@@ -266,6 +266,23 @@ input.m01-logic__input {
   font-size: var(--text-caption);
 }
 
+/* 목록 「별칭」 칸(208-1) — 칸 안 글 상자 · 테두리는 올렸을 때만 */
+.m01-logic__alias {
+  width: 160px;
+  padding: 2px var(--spacing-4);
+  border: 1px solid transparent;
+  border-radius: var(--radius-buttons);
+  background: transparent;
+  color: inherit;
+  font: inherit;
+}
+
+.m01-logic__alias:hover,
+.m01-logic__alias:focus {
+  border-color: var(--color-border);
+  background: var(--color-canvas);
+}
+
 .m01-logic__bad {
   color: var(--color-danger);
   font-size: var(--text-caption);
diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Text.ts b/M01_MasterData/M01_MasterData_UI_Logic_Text.ts
index c9090312b..6a7f7010a 100644
--- a/M01_MasterData/M01_MasterData_UI_Logic_Text.ts
+++ b/M01_MasterData/M01_MasterData_UI_Logic_Text.ts
@@ -7,7 +7,8 @@ import { currentLanguageIndex } from "@ui/ui_template_locale";
 
 const TEXT = {
   Title: ["단가산출 로직", "Unit-price logic"],
-  List_Search: ["이름 찾기", "Search name"],
+  List_Search: ["이름 · 별칭 찾기", "Search name or alias"],
+  List_Alias: ["별칭 — 쉼표로 여럿 · 고친 뒤 [저장]", "Aliases — comma separated · then [Save]"],
   List_AllBooks: ["원문 모두", "All sources"],
   List_AllChapters: ["장 모두", "All chapters"],
   List_BlockedOnly: ["막힘만", "Blocked only"],
diff --git a/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Build.ts b/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Build.ts
index a34d3c543..ebc94a459 100644
--- a/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Build.ts
+++ b/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Build.ts
@@ -17,6 +17,7 @@ import type {
   CfScope,
   CfVariable,
 } from "./M02_DF_Model";
+import { matchLogic } from "@ui/ui_template_logic_find";
 
 /** 입력 상자가 고르는 그룹 — 화면 차례 */
 export const GROUPS: CfGroup[] = [
@@ -285,21 +286,21 @@ export interface MasterLogicBrief {
   원문번호: string;
   이름: string;
   결과단위: string;
+  /** 쉼표로 여럿(208-1) */
+  별칭?: string;
   blocked?: boolean;
   reasons?: string[];
 }
 
-/** 찾기 — 띄어쓰기로 나눈 말을 모두 포함(이름 · 원문번호 · 키 · 구분 · 상세구분 · 띄어쓰기는 가리지 않음) · 원문(구분) · 장(상세구분) 거름 */
+/** 찾기 — 공용 `matchLogic`(띄어 나눈 말마다 이름 · 원문번호 · 키 · 구분 · 상세구분 · 별칭 · 208-1) · 원문(구분) · 장(상세구분) 거름 */
 export function filterLogics(
   items: MasterLogicBrief[],
   q: { text: string; book?: string; chapter?: string },
 ): MasterLogicBrief[] {
-  const words = q.text.split(/\s+/).map(squash).filter(Boolean);
   return items.filter((i) => {
     if (q.book && i.구분 !== q.book) return false;
     if (q.chapter && i.상세구분 !== q.chapter) return false;
-    const hay = squash(`${i.이름} ${i.원문번호} ${i.키} ${i.구분} ${i.상세구분}`);
-    return words.every((w) => hay.includes(w));
+    return matchLogic(q.text, i).ok;
   });
 }
 
diff --git a/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Logic.ts b/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Logic.ts
index 04e9a4c80..af44df841 100644
--- a/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Logic.ts
+++ b/M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Logic.ts
@@ -14,6 +14,7 @@ import {
   el,
   showToast,
 } from "@ui/ui_template_elements";
+import { aliasNote, matchLogic } from "@ui/ui_template_logic_find";
 import {
   fetchAuto,
   fetchLogic,
@@ -193,6 +194,11 @@ export function renderLogicInput(
                   children: [
                     el("strong", { text: i.이름 }),
                     el("span", { className: "m02-dfip__muted", text: ` ${i.원문번호}` }),
+                    // 별칭으로 맞았으면 그 별칭을 작게(208-1)
+                    el("span", {
+                      className: "m02-dfip__muted",
+                      text: ` ${aliasNote(matchLogic(q.input.value, i).alias)}`,
+                    }),
                     el("span", {
                       className: "m02-dfip__tag",
                       text: i.blocked ? t("Blocked") : i.상세구분,
diff --git a/M02_MasterTemplete/DataFlow/M02_DF_Panel.ts b/M02_MasterTemplete/DataFlow/M02_DF_Panel.ts
index 6462690e5..ec3901ac3 100644
--- a/M02_MasterTemplete/DataFlow/M02_DF_Panel.ts
+++ b/M02_MasterTemplete/DataFlow/M02_DF_Panel.ts
@@ -8,6 +8,7 @@
  * 고치는 핵심은 `M02_DF_Paper.ts`(판 DOM 을 옮겨 끼움).
  * ========================================================================== */
 
+import { isCtrlKey } from "../../A00_Common/key_shortcut";
 import { currentLanguageIndex } from "@ui/ui_template_locale";
 import { createButton, el } from "@ui/ui_template_elements";
 import { openModal } from "@ui/ui_template_modal";
@@ -209,7 +210,7 @@ export function mountFlowPanel(host: HTMLElement, opts: FlowPanelOpts): FlowPane
 
   const root = el("aside", { className: "m02-dfp", children: [grip, open, strip] });
   root.addEventListener("keydown", (ev) => {
-    if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === "z" && !ev.shiftKey) {
+    if (isCtrlKey(ev, "z") && !ev.shiftKey) {
       if ((ev.target as HTMLElement).closest("input, textarea, [contenteditable]")) return;
       ev.preventDefault();
       paper.undo();
@@ -258,7 +259,7 @@ export function mountFlowPanel(host: HTMLElement, opts: FlowPanelOpts): FlowPane
     });
     full.addEventListener("keydown", (ev) => {
       if (ev.key === "Escape" && !ev.defaultPrevented) shrink();
-      if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === "z" && !ev.shiftKey) {
+      if (isCtrlKey(ev, "z") && !ev.shiftKey) {
         if ((ev.target as HTMLElement).closest("input, textarea, [contenteditable]")) return;
         ev.preventDefault();
         paper.undo();
diff --git a/M02_MasterTemplete/M02_Item_Source.py b/M02_MasterTemplete/M02_Item_Source.py
index 717791ba8..597cb086c 100644
--- a/M02_MasterTemplete/M02_Item_Source.py
+++ b/M02_MasterTemplete/M02_Item_Source.py
@@ -132,8 +132,6 @@ def logic_rows(row: dict[str, Any]) -> dict[str, Any]:
 
 def build_source(item: dict[str, Any]) -> dict[str, Any]:
     """원본 층 · 마스터에서 항목 내용을 모음 — SS 줄이 없으면 LookupError."""
-    from M02_MasterTemplete import M02_Item_Prices as prices
-
     root = layer_root(item)
     row = row_of(read_json(root / layers.COMBO_FILE), item["key"])
     if row is None:
@@ -153,6 +151,14 @@ 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
+    files[PRICE_FILE] = price_bundle(labor, root)
+    return files
+
+
+def price_bundle(labor: dict[str, Any] | None, root: Path) -> dict[str, Any]:
+    """사본 단가 묶음(`단가.json`) — 담은 로직 · 굳힌 참조 로직 · 자재 · 고른 자재 · 사전조합 자재 ·
+    개인 자재(`root` = 원본 층 · B09 설계내역서 서고 사본도 이 길 · 204-2)."""
+    from M02_MasterTemplete import M02_Item_Prices as prices
     from M02_MasterTemplete import M02_Labor_Ref as refs
 
     logic_keys = [str(one.get("키")) for one in (labor or {}).get("로직", [])]
@@ -164,9 +170,9 @@ def build_source(item: dict[str, Any]) -> dict[str, Any]:
     ]
     materials += refs.frozen_materials((labor or {}).get("참조사본") or {})  # 175-2 사전조합 자재
     wanted = logic_keys + [code for code in materials if code]
-    files[PRICE_FILE] = prices.to_json(prices.collect(logic_keys, materials)) if wanted else {}
+    bundle = prices.to_json(prices.collect(logic_keys, materials)) if wanted else {}
     if mine := own.bundle(
         [c for c in materials if own.is_own(c)], root
     ):  # 개인 자재(148-3 · 사전조합 것도 175-2) — 원본 목록이 바뀌어도 사본 그대로
-        files[PRICE_FILE][own.BUNDLE] = mine
-    return files
+        bundle[own.BUNDLE] = mine
+    return bundle
diff --git a/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts b/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts
index e87486094..ea6c0e4b3 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_CardShell.ts
@@ -8,6 +8,7 @@
  * 접기는 부모의 attachCollapsible(제목 줄 클릭) — 오른쪽 단추를 눌러도 접히지 않음.
  * ========================================================================== */
 
+import { isCtrlKey } from "../A00_Common/key_shortcut";
 import { createButton, el, showToast } from "@ui/ui_template_elements";
 import { loadingError, showLoading } from "@ui/ui_template_loading";
 import { StaleError } from "./M02_MasterTemplete_Api_Fetch";
@@ -76,7 +77,7 @@ export function cardShell(opt: CardShellOptions): CardShell {
   const host = opt.stateHost ?? opt.body;
   let save: (() => void) | null = null;
   root.addEventListener("keydown", (event) => {
-    if (!save || !(event.ctrlKey || event.metaKey) || event.key.toLowerCase() !== "s") return;
+    if (!save || !isCtrlKey(event, "s")) return;
     event.preventDefault();
     save();
   });
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts
index 7dafc26ec..310825c63 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts
@@ -7,6 +7,7 @@
 
 import { createButton, createSelectField, el, showToast } from "@ui/ui_template_elements";
 import { createFindList } from "@ui/ui_template_find_list";
+import { aliasNote, matchLogic } from "@ui/ui_template_logic_find";
 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";
@@ -34,6 +35,9 @@ export interface LibraryPick {
   layer: Layer;
   owner: string | null;
   pick: (ref: LaborRef, name: string) => void;
+  /** 서고 줄만(로직 목록 안 받음 · B09 설계내역서 연결 204-2) · 창 제목 */
+  libOnly?: boolean;
+  title?: string;
 }
 
 /** 고를 수 있는 층 — 위 층만(마스터 → 마스터 · 회사 → 그 회사 · 마스터 · 개인 → 그 개인 · 그 회사 · 마스터) */
@@ -83,7 +87,7 @@ export function openLogicPicker(done: (logic: LogicSummary) => void, lib?: Libra
       (x) =>
         (!sub.select.value || x.구분 === sub.select.value) &&
         (!detail.select.value || x.상세구분 === detail.select.value) &&
-        (!q || `${x.키} ${x.이름}`.toLowerCase().includes(q)),
+        matchLogic(finder.search.value, x).ok, // 이름 · 키 · 별칭 …(공용 · 208-1)
     );
     const libFound = libRows.filter(
       (x) =>
@@ -103,7 +107,9 @@ export function openLogicPicker(done: (logic: LogicSummary) => void, lib?: Libra
         key: x.키,
         tag: tc("Kind_Logic"),
         name: x.이름,
-        sub: `${x.키} · ${x.구분} ${x.상세구분}`.trim(),
+        sub: [`${x.키} · ${x.구분} ${x.상세구분}`.trim(), aliasNote(matchLogic(q, x).alias)]
+          .filter(Boolean)
+          .join(" · "),
         unit: `${x.결과단위}${x.blocked ? ` · ${tc("Pick_Blocked")}` : ""}`,
         onPick: () => {
           close();
@@ -213,7 +219,7 @@ export function openLogicPicker(done: (logic: LogicSummary) => void, lib?: Libra
       el("div", {
         className: "m01-logic__section-head",
         children: [
-          el("h3", { text: tc("Pick_Title") }),
+          el("h3", { text: lib?.title ?? tc("Pick_Title") }),
           createButton({ label: tc("Pick_Close"), variant: "ghost", onClick: close }),
         ],
       }),
@@ -226,14 +232,15 @@ export function openLogicPicker(done: (logic: LogicSummary) => void, lib?: Libra
   document.body.append(backdrop);
   finder.search.focus();
 
-  void Promise.all([fetchLogicSubs(), fetchLogics()])
-    .then(([s, l]) => {
-      subs.push(...s);
-      all = l;
-      drawSubs();
-      find();
-    })
-    .catch((error) =>
-      showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error"),
-    );
+  if (!lib?.libOnly)
+    void Promise.all([fetchLogicSubs(), fetchLogics()])
+      .then(([s, l]) => {
+        subs.push(...s);
+        all = l;
+        drawSubs();
+        find();
+      })
+      .catch((error) =>
+        showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error"),
+      );
 }
diff --git a/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts b/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts
index 942642abd..38b78fe5f 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_TreePanel.ts
@@ -10,6 +10,7 @@
  * ========================================================================== */
 
 import "./M02_MasterTemplete_TreePanel.css";
+import { isCtrlKey } from "../A00_Common/key_shortcut";
 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";
@@ -598,7 +599,7 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
 
   body.addEventListener("keydown", (event) => {
     const row = (event.target as HTMLElement).closest<HTMLElement>("[data-node]");
-    if (!row && (event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "v") {
+    if (!row && isCtrlKey(event, "v")) {
       event.preventDefault(); // 빈 자리에 초점 = 맨 위에 붙여넣기
       return void paste([]);
     }
@@ -626,10 +627,10 @@ export function createTreePanel(opt: TreePanelOptions): TreePanelHandle {
       const many = picked.size > 1 && picked.has(row.dataset.node ?? "");
       if (many && api.many) void removeMany(pickedTargets());
       else if (!(target.kind === "folder" && !target.path.length)) void remove(target);
-    } else if (target && (event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "c") {
+    } else if (target && isCtrlKey(event, "c")) {
       event.preventDefault();
       copy(picked.has(row.dataset.node ?? "") ? pickedTargets() : [target]);
-    } else if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "v") {
+    } else if (isCtrlKey(event, "v")) {
       event.preventDefault(); // 붙일 자리 = 초점 줄이 폴더면 그 안 · 아니면 맨 위
       void paste(target?.kind === "folder" ? target.path : []);
     }
diff --git a/common_util/common_util_cross_design_geometry.ts b/common_util/common_util_cross_design_geometry.ts
index 80630a777..b67b2d67e 100644
--- a/common_util/common_util_cross_design_geometry.ts
+++ b/common_util/common_util_cross_design_geometry.ts
@@ -188,8 +188,11 @@ export class SectionGeometry {
     //   `hasDitch`** 로 가른다.
     // ⚠ 옛 저장분은 `ditchEnabled` 로 온다. 그 값은 **자동값과 다를 때만 뜻이 있다** —
     //   같으면 자동이 그렇게 냈던 것이고, 다르면 사용자가 일부러 바꾼 것이다.
+    // ⚠ 양측 성토는 **판정된 역할**로 가른다(206-1 · 짝: 파이썬) — 입력 `sectionMode` 는 옛
+    //   저장값일 수 있다. 입력으로 가르면 옛 측구 결과가 선택으로 둔갑해 양측 성토에 측구가 섰다.
+    const bothFill = this.leftRole === "fill" && this.rightRole === "fill";
     let autoDitch: boolean;
-    if (params.sectionMode === "both_fill") {
+    if (bothFill) {
       autoDitch = false;
     } else if (groundAt !== null) {
       const ditchEdge = params.ditchSide === "left" ? this.leftExtent : -this.rightExtent;
@@ -206,10 +209,10 @@ export class SectionGeometry {
     //   「자동으로 되돌리기」 단추가 없고, 원래 값으로 다시 누른 것을 선택으로 굳히면
     //   **다시 같은 병**이 된다.
     if (choice !== null && Boolean(choice) === autoDitch) choice = null;
-    // 양성(both_fill)은 측구가 설 자리가 없다 — 선택보다 기하가 먼저다.
-    this.hasDitch = choice === null || params.sectionMode === "both_fill" ? autoDitch : choice;
+    // 양성(both_fill)은 측구가 설 자리가 없다 — 선택보다 기하가 먼저 · 남은 선택은 비움.
+    this.hasDitch = choice === null || bothFill ? autoDitch : choice;
     /** 그 측점에 **사용자가 정한 선택**(없으면 자동). 결과와 갈라 내보낸다. */
-    this.ditchChoice = choice;
+    this.ditchChoice = bothFill ? null : choice;
 
     // 설계선 쉬프트 = 쪽마다 사면 이동(≥ 0 · 139-6 · 151-2) — 단면유형 · 측구 판정은 **옮기기 전**
     // 노견에서(위) · 노견(폭 고정) · 측구 · 사면이 같이 바깥으로 · 늘어난 폭은 차도. ⚠ 파이썬 짝 `_SectionGeometry`.
diff --git a/common_util/common_util_culvert_sets.ts b/common_util/common_util_culvert_sets.ts
index be2df5118..e1a92706a 100644
--- a/common_util/common_util_culvert_sets.ts
+++ b/common_util/common_util_culvert_sets.ts
@@ -51,12 +51,15 @@ export const BOX_COVER_M = 0.5;
 export const REVET_HEIGHT_STEP_M = 0.1;
 export const REVET_EMBED_DEPTH_M = 0.5;
 export const OLD_PIPE_WALL_DEFAULT_M = 1.5;
+/** 관 보호공 유입 흙막이 빈 칸 기본 = 관경(올림) + 0.7(211-1) — 유출 · 집수정은 근입 0.5 그대로. */
+export const INLET_REVET_ADD_M = 0.7;
 
-/** 관 벽 순수 높이(근입 포함) 기본값 — 파이썬 `pipe_wall_min_height_m`. */
-export function pipeWallMinHeightM(diameterM: number): number {
+/** 관 벽 순수 높이(근입 포함) 기본값 — 파이썬 `pipe_wall_min_height_m`. `side="inlet"` = + 0.7. */
+export function pipeWallMinHeightM(diameterM: number, side = ""): number {
   const raw = diameterM;
   const steps = Math.ceil(raw / REVET_HEIGHT_STEP_M - 1e-9);
-  return round(steps * REVET_HEIGHT_STEP_M + REVET_EMBED_DEPTH_M, 3);
+  const add = side === "inlet" ? INLET_REVET_ADD_M : REVET_EMBED_DEPTH_M;
+  return round(steps * REVET_HEIGHT_STEP_M + add, 3);
 }
 
 /** 관 벽 · 유입 집수정 높이 칸 읽기 — 옛 기본 1.5 이고 관경 > 1.0 이면 관경 기준 값(139-1) ·
@@ -71,7 +74,8 @@ export function pipeWallHeightM(stored: number | null, diameterM: number): numbe
   return stored;
 }
 
-/** 관 보호공 · 유입 집수정 높이 칸 — 새 관 기본 = 관경 + 0.5(139-1 · 서버 짝 `PIPE_HEIGHT_KEYS`). */
+/** 관 보호공 · 유입 집수정 높이 칸 — 새 관 기본 = 관경 + 0.5(139-1) · 유입 흙막이만 + 0.7(211-1)
+ *  (서버 짝 `PIPE_HEIGHT_KEYS`). */
 export const PIPE_HEIGHT_KEYS = [
   "inlet_revet_height_m",
   "outlet_revet_height_m",
@@ -86,12 +90,14 @@ export function fillPipeHeights(
   const diameterM = Number(values.pipe_diameter_mm) / 1000;
   if (!(diameterM > 0)) return;
   for (const key of PIPE_HEIGHT_KEYS)
-    if (keys.includes(key)) values[key] ??= pipeWallMinHeightM(diameterM);
+    if (keys.includes(key))
+      values[key] ??= pipeWallMinHeightM(diameterM, key === "inlet_revet_height_m" ? "inlet" : "");
 }
 
-/** 배관 관 보호공 높이 칸(유입 · 유출 · 유입 집수정 = 항목 `height`) — 관경 + 0.5 규칙(139-1).
+/** 배관 관 보호공 높이 칸(유입 · 유출 · 유입 집수정 = 항목 `height`) — 관경 + 0.5 규칙(139-1) ·
+ *  유입 흙막이 + 0.7(211-1).
  *  `previousMm` 없음 = 읽을 때(옛 1.5 · 관경 > 1.0 옮김) · 있음 = 관경을 바꿈(옛 관경 규칙 값 · 옛 1.5
- *  칸만 새 규칙 값으로 · 손 값 · 빈 칸은 그대로). */
+ *  칸만 새 규칙 값으로 · 손 값 · 빈 칸은 그대로 · 유입은 옛 + 0.5 값도 새 + 0.7 로 따라감). */
 export function followPipeHeights(
   state: Record<string, Array<Record<string, string>> | undefined>,
   diameterMm: string,
@@ -99,7 +105,13 @@ export function followPipeHeights(
 ): void {
   const d = Number(diameterMm) / 1000;
   if (!(d > 0)) return;
-  const prev = previousMm ? pipeWallMinHeightM(Number(previousMm) / 1000) : null;
+  const prevOf = (id: string): Array<number | null> => {
+    if (!previousMm) return [];
+    const p = Number(previousMm) / 1000;
+    return id === "inlet"
+      ? [pipeWallMinHeightM(p, id), pipeWallMinHeightM(p)]
+      : [pipeWallMinHeightM(p)];
+  };
   for (const id of ["inlet", "outlet"]) {
     const values = state[id]?.[0];
     const raw = values?.height ?? "";
@@ -108,8 +120,10 @@ export function followPipeHeights(
     const moved =
       previousMm === undefined
         ? pipeWallHeightM(now, d)
-        : [prev, OLD_PIPE_WALL_DEFAULT_M].some((v) => v !== null && Math.abs(now - v) < 1e-9)
-          ? pipeWallMinHeightM(d)
+        : [...prevOf(id), OLD_PIPE_WALL_DEFAULT_M].some(
+              (v) => v !== null && Math.abs(now - v) < 1e-9,
+            )
+          ? pipeWallMinHeightM(d, id)
           : now;
     if (moved !== null && moved !== now) values.height = String(moved);
   }
@@ -170,7 +184,7 @@ function sideSpec(
 
   const height =
     pipeWallHeightM(num(options[`${side}_revet_height_m`], null), diameterM) ??
-    pipeWallMinHeightM(diameterM);
+    pipeWallMinHeightM(diameterM, side);
   const length = num(options[`${side}_revet_length_m`], null);
   const form = text(options[`${side}_revet_form`]);
   const before = num(options[`${side}_revet_before_m`], null);
diff --git a/docs/raw/plans/2026-10-10_plan_200-219.md b/docs/raw/plans/2026-10-10_plan_200-219.md
new file mode 100644
index 000000000..ac59f594e
--- /dev/null
+++ b/docs/raw/plans/2026-10-10_plan_200-219.md
@@ -0,0 +1,126 @@
+# 2026-10-10 계획 200~219장 기록 — B09 박스보기 · 레벨 · 표 병합 · 안내 줄 · 데이터 점검 · 내역서 끌기 · 서고 연결 · 측구 · 알림 칩 · 별칭 · 상세 고르기 · 측점 겹침 · 단축키 · 자유지정 · 돋보기 · 방향키 흠
+
+근거 = `docs/raw/요구_1010_2/사용자요구_1010_2.md` 53~82 · 조사 AB(제비율 · 사용자 결정 기다림) · 메인 합침(이 커밋 앞).
+
+## 200. B09 박스보기 도구 줄 한 줄 · 카드 높이 맞춤 · 설계내역서 레벨 글 · 레벨 다루기 (sub1 · sub3)
+정함(브레인) = 사용자 53~55번 · 53 = 박스보기 단추 · 가로 1~4 단추 · 계산 안내 글(표 위 hint 줄)을 한 줄에(안내 글은 줄임표 + 호버로 전문) · 54 = 박스보기 같은 가로 줄 카드 높이 같게(grid 행 늘림) · 55 = 공종 · 명칭 글 왼쪽 맞춤 + 레벨 = 왼쪽 들여쓰기(글자 크기 차이는 줄이거나 없앰) · 레벨 다루기를 보이게: 표 위 도구 단추 [→ 들여쓰기] [← 내어쓰기] [↑] [↓](고른 줄) + 키(Tab · Shift+Tab · Alt+↑↓) + 안내 한 줄
+- [x] 200-1 (sub1) 도구 줄 한 줄(안내 글 포함) · 카드 같은 줄 높이 같게 — 새 시험
+  - 검증완료 — test_200_1(7) + test_185_2 · 171_2 · 171_3 · 181_2 · 157_2 = 32 통과 · typecheck 통과 · 안내 글 = 줄임표 + 잘릴 때만 공용 호버 · 카드 격자 행 늘림(stretch)
+- [x] 200-2 (sub3) 설계내역서 글 왼쪽 맞춤 · 들여쓰기 레벨 · 레벨 단추 · 키 · 안내 — 새 시험
+  - 검증완료 — test_200_2(4 · 단추 넷 · 못 하면 disabled · 키 셋 · 편집 중 안 먹음 · 레벨 padding 1em · 글 칸 왼쪽 맞춤) + 184_3 · 182 · 166_2 · 185_1 = 27 통과 · typecheck 통과
+- [x] 200-3 (sub1) 박스보기 카드 제목 줄 · 합계 줄 = 서로 다른 바탕색(밝음 · 어두움 테마 토큰) — 새 시험
+  - 검증완료 — test_200_1(10) + 185_2 · 171_2 · 171_3 · 181_2 · 157_2 = 35 통과 · typecheck 통과 · 토큰 `--group-head-bg`(강조 6%) · `--group-foot-bg`(강조 15%) = 테마 변수 섞음 · 밝음 · 어두움 두 색 차이 ≥ 40 · 글 대비 ≥ 4.5
+
+## 201. B08 · B09 표 레벨 양식 한 벌(보기 전용) · 같은 값 세로 병합 (sub3 · 200-2 뒤)
+정함(브레인) = 사용자 57번 · 레벨이 필요한 표(총괄 · 원가계산서 · 목록표 · 집계표 등)는 설계내역서 레벨 꼴(200-2 들여쓰기 · 굵기)을 공용 표 옵션 하나로 같이 씀 · 다루기 단추 · 키는 설계내역서만(나머지는 보기 전용) · 같은 열에 위아래로 같은 값이 이어지는 칸(공종 · 호표 이름 등 묶음 열) = 세로 병합(rowSpan)으로 그림 · 값 · 합계 · 엑셀 꼴은 그대로 · 병합할 열은 표마다 지정(아무 열이나 하지 않음)
+- [x] 201-1 공용 표 옵션 level(보기 전용) · mergeSame(열 목록) · B08 · B09 적용 표 목록 보고 — 새 시험
+  - 검증완료 — test_201_1(4 · level 들여쓰기 · 단추 없음 · rowSpan 같은 값만 · 빈칸 · 고칠 칸 · 합계 줄 안 합침 · 옵션 없으면 무변) + B08 · B09 관련 36 파일 212 통과(test_124 1건 = 받기 전부터 실패 · 손 안 댐) · typecheck 통과
+
+## 202. B08 · B09 표 칸 — 안내 · 경고 줄 = 맨 아래 · 박스보기 · 가로 수 = 보조 탭 줄 오른쪽 (sub1)
+정함(브레인) = 사용자 59번 · 표 칸 맨 위 안내 · 경고 줄(hint · 서버 안내)을 표 칸 맨 아래로(199 창 높이 셈에 그 줄 몫 넣음) · 박스보기 단추 · 가로 1~4 = 보조 탭 줄(181 · 170-4) 오른쪽 맞춤 · 보조 탭 없는 단독 탭은 빈 보조 줄 오른쪽 · 200-1 한 줄 묶음은 풂(안내 글은 아래로)
+- [x] 202-1 B08 · B09 표 칸 안내 줄 맨 아래 · 보기 단추 보조 탭 줄 오른쪽 — test_200_1 · 185_2 · 199_1 고침 · 새 시험
+  - 검증완료 — test_202_1(7) 새로 + 200_1 · 185_2 · 199_1 · 181_1 · 181_2 · 171_2 · 171_3 · 157_2 · 170 · 143_3 · B08 표 시험 = 192 통과 · typecheck 통과 · 안내 줄 = B09 표 · 카드 판 마지막 자식 · B08 토적 · 운반 · 자재 · 구조물 집계 표 아래 · 보기 단추 · 열 수 = 아래 탭 줄 오른쪽(빈 줄 포함) · 창 끝까지 셈에 아래 줄 134 포함 · 문서 끝 = 창 끝(900 = 900)
+
+## 203. B09 좌측 「데이터 점검」 묶음 — 이름 · 설명 지움 · [업데이트] 표시 · 연결 점검 옮김 (sub8)
+정함(브레인) = 사용자 60번 · 좌측 「원가 단가」 묶음 이름 → 「데이터 점검」 · 안 설명 글 지움(꼭 필요한 건 공용 호버로) · [단가 갱신] → [업데이트] · 갱신이 필요하면(굳힌 단가가 M01 · 사본보다 낡음 등 지금 판정 그대로) 단추에 점 배지(오버레이) · 상세 페이지 「연결 점검」 탭 내용 = 좌측 데이터 점검 묶음 안으로 옮기고 위 탭에서 뺌(181 묶음 표에서 지움 · 첫 탭 = 다음 탭)
+- [x] 203-1 이름 · 설명 · [업데이트] · 배지 · 연결 점검 좌측으로 · 탭 지움 — test_144 · 181_1 고침 · 새 시험
+  - 검증완료 — test_203_1(5 · 이름 · 설명 없음 · 단추 글 · 배지 조건 `book_stale` 넷 · 좌측 목록 이동 · 호버 · 탭 없음 · 첫 탭 cost) + 144 · 181_1 · 155 · B09 탭 시험 10 = 74 통과 · typecheck 통과 · 배지 판정 = 지금 M01 로 굳힌 책과 견줌(브레인 승인) 180 키 5 ms
+
+## 204. B09 설계내역서 — 끌기 · 방향키 레벨 · 이동 · 묶음 자동 · 서고 연결 (sub2 · sub6)
+정함(브레인) = 사용자 61번 · 레벨 = 들여 · 내어쓰기 하나 · 고른 줄(편집 중 아님) ←→ = 내어 · 들여쓰기 · ↑↓ = 옮기기(200-2 Tab · Alt 키도 그대로) · 끌기 = 줄 잡아 위아래(자리) + 좌우(레벨) · 줄을 옮기면 자손이 함께 감 · 자식이 생긴 줄 = 묶음(금액 = 자손 합 · 위로 전달) · 자식이 없어진 묶음 = 항목(제 단가 · 수량) · 깊이 5 · 관급 줄 규칙 그대로 · 연결 고르기 출처 = 지금 프로젝트 호표(일위대가 · 산근) + 마스터 · 회사 · 개인의 구조물조합 · 일위대가 사전조합 → 서고 것을 고르면 프로젝트 사본으로 들여와 새 호표로 잇기(B08 [선택] 사본 길 재사용)
+- [x] 204-1 (sub2) 방향키 · 끌기 · 자손 함께 · 묶음/항목 자동 · 합 전달(Calc_Bill 짝 거울) — 새 시험
+  - 검증완료 — test_204_1(6 · 방향키 넷 · Alt+←→ 안 받음 · 편집 중 안 먹음 · 끌기 자리 9 · 놓기 자손 함께 · 막음 5 · 깊이 · 항목 → 묶음 금액 = 자손 합 → 1.2 · 1 전달 · 빠지면 기본 표 그대로 · 거울 5) + 184_2 · 184_3 · 200_2 · 182 · 166_2 · 145_3 = 49 통과 · typecheck 통과 · 184_3 · 166_2 · 200_2 기대값 고침(위 항목 아래로 들여쓰기 됨 · 그냥 ↑ = 옮김)
+- [x] 204-2 (sub6) 연결 고르기 = 프로젝트 호표 + 서고 세 층 구조물조합 · 사전조합 · 고르면 사본 들여와 호표 · 단가 묶음 — 새 시험
+  - 검증완료 — test_204_2(6 · 사전조합 고름 = 사본 파일 셋 + 사전조합 호표 줄 3 + 단가 묶음 로직 · 자재 · 고른 자재 넷 + 수요 키 · 다시 고름 = 만듦 거짓 · 같은 호표 · 원본 지워도 그대로 · 구조물조합 = 조합 호표 · 없는 것 404 · 모양 400 · [저장] = 안 잇는 사본 지움 · lib 지킴 · 권한 남의 회사 403 · 회사 없는 개인 409 · 마스터 누구나 · 화면 출처 다섯 · 서고 줄만 창 · 원가 자료만 바꿔 끼움) + 182 · 166_2 · 184_3 · 184_2 · 175 · 145_2 · 155 · item_copy_complete · m02_labor_ref · m02_card_shell 등 = 200 통과 · typecheck 통과 · 182 출처 기대값 고침
+
+## 205. B05/B06 구조물 배치 묶음 [삭제] · [리셋] 단추 높이 · 늘 보임 (sub5) · 낡은 시험 둘 (sub3)
+정함(브레인) = 사용자 63번 · 묶음 머리 [삭제] · [리셋] 높이 = 안쪽 컨테이너 단추 높이(공용 단추 크기 토큰 · 187 꼴) · 안쪽 컨테이너에서도 [삭제] · [리셋]이 늘 보임(접힘 · 넘침 · 호버 때만 아님) · 낡은 시험 = test_124 화면 연결(자재 할증 글 rows[keep[i]]) · test_m02_card_sheet_edit(spreadsheet.ts 문구) 기대값만 지금 코드로
+- [x] 205-1 (sub5) 단추 높이 맞춤 · 늘 보임 — 새 시험
+  - 검증완료 — test_205_1(3) · test_187_1 · test_136_3 통과 · typecheck 통과 · 맨 아래 [추가]·[삭제]·[리셋] 줄 높이 약 33px → 26px(상자 안 단추 `--b05-control-h`) · 줄이 스크롤 영역 아래 끝에 붙음(sticky)
+- [x] 205-2 (sub3) 낡은 시험 둘 기대값 고침(코드 안 고침) — 두 시험 통과
+  - 검증완료 — test_124_b08_surcharge_panel · test_m02_card_sheet_edit 둘 파일 13 통과 · 코드 안 고침 · 미리보기 = 도구 줄 없음 · 우클릭 「복사」 한 줄(spreadsheet_menu 의 ss--preview) 같은 뜻 확인
+
+## 206. 양측 성토 측점에 측구가 남는 흠 · 단추 숨김으로 못 끔 — 검증_sub1 No.1+0 (sub7)
+정함(브레인) = 사용자 64번 · 확실히 조사 · 원인 고침 · 양측 성토 = 측구 없음이 형상(카드 · 서버 면적 · B07 · 3D)까지 같은 규칙 · 측구가 실제로 그려져 있으면 단추를 숨기지 않음(179-2 숨김은 「막힘 + 그려진 것 없음」일 때만) · 좌우 한 번 바꾸면 사라지는 까닭(옛 저장 측구 쪽 · 다시 셈 빠짐 등) 판정
+- [x] 206-1 원인 판정(자료 · 코드) · 고침 · 사본 재현 시험 — 새 시험
+  - 검증완료 — 원인 = 측구 판정의 「양측 성토」가 입력 단면유형(옛 저장 right_cut · 계획고 871.93 → 873.90)을 봄 · 옛 결과 ditch_enabled=True 가 선택으로 둔갑(ditch_choice=True) · 사본 재현 고치기 전 측구 0.18㎡ · 성토 34.1141(DB 34.114 · 0.18 같음) → 고친 뒤 측구 0 · 성토 34.0513 · 좌우 누름 = both_fill 입력으로 다시 셈이라 사라짐 · 고침 = 판정 역할(양쪽 성토)로 가름 · 남은 선택 비움(파이썬 · TS 짝) · 옛 저장분 낡음 판정 → B05 · B06 진입 때 다시 셈 · 측구 그려져 있으면 단추 보임 · test_206_1 11(고치기 전 11 실패) · 179_2 · ditch_choice · ditch_split · mirror · 178_2 · 115 · 137 · 139_6 · 172 · 176 · 193 · 194 · 195 · stale_sync 외 6 파일 합 142 통과 · typecheck 0
+
+## 207. B06 알림 칩 다듬기 — 사각 라운드 · 내용 칸 겹쳐 띄움 · 고르면 접힘 · 고른 측점 강조 (sub8)
+정함(브레인) = 사용자 65번 · 칩 셋 모양 = 둥근 사각(알약 아님) · 안 측점 단추는 지금 그대로 · 내용 칸 = 카드 위에 겹쳐 띄움(흐름에 끼지 않아 페이지 · 카드가 안 밀림 · sticky 줄 아래) · 측점 누르면 그 카드로 가며 내용 칸 접힘 · 지금 고른 측점(카드)이 있으면 열 때 목록에서 그 측점 강조
+- [x] 207-1 칩 모양 · 겹친 내용 칸 · 고르면 접힘 · 고른 측점 강조 — test_196_1 고침 · 새 시험
+  - 검증완료 — test_207_1(6 · 칩 반경 `--radius-buttons` 8px · 내용 칸 absolute(top 100% · 그림자 · 흐름 밖) · scroll-margin = 칩 줄 offsetHeight · 고르면 접힘 · 고른 측점 단추 강조 · 없으면 강조 없음) + test_196_1 · 138 둘 · fill_slope_warn · berm_review = 26 통과 · typecheck 통과
+
+## 208. M01 단가산출 로직 「별칭」 열 · 전역 검색에 별칭 포함 (sub4)
+정함(브레인) = 사용자 66번 · 로직 항목마다 선택 칸 alias(빈 값 허용 · 여러 개면 쉼표) · 값은 사용자가 M01 화면에서 넣고 [저장](코드는 마스터 파일에 값을 일괄로 쓰지 않음 · 없으면 빈칸으로 읽음) · 단가산출 로직을 찾는 모든 검색(M01 목록 · M01 고르기 창 · M02 로직 고르기 · B09 산근 · 연결 고르기 등)이 이름 + 별칭으로 찾음 · 검색 결과에 별칭이 맞았으면 그 별칭을 작게 보임
+- [x] 208-1 alias 칸(스키마 · 저장 · M01 열 · 편집) · 검색 함수 한 벌로 별칭 포함 · 쓰는 곳 목록 보고 — 새 시험
+  - 검증완료 — test_208_1(10 · 서버 hit ↔ 화면 matchLogic 거울 11가지 · 읽기 빈칸 · 임시 사본 저장 왕복 · 정본 파일 그대로 · M01 열 이름 옆 · 쓰는 곳 5곳 공용 맞춤) + m01 api · combo · make · pick · search_words · m02 df_input_logic · inputpanel_build · labor_logic_mats · card_shell · precombo_scope = 123 통과 · typecheck 통과
+
+## 209. B06 [상세] 그래프 고르기 — 교차점 분할 · 여러 개 고름(원지반 포함) · 고른 것 면적 · 길이 보기 (sub2)
+정함(브레인) = 사용자 67번 · 179-4 고르기 고침 · [상세] 모달만(메인 카드는 사용자가 본 뒤 정함) · 선(설계선 · 원지반선 · 구조물 선)을 서로 만나는 점에서 조각으로 나눔 · Shift/Ctrl 누름 = 여러 조각 고름 · 길이 = 고른 조각 합 · 면적 = 고른 조각이 닫힌 영역을 이루면 그 넓이(안 닫히면 「닫히지 않음」) · 고른 것 값 정보창(179-1 메인 길이 정보창 꼴 재사용) · 칸에 넣기 = 지금 우클릭 길 그대로 · 서버 검산(두 끝 · 조각 목록)
+- [x] 209-1 분할 · 여러 고름 · 닫힌 영역 넓이 · 정보창 · 칸 넣기 · 서버 검산 — test_179_4 고침 · 새 시험
+  - 검증완료 — test_209_1(9) · 179_4 · 164 · 150 둘 · 173 = 53 통과 · typecheck · 골 넓이 10.667㎡ 파이썬 = TS · 설계선 내리면 다시 고름
+
+## 210. B06 조사 둘 — 「누락된 구조물 측점」 줄이 뜨는 까닭 · 도수로/돌붙임 끌 때 「기준측점을 옮겼습니다」 (sub7 · 조사만)
+정함(브레인) = 사용자 68 · 70번 · 조사 · 보고만(코드 안 고침) · 자료 · 코드 근거 · 고칠 거리 제안 한 줄씩
+- [x] 210-1 두 현상 까닭 판정 · 보고(재현 조건 · 근거 · 제안)
+  - 조사완료 — ① 관 · 구조물 옮김 · 추가 뒤 측점 안 다시 뜸(검증 13곳 중 엄상준 263.31 하나 · 측점 263.21 과 0.100 m) · 반올림 차는 ≤ 0.005 m(sub4 최대 0.0050 · 소수 경계라 뜰 수 있음) ② 횡단도 도수로/돌붙임 · 관 고름 = 조정창 없음 → 방향키 ← → 가 종단도로 가 관 기준측점 0.1 m 이동(152-4 c924ee204 부터 · 관은 118-1) · 옮긴 관 둘(263.21 → 263.31 · 769.28 → 769.38)이 꼭 키 한 번
+
+## 211. 관보호공 유입 흙막이 기본 높이 = 관 + 0.7 m (sub1)
+정함(브레인) = 사용자 69번 · 지금 「관 + 0.5 m」 기본값 자리(코드 상수 · 파이썬 · TS 짝이면 둘 다 · 마스터 템플릿 값이면 그 한 줄) → 0.7 · 이미 저장된 값은 그대로 · 빈 값일 때만
+- [x] 211-1 기본 높이 0.5 → 0.7(짝 거울) — 새 시험
+  - 검증완료 — test_211_1_inlet_revet_height 6 통과(Φ1200 유입 빈 칸 1.9 · 유출 1.7 · 집수정 1.7 · 저장 1.2 그대로 · 옛 1.5 → 1.7 무변 · TS 세트 ↔ 파이썬 거울 · 횡단도 revetWallSpec 1.9 · 1.7 · B08 집계 열 1.5 · 1.3) · 관련 시험 69 통과 · npm run typecheck 오류 0
+
+## 212. B07 횡단 장 — 원지반선 고르기 다시 확인 · 측점별 레이어 자동 · 검은 격자선 지움 · 표준 옵션 단추 양식 (sub6)
+정함(브레인) = 사용자 71~74번 · 71 = 180-1 뒤에도 안 잡힘 → 실제 화면 길(확정 장 · 백엔드 재시작 전 옛 엔티티 · 잠금 층 · 고르기 필터)로 까닭 판정 후 고침 · 72 = 측점마다 레이어 자동 생성(예 「횡단 No.3」 · 그 측점 원지반선 · 설계선 · 구조물 그림이 그 층 · 표 · 글은 기존 층) · 층 관리에서 그 층만 고르기 · 켜고 끄기 · groupId 그대로 · DXF 층 이름 영향 확인 · 73 = 붉은 틀 숨김 뒤 남는 검은 격자선(인쇄 칸선과 다른 안내선이면 함께 숨김 · 인쇄 칸선이면 사용자 확인 거리로 보고) · 74 = 좌측 「횡단도」 표준 옵션 단추들(배치 칸 · 배율 · 안내선 · 열 · 행 등)을 공용 단추 양식 · 크기로 한 벌
+- [x] 212-1 원지반선 고르기 까닭 · 고침 — 새 시험
+  - 검증완료 — 까닭 = 새로 만든 장은 서버(검증_sub6 1장 원지반 16 개 · 층 잠금 거짓) · CAD 걸름(층 잠금 하나뿐) 모두 잡힘 → 안 잡힌 것은 180-1 앞 잠금째 저장된 확정 장 · 반영 전 서버 · 페이지 메모리 옛 도면 · 확정 장 열 때 원지반 잠금 풂 + 측점 층 없으면 stale_layers 안내 · test_212 6(옛 확정 장 원지반 거짓 · 도각 잠금 그대로)
+- [x] 212-2 측점별 레이어 자동 — 새 시험 · CAD build
+  - 검증완료 — 측점 층 + 종류는 색 · 선 꼴 · 2 × 2 장 층 4(b08-station-{측점} · 「횡단 No.0~3」) + 수량표 + 도각 · 종류 층 0 · 그림 자식 선까지 측점 층 · 표 · 글 수량표 층 · id · groupId 그대로 · design_ids · DXF 층 이름 = 측점 층 id · 140 · 174 · 180_* · 169 · 153_1 · cross_sheet_pad 44 통과 · vitest 126 · CAD build · typecheck 통과
+- [x] 212-3 검은 격자선 · 표준 옵션 단추 양식 — 새 시험
+  - 검증완료 — 검은 선 = 인쇄 칸선(도각 층 · #8ea0b5 · 밝은 바탕에서 짙게) → 안 지움 · 사용자 확인 거리 · 배치 칸 4 줄(열 · 행 / 이 장 · 모든 장 / 표 배율 · 적용 / 안내선) · 단추 · 숫자 칸 = --btn-bar-* 높이 16 · test_212_3 3 통과
+
+## 213. 한 자리에 측점 둘이 숨는 흠 — 엄상준_검증 No.13+3 (sub7 · 먼저)
+정함(브레인) = 사용자 76번 · 중요 · 되풀이 · 192(옮긴 관 · 옛 측점 남음 · 판정 폭 0.005 m)와 같은 갈래인지 판정 · 근본 원인 고침(측점이 생기는 모든 길 — 자동설계 · 관 지점 · 구조물 심음 · [측점 만들기] · 옮김 · 반올림 — 에서 같은 자리 두 벌이 안 생기게 · 생겨 있는 겹침은 읽을 때 하나로 정리) · 사용자 프로젝트 읽기만 · 사본 재현
+- [x] 213-1 13+3 자료 판정 · 근본 원인 · 고침 · 겹침 정리 · 재발 막는 시험 — 새 시험
+  - 검증완료 — test_213_1 7 통과(측점 0.006 m 안 꼭짓점 · 편집 키 모음 · 파이썬 = TS 거울 · 엄상준 사본 263.206/263.210 두 꼭짓점 → 하나 · 최대 경사 −15003% → 22.6% · [측점 만들기] 병합이 옛 글자 263.206 도 지움) · 검증 13 프로젝트 측점 계획고 변화 ≤ 1 mm · typecheck 오류 0
+
+## 214. CAD 되돌리기 · 다시 하기 — 한글 자판에서 Ctrl+Z · Y 안 먹는 흠 (sub8)
+정함(브레인) = 사용자 78번 · CAD 엔 되돌리기 · 다시 하기가 있음(빠른 막대 UNDO · REDO 단추 + Ctrl+Z · Ctrl+Y · Ctrl+Shift+Z) · 단 키 판정이 글자(evt.key === 'z')라 한글 자판이면 「ㅋ」로 와 안 먹음(Ctrl+V 는 이미 evt.code) → evt.code(KeyZ · KeyY)로 · 구조물조합(M02 도면 카드) · B07 · B08 구조물도 등 CAD 를 쓰는 모든 곳 같은 고침 · 부모 페이지에 초점이 있을 때 키가 CAD 로 안 가는지도 확인
+- [x] 214-1 키 판정 evt.code · 쓰는 곳 확인 · vitest · CAD build — 새 시험
+  - 고침: Ctrl+Z · Y · Shift+Z · S · A 를 자판 자리(code)로 판정(`input-shortcut.ts`) · 한글 조합 중에도 Ctrl 단축키는 먹음 · 제목줄 없는 M02 화면(양식 편집 · 구조물 카드)은 우하단 탐색 막대에 ↶ ↷ 단추 추가(고칠 수 있을 때만) · 포인터가 CAD 위에 오면 부모 입력 칸이 아닐 때 CAD 로 초점(`cad_host.ts`)
+  - 검증완료 — 새 vitest `resources/tester/cad/ctrl-shortcut-hangul.test.ts` 9 통과(key 「ㅋ」+KeyZ = 되돌리기 · 「ㅛ」+KeyY = 다시 하기 · Shift+KeyZ = 다시 하기 · 조합 중 Ctrl+Z) · openwebcad 전체 vitest 24 파일 126 통과 · CAD `npm run build` 통과 · `npm run typecheck` 통과 · prettier 통과
+
+## 215. B05 종단 [자유지정] — 범위 고르고 클릭으로 계획선 잇기 (sub5)
+정함(브레인) = 사용자 77 · 79번 · [직선화] 오른쪽 [자유지정] · ① 범위 = 직선화처럼 세로 측점선 둘 고름 · 그 구간 강조 ② 시작 세로선 근처 클릭 = 그 자리 지금 계획고에 이은 채 시작 ③ 클릭마다 점 하나 — 가로 = 가까운 측점 세로선에 붙음(범위 안 · 새 측점 안 만듦) · 높이 = 클릭한 높이 ④ 확정 전엔 실시간 점선(마지막 점 → 마우스 · 기울기 % 글 · 기준 넘으면 빨강) · 점 사이 직선 · 꺾이는 점엔 종단곡선 자동(지금 직선화 · 종단곡선 규칙 그대로) ⑤ 끝 세로선 근처 클릭 = 그 자리 지금 계획고에 이어 끝(Enter = 끝 · Esc = 취소 · Backspace = 마지막 점 빼기) ⑥ 끝내면 계획고 편집으로 캐시에(직선화 결과 길과 같음 · [저장] 때 서버 다시 셈)
+- [x] 215-1 [자유지정] 범위 · 클릭 점 · 측점선 붙음 · 실시간 점선 · 종단곡선 · 끝 · 취소 · 적용 — 새 시험
+  - 검증완료 — test_215_1 15 통과(79m 클릭 → 80m 세로선 · 103.456 → 103.46 · 세로 창 왕복 103.2 · 시작 40m 100.6 이음 · 미리 보기 7.15 % / −5.65 % · −58.65 % 빨강 · 끝 160m 102.4 이음 · 꺾인 80 · 120m 만 R(80m L 20 m) · 범위 밖 편집 0 · Esc 적용 0 · Backspace) · 종단 관련 기존 시험 97 통과 · typecheck 오류 0
+
+## 216. B05 종단 세로선 고름 → 좌측 구조물 배치 패널이 B06 처럼 안 따라가는 흠 (sub2)
+정함(브레인) = 사용자 80번 · B06 은 종단 세로선(관 지점 · 일반 측점) 고름에 좌측 구조물 배치 패널이 잘 바뀜 · B05 는 잘 안 됨 → 까닭 판정 후 B05 도 B06 과 같은 규칙(같은 함수)으로 · 188 고름 한 칸 · 189 노면공 · 177-3 측점선 규칙 그대로
+- [x] 216-1 까닭(코드 근거) · B05 고침 · 새 시험
+  - 검증완료 — 까닭 B05_Profile_UI_Selection 일반 측점 조기 return · 관 전용 selectPipeByChainage → openAtStation(resolveSelection + coversAtStation = B06 showAtChainage) · test_216_1 7 · 188_1 · 189_1 · 177_3 · selection_single 등 82 통과 · typecheck 0
+- [x] 213-2 (sub7 · 210 뒤) 유령 편집 근본 막음 — 정함(브레인): ① 관 · 구조물을 옮기면 그 자리 계획고 편집 키가 함께 옮겨 감(B05 · B06 movePipeTo · 구조물 끌기 · 세션 초안 · 옛 키 다시 보내지 않음) ② [저장] 때 서버가 「측점 · 관 · 구조물 자리 어디에도 없는」 편집 키를 버리고 응답 알림에 버린 자리 목록(사용자가 봄) ③ test_192_1 은 사용자 프로젝트 원본에 기대지 말고 사본 고정 자료로 — 새 시험
+  - 검증완료 — test_213_2 6 통과(226fc805 꼴 측점 769.38 + 옛 키 769.280 → 버림 [769.28] · 꼭짓점 하나 · 관만 옮긴 때 둘 다 지킴 · 자리 못 읽으면 안 버림 · followedStation TS 5 경우 · 옮김 자리 둘) · test_192_1 고정 사본 5 · 213_1 7 · missing_stations 통과 · 저장 왕복 · 초기선 시험 29 통과(노선 탐색 test_terrain_impossible 1 실패 = 엔진 몫 · 무관) · typecheck 0
+- [x] 214-2 (sub8) 프로그램 전역 Ctrl 단축키 한글 자판 — B05 종단 Ctrl+Z 등 글자 판정(evt.key)을 evt.code 로(214-1 input-shortcut 꼴 · 공용으로 올려 같이 씀) · grep 으로 다른 페이지도 — 새 시험
+  - 고침 — 공용 `A00_Common/key_shortcut.ts`(keyLetter · isCtrlKey · ctrlShortcut) · 쓰는 곳 8: CAD `input-shortcut.ts`(다시 내보냄) · B05 종단 Ctrl+Z(Panel_Tools) · B05 노선 편집 Ctrl+Z · Y(RouteEdit_History) · M02 흐름도 패널 Ctrl+Z ×2(DF_Panel) · M02 카드 Ctrl+S(CardShell) · M02 나무 Ctrl+C · V ×3(TreePanel) · 시트 Ctrl+Z · Y · A · D · R · F · H · L · V · 1(spreadsheet_keys · 조합 중에도) · 시트 actions 는 이미 code
+  - 검증완료 — 새 시험 ctrl-shortcut-hangul 13 · ctrl-shortcut-sheet 2(「ㅋ」+KeyZ · 「ㅛ」+KeyY · 「ㄹ」+KeyF) 통과 · openwebcad 전체 vitest 126 통과 · CAD build · typecheck 통과 · prettier 통과
+
+## 217. B06 알림 칩 줄 ↔ 횡단 카드 사이 여백 줄임 (sub1)
+정함(브레인) = 사용자 81번 · 칩 줄 위아래 여백 · 칩 줄과 첫 카드 줄 사이 간격을 절반쯤으로(공용 간격 토큰 한 단계 아래) · sticky · scroll-margin(--b06-notice-h) 그대로
+- [x] 217-1 여백 줄임 — 새 CSS 시험
+  - 검증완료 — test_217_1 신규 3 + test_196_1 · test_207_1 통과(16 passed) · typecheck 통과 · 칩 줄 위 여백 16→8 px · 칩 줄 ↔ 첫 카드 28→16 px
+
+## 218. B05~B09 돋보기 — 우클릭 길게 누름 · Z 키 누르는 동안 커서 따라감 (sub4)
+정함(브레인) = 사용자 82번 · 기본 = 지름 240 px 원 · 2배(나중에 바꿀 수 있게 상수 둘) · 켜는 법 = 오른쪽 단추 0.4 초 넘게 누르고 있는 동안(그때는 우클릭 메뉴 안 뜸) · Z 키 누르고 있는 동안(글 칸 입력 중엔 안 켬 · Ctrl/Alt 조합 아님) · 떼면 꺼짐 · 공용 ui_template 하나로 B05~B09 페이지에 붙임 · 켤 때 화면을 한 번 떠서(DOM 복제 + 2D canvas 그림 복사) 커서 따라 옮김(켜 있는 동안 화면이 바뀌면 다시 뜸 · WebGL 3D · CAD iframe 은 그림 복사 가능하면 · 안 되면 빈칸 · 보고) · 밝음 · 어두움 테두리 토큰
+- [x] 218-1 공용 돋보기 · 두 켜는 법 · B05~B09 붙임 · 새 시험
+  - 검증완료 — 새 시험 test_218_1_loupe 13(0.399 초 안 켬 · 0.4 초 켬 · 뗌 끔 · 길게 뒤 메뉴 막음 · 짧게 = 메뉴 그대로 · Z 켬/뗌 끔 · 글 칸 6 종 안 켬 · 240 px · 2배 · 화면 끝 4 px 안 잘림 · 끄면 복제 0 · 0.5 초 뒤 다시 뜸 · 붙는 주소 b05~b09 다섯) · native_menu 3 통과 · typecheck · prettier · ruff 통과
+  - 검증완료(218-2 공용 키 판정) — Z 판정 · 뗌 판정을 공용 key_shortcut keyLetter 로 바꿈(동작 그대로) · test_218_1_loupe 13 · ctrl-shortcut-hangul 13 · ctrl-shortcut-sheet 2 통과 · typecheck 통과
+- [x] 210-1 조사완료 — ① 측점 없는 구조물 줄 = 관 · 구조물 정본 자리에 0.005 m 안 측점 없음(옮김 · 반올림 경계 · 노선 밖) · 실측 엄상준 263.31 하나 ② 「기준 측점을 옮겼습니다」 = 횡단 보기에서 도수로 · 돌붙임 · 관을 고르면 조정창이 없어 방향키를 종단도 듣개(Panel_Tools)가 받아 관 기준측점 0.1 m 이동 · 저장까지 됨 → 192 · 213 숨은 측점의 씨앗
+
+## 219. 횡단 보기 방향키가 관을 몰래 옮기는 흠 · 측점 없는 구조물 판정 폭 (sub2)
+정함(브레인) = 210 조사 ② = 사용자가 요청하지 않은 관 이동이 저장까지 됨(데이터 오염 · 192 · 213 씨앗) → 고침 · 종단도 방향키 좌우 이동은 마지막 누름이 종단도 안일 때만(arrowsBelongToProfile 를 Panel_Tools 에도) · 도수로 · 돌붙임 고름 중 방향키 = 무시 · ① 판정 폭 0.005 → 0.006 m(213 측점 폭과 한 벌) · 노선 밖 자리 빼기
+- [x] 219-1 방향키 소속 · 판정 폭 · 노선 밖 — 새 시험
+  - 검증완료 — Panel_Tools 좌우 = arrowsBelongToProfile 때만 · 관 · 도수로 띠 고름 = swallowsArrows 삼킴 · 판정 폭 = SAME_STATION_SNAP_M 0.006 · 노선 밖 뺌 · test_219_1 9(카드 뒤 ← → 이동 0 · 종단도 뒤 263.21 → 263.31) · 188_1 · 216_1 · 193_1 · 126 · 213_1 · missing_stations 등 64 통과 · typecheck 0 · 192_1 원본 읽기 둘은 storage 226fc805 자료가 이미 고쳐져(10-10 14:54) 실패 — 고침과 무관
+  - 검증완료(219-2 헬퍼) — helper_219_1 가짜 모듈에 design_profile_free · design_profile_free_view(215-1 이 끄는 @config 줄기 차단) · 코드 손대지 않음 · test_219_1 · 215_1 · 188_1 · 216_1 39 통과
+- [x] 213-3 (sub7) design_profile.ts 700줄 닿음(합친 뒤 · 213-2 · 216 · 219 몫) → 기능 하나 떼어 650 안쪽 · test_215_1 「줄 수」 기준 = 700(규칙) — 시험 통과
+  - 검증완료 — design_profile.ts 700 → 641줄(유토곡선 · 테이블 오버레이 · 배지 = design_profile_overlays.ts 63 · 가로 스크롤 · 휠 · 크기 바뀜 = design_profile_viewport.ts 68 · 동작 그대로) · test_215_1 기준 700 · 215_1 · 213_1 · 213_2 · 216_1 · 219_1 · 188_1 · 177_3 · 165 · 129 · 최소고 · stale · 한 벌 종단 등 104 통과 · typecheck 0
diff --git a/docs/raw/요구_1010_2/조사_AB_제비율대조.md b/docs/raw/요구_1010_2/조사_AB_제비율대조.md
new file mode 100644
index 000000000..104228015
--- /dev/null
+++ b/docs/raw/요구_1010_2/조사_AB_제비율대조.md
@@ -0,0 +1,79 @@
+# 조사 AB — 제비율 대조 (요구 58 · 조사만)
+
+대상 = B09 총괄설계내역서 · 공사원가계산서 탭의 요율 줄 ↔ 원문 조달청 제비율표(2026.04.13판, 토목 갈래) · 예정가격작성기준 별표2 · 실무 엑셀(기번3 2024 · 소광 2025 · 거창 2026).
+
+## 1. 한눈 결론
+
+- 요율 값 자체는 맞음 — 프로그램이 자동으로 고르는 13줄(간접노무비~부가세)의 값 · 밑수 · 구간이 원문표와 모두 같음.
+- 큰 누락 넷 — 퇴직공제부금비 · 임금채권부담금 · 석면분담금 · 하도급대금지급보증수수료. 줄 이름만 있고 늘 빈칸이며 소계에도 안 들어감(M01 표엔 값이 있는데 셈이 안 씀).
+- 총괄 줄 자체가 없는 것 둘 — 폐기물처리비(실무 거창 · 소광에 있고, 09-07 사용자 확정 「필요」) · 공사손해보험료(원문 서식에 있음, 가입 대상일 때만).
+- 조건이 다른 것 — 연금 요율을 「오늘 날짜의 해」로 고름(설계 연도 칸 없음) · 조달수수료율 자동값 없음(빈칸 = 0) · 적용 조건(1억 이상 등) 확인 없음.
+- 실무 엑셀 차례는 기번3(2024) 꼴과 같음. 2026 실무(거창)에 비하면 퇴직공제 · 공사이행보증 · 폐기물처리비 줄이 빠짐.
+
+## 2. 대조 표
+
+프로그램 근거 약칭 — `CT` = `B09_Estimation/B09_Estimation_Calc_Total.py`(짝 `.ts` 같은 줄 구성) · `RT` = `B09_Estimation/B09_Estimation_Rates.py` · `UI` = `B09_Estimation/B09_Estimation_UI_Tabs_Total.ts` · `M01` = `resources/master_data/요율_조달청제비율.json` · 원문 = `현행_20260413.md` 줄.
+
+| 원문 비목 | 원문 요율 · 밑수 · 조건 | 프로그램 | 프로그램 근거 | 메모 |
+|---|---|---|---|---|
+| 간접노무비 (원문 8-31) | 직노 × 18.9~21.0% · 직접공사비 5구간 × 공기 4구간 · 토목 | 있음 · 같음 | CT:34,179 · RT:136 | 직접공사비 = 가.순공사비계 · 공기 = 사용자 칸(일) · 183/365/1095일 경계 맞음 |
+| 산재보험료 (원문 88) | 노무비 × 3.56% · 모든 건설공사 | 있음 · 같음 | CT:35,181 · RT:112 | 밑수 = 직노 + 간노 |
+| 고용보험료 (원문 91-105) | 노무비 × 1.01~1.57% · **추정금액** 등급 | 있음 · 밑수 조금 다름 | CT:36,182 · RT:127 | 등급을 **추정가격** 칸으로 고름. 임도 규모는 둘 다 7등급 이하 1.01% → 금액 차 없음 |
+| 건강보험료 (원문 85) | 직노 × 3.595% · 공기 1개월 이상 | 있음 · 같음 | CT:38,183 · RT:112 | 1개월 조건 확인 없음(임도는 늘 넘음) |
+| 노인장기요양 (원문 86) | 건강보험료 × 13.14% | 있음 · 같음 | CT:39,184 · RT:112 | |
+| 연금보험료 (원문 87) | 직노 × 4.75%(2026) · 해마다 오름(2027 5.00 …) | 있음 · **조건 다름** | CT:40,185,158 · RT:155-159 | 해 = 오늘 날짜의 해 → 2026 설계를 2027년에 다시 [저장]하면 5.00%로 바뀜 |
+| 산업안전보건관리비 (원문 107-125) | (재료비 + 직노 + 도급자설치 관급) × 3.15% / 2.53% + 330만 / 2.60% · 관급 있으면 A · B(× 1.2) 작은 쪽 · 총공사금액 2천만 이상 | 있음 · 조건 일부 다름 | CT:40,186-192 · RT:139-154 | B안도 A 대상액 구간의 요율 · 기초액을 씀(고시는 「관급 뺀 대상액으로 산출」 → 5억 · 50억 경계 근처에서만 차이) · 2천만 조건 확인 없음 · 1000억↑ 구간은 뺌(임도 밖) |
+| 기타경비 (원문 33-58) | (재료비 + 노무비) × 5.5~8.1% · 직접공사비 × 공기 | 있음 · 같음 | CT:41,193 · RT:137 | |
+| 환경보전비 (원문 127-143) | 직접공사비 × 0.9(도로) / 0.8(그 밖의 토목) · 추정금액 1억 이상 | 있음 · 조건 확인 없음 | CT:42,194 · RT:160-169 · UI:156-162 | 기본 = 그 밖 0.8 · 누르면 도로 0.9(지식DB도 미확정) · 1억 미만 공사에도 붙음 |
+| 건설기계대여대금 지급보증 (원문 171-173) | 직접공사비 × 0.4%(종합 토목) · 전문 0.1~0.68% | 있음 · 같음 | CT:43,195 · RT:115-126 | 거창 실무 0.1%(전문) — 사용자 칸으로 바꿀 수 있음 |
+| **퇴직공제부금비** (원문 152-154) | 직노 × 2.3% · 추정금액 1억 이상 | **줄만 · 늘 빈칸 · 소계 안 듦** | CT:46-52 · UI:169-173 · M01:1027 | ★ 누락. 거창 2026 실무 계상(5,603,907원). 원가계산서 탭엔 줄도 없음(UI:236-257) |
+| **임금채권부담금** (원문 150) | 노무비 × 0.09% · 모든 건설공사 | **줄만** | CT:48 · M01:1028 | ★ 누락 (2026.03.13 추가 항목) |
+| **석면분담금** (원문 149) | 노무비 × 0.006% · 모든 건설공사 | **줄만** | CT:49 · M01:1029 | ★ 누락 (〃) |
+| **하도급대금지급보증수수료** (원문 158-169) | 직접공사비 × 0.081%(추정가격 50억 미만) … · 전문공사 제외 | **줄만** | CT:50 · M01:1031 | ★ 누락. 임도를 종합공사로 내면 붙음 |
+| 공사이행보증수수료 (원문 175-185) | 직공비 구간식 × 공기(년) · 추정가격 300억 이상 등 의무 대상만 | 줄만 | CT:51 · M01:1110 | 임도는 통상 비대상 → 빈칸이 맞음. 원가계산서 탭엔 줄 없음 |
+| 일반관리비 (원문 60-70) | (재 + 노 + 경) × 8.0%(50억 미만) / 6.5 / 5.0 / 4.5 · 추정가격 | 있음 · 같음 | CT:55,197 · RT:128-134 | 원문 md 표는 병합 칸이라 「5억~50억」이 비어 보이나 실무 「26. 1. 1.」 시트로 50억 미만 = 8.0 확인 → M01 해석 맞음 |
+| 이윤 (원문 72-79) | (노 + 경 + 일반관리비) × 15 / 12 / 10 / 9% · 추정가격 · 상한 15%(예정가격작성기준 §21) | 있음 · 같음 | CT:56,199-200 · RT:135 | 사용자가 15% 넘게 적어도 막지 않음 |
+| 부가가치세 | 총원가 × 10% | 있음 · 같음 | CT:57,202-203 · RT:114 | |
+| 조달수수료 (조달수수료 고시 22-33) | 관급 순자재대 × 0.54%(단가계약 · 10억 이하) | 있음 · **자동값 없음** | CT:206-210 · UI:40 | 빈칸 시작 = 0 → 관급이 있어도 수수료 0. M01에 줄 없음 |
+| 공사손해보험료 (예정가격작성기준 §22 · 별표2) | 가입 대상 총원가(+ 관급) × 발주기관이 정한 율 | **없음** | — | 조달청 제비율표 밖 · 가입 대상일 때만 · 실무 셋 모두 없음 |
+| 폐기물처리비 (실무 거창 · 소광) | 요율 아님 · 실비 | **없음** | — | 거창 = 관급 뒤(총원가 밖) · 소광 = 이윤 뒤(총원가 안) — 자리 갈림 |
+| 간접재료비 · 작업설 | 손입력 | 있음 | UI:41-42 | |
+
+### 2-2. 실무 엑셀 차례와 비교
+
+| 실무 | 경비 줄 차례 | 프로그램과 차이 |
+|---|---|---|
+| 기번3 2024 총괄 49~67 (STmate) | 간노 · 산재 · 고용 · 건강 · 요양 · 연금 · 안전 · 기타경비 · 환경 · 건설기계 → 나.소계 · 일반관리비 · 이윤 · 부가세 · 관급 | **같음** (CT:33-58이 이 차례를 그대로 따름) |
+| 소광 2025 원가계산서 (STmate) | 기번3과 같음 + 이윤 뒤 「폐기물처리」 | 폐기물처리 줄 없음 |
+| 거창 2026 원가계산서 (26.1.1판) | … 연금 · 요양 · **퇴직공제** · 건설기계 · 안전(A · B 두 줄) · 환경 · **공사이행보증** · 기타경비 · … 관급 뒤 **폐기물처리비** | 퇴직공제 값 · 공사이행보증 줄(원가계산서) · 폐기물처리비 · 안전 비채택 줄(프로그램은 산식 글로만 A · B 표시 UI:191-193) |
+
+- 원문 4종(퇴직공제 · 임금채권 · 석면 · 하도급)은 실무 셋 중 거창에 퇴직공제만 있음 — 실무를 따라도, 원문을 따라도 프로그램에서 빠진 상태.
+
+## 3. 누락 · 다름 목록과 고칠 거리
+
+| # | 무엇 | 왜 문제 | 고칠 거리 | 크기 |
+|---|---|---|---|---|
+| A | 법정 비목 4개 셈 안 함 (퇴직공제 · 임금채권 · 석면 · 하도급) | 원문상 모든(또는 1억 이상) 임도에 붙는 돈이 빠짐. 직노 2.4억 공사(거창)면 퇴직공제만 약 560만 원 + 일반관리비 · 이윤 · 부가세 몫 | CURRENT_ONLY → RATE_LINES로 옮김 · `rate_table` 에 4줄(값 · 밑수는 M01에 이미 있음) · 원가계산서 줄 · 짝 TS · 거울 시험 | 중 |
+| B | 폐기물처리비 줄 없음 | 사용자가 「필요」로 확정한 줄. 실무 두 벌에 있음 | 손입력 줄 하나 · **자리(총원가 안/밖) 사용자 협의 먼저** | 소~중 |
+| C | 조달수수료율 자동값 없음 | 관급자재가 있는데 칸을 안 채우면 관급자재대가 수수료만큼 적게 나옴 | M01에 조달수수료 줄(0.54%) 추가 후 자동 · 또는 기본값 | 소 |
+| D | 연금 요율 해 = 오늘 해 | 해를 넘겨 다시 저장하면 요율이 저절로 바뀜 | 프로젝트 기준 연도(설계 · 입찰 연도) 칸으로 고름 | 소 |
+| E | 적용 조건 확인 없음 (환경보전비 · 퇴직공제 추정금액 1억 · 안전 2천만 · 건강 · 연금 1개월) | 소규모 공사에서 0 이어야 할 줄이 붙음 | M01 조건 칸(이미 있음 M01:113,954,1027)을 셈이 읽음 | 소 |
+| F | 안전관리비 B안 구간 | 관급을 넣어 대상액이 5억 · 50억을 넘을 때 B안 요율이 원문과 다를 수 있음 | B안은 관급 뺀 대상액으로 구간 다시 고름 | 소 |
+| G | 공사손해보험료 줄 없음 | 가입 대상 공사일 때 넣을 자리 없음 | 손입력 줄(율 · 기본 빈칸) | 소 |
+| H | 고용보험 등급 밑수 = 추정가격 | 원문은 추정금액. 임도 규모에선 금액 차 없음 | 메모만 · 또는 추정금액 칸 | 소 |
+| I | M01 처리규칙 글 「추정가격 빈칸이면 직접공사비로 수렴」 ↔ 코드는 빈칸이면 자동 없음(CT:93-95) | 글과 코드가 어긋남 → 추정가격을 안 적으면 일반관리비 · 이윤 · 고용 빈칸 | 글을 고치거나 수렴을 넣음(협의) | 소 |
+| J | 이윤 15% · 일반관리비 상한 확인 없음 | 사용자 값이 상한을 넘어도 그대로 | 넘으면 출처 칸에 경고 글 | 소 |
+
+- 요율 값 오류 · 밑수 오류는 못 찾음 (자동 고르는 13줄 전부 원문과 같음).
+- 원문은 조달청 발주 기준(「참고자료」 문구) — 지자체 · 산림청 발주용 별도 제비율은 지식DB에 없음. 지식DB는 근거 · 후보 가이드 — 위 고칠 거리의 값 · 자리는 사용자 협의로 확정.
+
+## 4. 근거 문서
+
+- 원문 제비율 — `resources/knowledge/original/행정규칙/토목공사원가계산 제비율 적용기준/현행_20260413.md` (원본 xlsx 같은 폴더 `첨부/`)
+- 원가 서식 · 비목 정의 — `resources/knowledge/original/행정규칙/(계약예규) 예정가격작성기준/현행_20260825.md` §19~22 · `별표/별표2_공사원가계산서.pdf`
+- 안전관리비 A · B — `resources/knowledge/original/행정규칙/건설업 산업안전보건관리비 계상 및 사용기준/현행_20250212.md` 44줄
+- 조달수수료 — `resources/knowledge/original/행정규칙/조달수수료 고시/현행_20250701.md` 22-33줄
+- 지식DB 정리 — `resources/knowledge/technical_info/01_임도/05_원가정보/제비율.md` · `원가계산_체계.md` · `original/실무문서/_종합비교/01_원가_제비율.md`
+- 실무 엑셀 — 기번3 `2024년 간선임도(기번3-울진.대흥)(공통)/…xlsx` (공사원가계산서 · 총괄설계내역서 49~67) · 소광 `25년 산불진화임도(기번8)(울진소광)/…xlsx` (공사원가계산서) · 거창 `01.산불거창(거창북상병곡)/01.내역서/…xlsx` (원가계산서 · 「26. 1. 1.」 시트)
+- 이전 결정 — `docs/raw/plans/2026-09-08_plan_B08_실무자료_해독기록.md` 8-13 · 8-14 (퇴직공제 · 공사이행보증 · 폐기물처리비 「필요」 사용자 확정 · 법정 4종 발견)
+- 프로그램 — `B09_Estimation/B09_Estimation_Calc_Total.py` · `.ts` · `B09_Estimation_Rates.py` · `B09_Estimation_UI_Tabs_Total.ts` · `B09_Estimation_Store.py` 41-52 · `resources/master_data/요율_조달청제비율.json`
diff --git a/resources/tester/cad/ctrl-shortcut-hangul.test.ts b/resources/tester/cad/ctrl-shortcut-hangul.test.ts
new file mode 100644
index 000000000..d7ed6b090
--- /dev/null
+++ b/resources/tester/cad/ctrl-shortcut-hangul.test.ts
@@ -0,0 +1,149 @@
+/**
+ * Ctrl 단축키 — 한글 자판에서도 먹는다(PLAN 214-1 CAD · 214-2 페이지 공용 `A00_Common/key_shortcut.ts`).
+ * 한글 자판은 key 가 「ㅋ」·「ㅛ」 · Shift 는 대문자 — 영문이 아니면 자판 자리(code)로 판정한다.
+ * 실행: cd B07_DesignDetail/openwebcad && npx vitest run --dir ../../resources/tester/cad ctrl-shortcut-hangul
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../B07_DesignDetail/openwebcad/src/state.ts", async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  undo: vi.fn(),
+  redo: vi.fn(),
+}));
+
+import { ctrlShortcut } from "../../../B07_DesignDetail/openwebcad/src/inputController/input-shortcut";
+import { InputController } from "../../../B07_DesignDetail/openwebcad/src/inputController/input-controller";
+import { redo, undo } from "../../../B07_DesignDetail/openwebcad/src/state";
+
+const press = (controller: InputController, extra: Partial<KeyboardEvent>) => {
+  const preventDefault = vi.fn();
+  controller.handleKeyStroke({
+    key: "",
+    code: "",
+    keyCode: 0,
+    isComposing: false,
+    shiftKey: false,
+    ctrlKey: true,
+    altKey: false,
+    metaKey: false,
+    repeat: false,
+    target: null,
+    preventDefault,
+    stopPropagation: vi.fn(),
+    ...extra,
+  } as unknown as KeyboardEvent);
+  return preventDefault;
+};
+
+describe("ctrlShortcut — 자판 자리(code)로 판정", () => {
+  const k = (code: string, extra = {}) =>
+    ctrlShortcut({ ctrlKey: true, altKey: false, shiftKey: false, code, ...extra });
+  it("KeyZ = 되돌리기 · Shift+KeyZ · KeyY = 다시 하기", () => {
+    expect(k("KeyZ")).toBe("undo");
+    expect(k("KeyZ", { shiftKey: true })).toBe("redo");
+    expect(k("KeyY")).toBe("redo");
+  });
+  it("KeyS = 저장 · KeyA = 전부 고르기 · Shift 면 아님", () => {
+    expect(k("KeyS")).toBe("save");
+    expect(k("KeyA")).toBe("selectAll");
+    expect(k("KeyS", { shiftKey: true })).toBeNull();
+    expect(k("KeyA", { shiftKey: true })).toBeNull();
+  });
+  it("Ctrl 없음 · Alt(AltGr) 함께 · 다른 자리는 아님", () => {
+    expect(k("KeyZ", { ctrlKey: false })).toBeNull();
+    expect(k("KeyZ", { altKey: true })).toBeNull();
+    expect(k("KeyX")).toBeNull();
+  });
+});
+
+describe("키 입력 — 한글 자판", () => {
+  beforeEach(() => {
+    vi.mocked(undo).mockClear();
+    vi.mocked(redo).mockClear();
+  });
+
+  it("Ctrl+「ㅋ」(KeyZ) = 되돌리기", () => {
+    const controller = new InputController();
+    const prevented = press(controller, { key: "ㅋ", code: "KeyZ" });
+    expect(undo).toHaveBeenCalledTimes(1);
+    expect(redo).not.toHaveBeenCalled();
+    expect(prevented).toHaveBeenCalled();
+  });
+
+  it("Ctrl+「ㅛ」(KeyY) = 다시 하기", () => {
+    const controller = new InputController();
+    press(controller, { key: "ㅛ", code: "KeyY" });
+    expect(redo).toHaveBeenCalledTimes(1);
+    expect(undo).not.toHaveBeenCalled();
+  });
+
+  it("Ctrl+Shift+「ㅋ」(KeyZ) = 다시 하기", () => {
+    const controller = new InputController();
+    press(controller, { key: "ㅋ", code: "KeyZ", shiftKey: true });
+    expect(redo).toHaveBeenCalledTimes(1);
+    expect(undo).not.toHaveBeenCalled();
+  });
+
+  it("영문 자판 Ctrl+Shift+Z(key 「Z」) = 다시 하기 · Ctrl+Z = 되돌리기", () => {
+    const controller = new InputController();
+    press(controller, { key: "Z", code: "KeyZ", shiftKey: true });
+    expect(redo).toHaveBeenCalledTimes(1);
+    press(controller, { key: "z", code: "KeyZ" });
+    expect(undo).toHaveBeenCalledTimes(1);
+  });
+
+  it("한글 조합 중(keyCode 229 · key Process)에도 Ctrl+Z 는 먹음", () => {
+    const controller = new InputController();
+    press(controller, { key: "Process", code: "KeyZ", keyCode: 229, isComposing: true });
+    expect(undo).toHaveBeenCalledTimes(1);
+  });
+
+  it("조합 중 Ctrl 없는 키는 여전히 IME 에 넘김", () => {
+    const controller = new InputController();
+    const prevented = press(controller, {
+      key: "Process",
+      code: "KeyZ",
+      keyCode: 229,
+      isComposing: true,
+      ctrlKey: false,
+    });
+    expect(undo).not.toHaveBeenCalled();
+    expect(prevented).not.toHaveBeenCalled();
+  });
+});
+
+// ---- 공용 판정 · 페이지(214-2) — 같은 함수를 B05 · M02 · 시트 키가 씀 ----
+import { isCtrlKey, keyLetter } from "../../../A00_Common/key_shortcut";
+
+describe("keyLetter · isCtrlKey — 페이지 공용", () => {
+  it("한글 자판 key 「ㅋ」 + KeyZ = z · 영문 · 대문자도 소문자 · 숫자", () => {
+    expect(keyLetter({ key: "ㅋ", code: "KeyZ" })).toBe("z");
+    expect(keyLetter({ key: "ㅊ", code: "KeyC" })).toBe("c");
+    expect(keyLetter({ key: "ㅍ", code: "KeyV" })).toBe("v");
+    expect(keyLetter({ key: "ㄴ", code: "KeyS" })).toBe("s");
+    expect(keyLetter({ key: "Z", code: "KeyZ" })).toBe("z");
+    expect(keyLetter({ key: "1", code: "Digit1" })).toBe("1");
+    expect(keyLetter({ key: "Process", code: "Digit1" })).toBe("1");
+  });
+  it("다른 자판 배열(key 가 영문)은 key 를 따름 · 글자 아닌 키는 빈 글", () => {
+    expect(keyLetter({ key: "z", code: "KeyY" })).toBe("z"); // 독일식 자리 바뀜
+    expect(keyLetter({ key: "Enter", code: "Enter" })).toBe("");
+    expect(keyLetter({ key: "Escape", code: "Escape" })).toBe("");
+  });
+  it("code 없는 합성 사건은 key 로", () => {
+    expect(keyLetter({ key: "Z", code: "" })).toBe("z");
+  });
+  it("isCtrlKey — Ctrl · ⌘ 만 · 글자 맞아야", () => {
+    const e = (extra: object) => ({
+      key: "ㅋ",
+      code: "KeyZ",
+      ctrlKey: false,
+      metaKey: false,
+      ...extra,
+    });
+    expect(isCtrlKey(e({ ctrlKey: true }), "z")).toBe(true);
+    expect(isCtrlKey(e({ metaKey: true }), "z")).toBe(true);
+    expect(isCtrlKey(e({}), "z")).toBe(false);
+    expect(isCtrlKey(e({ ctrlKey: true }), "y")).toBe(false);
+  });
+});
diff --git a/resources/tester/cad/ctrl-shortcut-sheet.test.ts b/resources/tester/cad/ctrl-shortcut-sheet.test.ts
new file mode 100644
index 000000000..0ae376b44
--- /dev/null
+++ b/resources/tester/cad/ctrl-shortcut-sheet.test.ts
@@ -0,0 +1,60 @@
+/**
+ * 시트 키 — 한글 자판에서도 Ctrl 단축키(PLAN 214-2).
+ * 실행: cd B07_DesignDetail/openwebcad && npx vitest run --config ../../resources/tester/cad/vitest.ui.config.ts
+ */
+import { describe, expect, it } from "vitest";
+import { attachKeys } from "../../../A00_Common/spreadsheet/spreadsheet_keys";
+
+describe("시트 키 — 한글 자판 Ctrl 단축키", () => {
+  const setup = () => {
+    const log: string[] = [];
+    const handlers: ((e: KeyboardEvent) => void)[] = [];
+    const ed = {
+      ta: {
+        addEventListener: (_: string, fn: (e: KeyboardEvent) => void) => handlers.push(fn),
+        removeEventListener: () => {},
+      },
+      formula: { addEventListener: () => {}, removeEventListener: () => {} },
+      editing: () => false,
+    };
+    const ctx = {
+      undo: () => log.push("undo"),
+      redo: () => log.push("redo"),
+      readOnly: false,
+      sheet: () => ({}),
+      selection: {},
+    };
+    attachKeys(ctx as never, ed as never, {
+      find: (replace: boolean) => log.push(replace ? "replace" : "find"),
+    });
+    const press = (extra: object) =>
+      handlers[0]({
+        key: "",
+        code: "",
+        keyCode: 0,
+        isComposing: false,
+        ctrlKey: true,
+        metaKey: false,
+        shiftKey: false,
+        altKey: false,
+        target: null,
+        preventDefault: () => {},
+        stopPropagation: () => {},
+        ...extra,
+      } as unknown as KeyboardEvent);
+    return { log, press };
+  };
+  it("「ㅋ」 = 되돌리기 · 「ㅛ」 = 다시 하기 · Shift+「ㅋ」 = 다시 하기", () => {
+    const { log, press } = setup();
+    press({ key: "ㅋ", code: "KeyZ" });
+    press({ key: "ㅛ", code: "KeyY" });
+    press({ key: "ㅋ", code: "KeyZ", shiftKey: true });
+    expect(log).toEqual(["undo", "redo", "redo"]);
+  });
+  it("「ㄹ」(KeyF) = 찾기 · 「ㅗ」(KeyH) = 바꾸기 · 조합 중에도", () => {
+    const { log, press } = setup();
+    press({ key: "ㄹ", code: "KeyF" });
+    press({ key: "Process", code: "KeyH", keyCode: 229, isComposing: true });
+    expect(log).toEqual(["find", "replace"]);
+  });
+});
diff --git a/resources/tester/cad/vitest.ui.config.ts b/resources/tester/cad/vitest.ui.config.ts
new file mode 100644
index 000000000..11ce23b73
--- /dev/null
+++ b/resources/tester/cad/vitest.ui.config.ts
@@ -0,0 +1,8 @@
+/** 페이지 코드(`@ui` 별칭을 쓰는 것)를 시험하는 vitest 설정 — 시험은 `ctrl-shortcut-sheet.test.ts`. */
+const root = new URL("../../..", import.meta.url).pathname.replace(/^\/(\w:)/, "$1");
+
+export default {
+  root,
+  resolve: { alias: { "@ui": `${root}ui_template` } },
+  test: { include: ["resources/tester/cad/ctrl-shortcut-sheet.test.ts"] },
+};
diff --git a/resources/tester/fixtures/b05_192_1_moved_pipe_longitudinal.json b/resources/tester/fixtures/b05_192_1_moved_pipe_longitudinal.json
new file mode 100644
index 000000000..35b41b64f
--- /dev/null
+++ b/resources/tester/fixtures/b05_192_1_moved_pipe_longitudinal.json
@@ -0,0 +1,2592 @@
+{
+ "_note": "192-1 · 213 시험 고정 자료 — 검증_랩탑메인 226fc805 종단 460~840m 사본, 측점 769.38 → 769.28(192 이전 상태: 관 769.28 → 769.38 옮김 뒤 측점은 옛 자리)",
+ "length_m": 1153.190099,
+ "samples": [
+  {
+   "chainage_m": 460.0,
+   "elevation_m": 854.399565,
+   "z": 854.399565,
+   "valid": true
+  },
+  {
+   "chainage_m": 461.0,
+   "elevation_m": 854.323496,
+   "z": 854.323496,
+   "valid": true
+  },
+  {
+   "chainage_m": 462.0,
+   "elevation_m": 854.357254,
+   "z": 854.357254,
+   "valid": true
+  },
+  {
+   "chainage_m": 463.0,
+   "elevation_m": 854.688311,
+   "z": 854.688311,
+   "valid": true
+  },
+  {
+   "chainage_m": 464.0,
+   "elevation_m": 854.65229,
+   "z": 854.65229,
+   "valid": true
+  },
+  {
+   "chainage_m": 465.0,
+   "elevation_m": 854.144385,
+   "z": 854.144385,
+   "valid": true
+  },
+  {
+   "chainage_m": 466.0,
+   "elevation_m": 854.23999,
+   "z": 854.23999,
+   "valid": true
+  },
+  {
+   "chainage_m": 467.0,
+   "elevation_m": 854.150669,
+   "z": 854.150669,
+   "valid": true
+  },
+  {
+   "chainage_m": 468.0,
+   "elevation_m": 854.010948,
+   "z": 854.010948,
+   "valid": true
+  },
+  {
+   "chainage_m": 469.0,
+   "elevation_m": 854.011239,
+   "z": 854.011239,
+   "valid": true
+  },
+  {
+   "chainage_m": 470.0,
+   "elevation_m": 853.905926,
+   "z": 853.905926,
+   "valid": true
+  },
+  {
+   "chainage_m": 471.0,
+   "elevation_m": 854.180391,
+   "z": 854.180391,
+   "valid": true
+  },
+  {
+   "chainage_m": 472.0,
+   "elevation_m": 854.284507,
+   "z": 854.284507,
+   "valid": true
+  },
+  {
+   "chainage_m": 473.0,
+   "elevation_m": 854.276427,
+   "z": 854.276427,
+   "valid": true
+  },
+  {
+   "chainage_m": 474.0,
+   "elevation_m": 854.545725,
+   "z": 854.545725,
+   "valid": true
+  },
+  {
+   "chainage_m": 475.0,
+   "elevation_m": 855.185317,
+   "z": 855.185317,
+   "valid": true
+  },
+  {
+   "chainage_m": 476.0,
+   "elevation_m": 855.976081,
+   "z": 855.976081,
+   "valid": true
+  },
+  {
+   "chainage_m": 477.0,
+   "elevation_m": 855.928803,
+   "z": 855.928803,
+   "valid": true
+  },
+  {
+   "chainage_m": 478.0,
+   "elevation_m": 855.427162,
+   "z": 855.427162,
+   "valid": true
+  },
+  {
+   "chainage_m": 479.0,
+   "elevation_m": 855.599991,
+   "z": 855.599991,
+   "valid": true
+  },
+  {
+   "chainage_m": 480.0,
+   "elevation_m": 856.590036,
+   "z": 856.590036,
+   "valid": true
+  },
+  {
+   "chainage_m": 481.0,
+   "elevation_m": 857.426487,
+   "z": 857.426487,
+   "valid": true
+  },
+  {
+   "chainage_m": 482.0,
+   "elevation_m": 857.39277,
+   "z": 857.39277,
+   "valid": true
+  },
+  {
+   "chainage_m": 483.0,
+   "elevation_m": 857.479369,
+   "z": 857.479369,
+   "valid": true
+  },
+  {
+   "chainage_m": 484.0,
+   "elevation_m": 855.607648,
+   "z": 855.607648,
+   "valid": true
+  },
+  {
+   "chainage_m": 485.0,
+   "elevation_m": 854.222329,
+   "z": 854.222329,
+   "valid": true
+  },
+  {
+   "chainage_m": 486.0,
+   "elevation_m": 853.720087,
+   "z": 853.720087,
+   "valid": true
+  },
+  {
+   "chainage_m": 487.0,
+   "elevation_m": 853.627091,
+   "z": 853.627091,
+   "valid": true
+  },
+  {
+   "chainage_m": 488.0,
+   "elevation_m": 853.70957,
+   "z": 853.70957,
+   "valid": true
+  },
+  {
+   "chainage_m": 489.0,
+   "elevation_m": 853.516046,
+   "z": 853.516046,
+   "valid": true
+  },
+  {
+   "chainage_m": 490.0,
+   "elevation_m": 853.192759,
+   "z": 853.192759,
+   "valid": true
+  },
+  {
+   "chainage_m": 491.0,
+   "elevation_m": 853.280064,
+   "z": 853.280064,
+   "valid": true
+  },
+  {
+   "chainage_m": 492.0,
+   "elevation_m": 853.367633,
+   "z": 853.367633,
+   "valid": true
+  },
+  {
+   "chainage_m": 493.0,
+   "elevation_m": 853.434346,
+   "z": 853.434346,
+   "valid": true
+  },
+  {
+   "chainage_m": 494.0,
+   "elevation_m": 853.337047,
+   "z": 853.337047,
+   "valid": true
+  },
+  {
+   "chainage_m": 495.0,
+   "elevation_m": 852.855864,
+   "z": 852.855864,
+   "valid": true
+  },
+  {
+   "chainage_m": 496.0,
+   "elevation_m": 853.017523,
+   "z": 853.017523,
+   "valid": true
+  },
+  {
+   "chainage_m": 497.0,
+   "elevation_m": 853.224828,
+   "z": 853.224828,
+   "valid": true
+  },
+  {
+   "chainage_m": 498.0,
+   "elevation_m": 853.151205,
+   "z": 853.151205,
+   "valid": true
+  },
+  {
+   "chainage_m": 499.0,
+   "elevation_m": 852.744451,
+   "z": 852.744451,
+   "valid": true
+  },
+  {
+   "chainage_m": 500.0,
+   "elevation_m": 852.29905,
+   "z": 852.29905,
+   "valid": true
+  },
+  {
+   "chainage_m": 501.0,
+   "elevation_m": 852.33224,
+   "z": 852.33224,
+   "valid": true
+  },
+  {
+   "chainage_m": 502.0,
+   "elevation_m": 852.356165,
+   "z": 852.356165,
+   "valid": true
+  },
+  {
+   "chainage_m": 503.0,
+   "elevation_m": 852.283422,
+   "z": 852.283422,
+   "valid": true
+  },
+  {
+   "chainage_m": 504.0,
+   "elevation_m": 852.09869,
+   "z": 852.09869,
+   "valid": true
+  },
+  {
+   "chainage_m": 505.0,
+   "elevation_m": 851.991606,
+   "z": 851.991606,
+   "valid": true
+  },
+  {
+   "chainage_m": 506.0,
+   "elevation_m": 851.942009,
+   "z": 851.942009,
+   "valid": true
+  },
+  {
+   "chainage_m": 507.0,
+   "elevation_m": 851.261328,
+   "z": 851.261328,
+   "valid": true
+  },
+  {
+   "chainage_m": 508.0,
+   "elevation_m": 851.424119,
+   "z": 851.424119,
+   "valid": true
+  },
+  {
+   "chainage_m": 509.0,
+   "elevation_m": 851.353731,
+   "z": 851.353731,
+   "valid": true
+  },
+  {
+   "chainage_m": 510.0,
+   "elevation_m": 851.190865,
+   "z": 851.190865,
+   "valid": true
+  },
+  {
+   "chainage_m": 511.0,
+   "elevation_m": 851.012716,
+   "z": 851.012716,
+   "valid": true
+  },
+  {
+   "chainage_m": 512.0,
+   "elevation_m": 850.742907,
+   "z": 850.742907,
+   "valid": true
+  },
+  {
+   "chainage_m": 513.0,
+   "elevation_m": 850.597659,
+   "z": 850.597659,
+   "valid": true
+  },
+  {
+   "chainage_m": 514.0,
+   "elevation_m": 850.698391,
+   "z": 850.698391,
+   "valid": true
+  },
+  {
+   "chainage_m": 515.0,
+   "elevation_m": 850.745868,
+   "z": 850.745868,
+   "valid": true
+  },
+  {
+   "chainage_m": 516.0,
+   "elevation_m": 850.773431,
+   "z": 850.773431,
+   "valid": true
+  },
+  {
+   "chainage_m": 517.0,
+   "elevation_m": 850.970436,
+   "z": 850.970436,
+   "valid": true
+  },
+  {
+   "chainage_m": 518.0,
+   "elevation_m": 850.928337,
+   "z": 850.928337,
+   "valid": true
+  },
+  {
+   "chainage_m": 519.0,
+   "elevation_m": 850.859021,
+   "z": 850.859021,
+   "valid": true
+  },
+  {
+   "chainage_m": 520.0,
+   "elevation_m": 851.187557,
+   "z": 851.187557,
+   "valid": true
+  },
+  {
+   "chainage_m": 521.0,
+   "elevation_m": 851.375589,
+   "z": 851.375589,
+   "valid": true
+  },
+  {
+   "chainage_m": 522.0,
+   "elevation_m": 851.534681,
+   "z": 851.534681,
+   "valid": true
+  },
+  {
+   "chainage_m": 523.0,
+   "elevation_m": 851.68768,
+   "z": 851.68768,
+   "valid": true
+  },
+  {
+   "chainage_m": 524.0,
+   "elevation_m": 851.930171,
+   "z": 851.930171,
+   "valid": true
+  },
+  {
+   "chainage_m": 525.0,
+   "elevation_m": 851.97661,
+   "z": 851.97661,
+   "valid": true
+  },
+  {
+   "chainage_m": 526.0,
+   "elevation_m": 852.094679,
+   "z": 852.094679,
+   "valid": true
+  },
+  {
+   "chainage_m": 527.0,
+   "elevation_m": 852.211098,
+   "z": 852.211098,
+   "valid": true
+  },
+  {
+   "chainage_m": 528.0,
+   "elevation_m": 852.230928,
+   "z": 852.230928,
+   "valid": true
+  },
+  {
+   "chainage_m": 529.0,
+   "elevation_m": 852.394254,
+   "z": 852.394254,
+   "valid": true
+  },
+  {
+   "chainage_m": 530.0,
+   "elevation_m": 852.636398,
+   "z": 852.636398,
+   "valid": true
+  },
+  {
+   "chainage_m": 531.0,
+   "elevation_m": 852.892311,
+   "z": 852.892311,
+   "valid": true
+  },
+  {
+   "chainage_m": 532.0,
+   "elevation_m": 853.103535,
+   "z": 853.103535,
+   "valid": true
+  },
+  {
+   "chainage_m": 533.0,
+   "elevation_m": 853.244656,
+   "z": 853.244656,
+   "valid": true
+  },
+  {
+   "chainage_m": 534.0,
+   "elevation_m": 853.379518,
+   "z": 853.379518,
+   "valid": true
+  },
+  {
+   "chainage_m": 535.0,
+   "elevation_m": 853.419451,
+   "z": 853.419451,
+   "valid": true
+  },
+  {
+   "chainage_m": 536.0,
+   "elevation_m": 853.478335,
+   "z": 853.478335,
+   "valid": true
+  },
+  {
+   "chainage_m": 537.0,
+   "elevation_m": 853.812764,
+   "z": 853.812764,
+   "valid": true
+  },
+  {
+   "chainage_m": 538.0,
+   "elevation_m": 854.099244,
+   "z": 854.099244,
+   "valid": true
+  },
+  {
+   "chainage_m": 539.0,
+   "elevation_m": 854.189474,
+   "z": 854.189474,
+   "valid": true
+  },
+  {
+   "chainage_m": 540.0,
+   "elevation_m": 854.273041,
+   "z": 854.273041,
+   "valid": true
+  },
+  {
+   "chainage_m": 541.0,
+   "elevation_m": 854.25719,
+   "z": 854.25719,
+   "valid": true
+  },
+  {
+   "chainage_m": 542.0,
+   "elevation_m": 854.3265,
+   "z": 854.3265,
+   "valid": true
+  },
+  {
+   "chainage_m": 543.0,
+   "elevation_m": 854.394984,
+   "z": 854.394984,
+   "valid": true
+  },
+  {
+   "chainage_m": 544.0,
+   "elevation_m": 854.628286,
+   "z": 854.628286,
+   "valid": true
+  },
+  {
+   "chainage_m": 545.0,
+   "elevation_m": 854.699286,
+   "z": 854.699286,
+   "valid": true
+  },
+  {
+   "chainage_m": 546.0,
+   "elevation_m": 854.36337,
+   "z": 854.36337,
+   "valid": true
+  },
+  {
+   "chainage_m": 547.0,
+   "elevation_m": 854.071547,
+   "z": 854.071547,
+   "valid": true
+  },
+  {
+   "chainage_m": 548.0,
+   "elevation_m": 853.961326,
+   "z": 853.961326,
+   "valid": true
+  },
+  {
+   "chainage_m": 549.0,
+   "elevation_m": 854.118069,
+   "z": 854.118069,
+   "valid": true
+  },
+  {
+   "chainage_m": 550.0,
+   "elevation_m": 854.1746,
+   "z": 854.1746,
+   "valid": true
+  },
+  {
+   "chainage_m": 551.0,
+   "elevation_m": 854.560974,
+   "z": 854.560974,
+   "valid": true
+  },
+  {
+   "chainage_m": 552.0,
+   "elevation_m": 854.536009,
+   "z": 854.536009,
+   "valid": true
+  },
+  {
+   "chainage_m": 553.0,
+   "elevation_m": 854.337467,
+   "z": 854.337467,
+   "valid": true
+  },
+  {
+   "chainage_m": 554.0,
+   "elevation_m": 854.176247,
+   "z": 854.176247,
+   "valid": true
+  },
+  {
+   "chainage_m": 555.0,
+   "elevation_m": 854.664027,
+   "z": 854.664027,
+   "valid": true
+  },
+  {
+   "chainage_m": 556.0,
+   "elevation_m": 854.846734,
+   "z": 854.846734,
+   "valid": true
+  },
+  {
+   "chainage_m": 557.0,
+   "elevation_m": 854.978906,
+   "z": 854.978906,
+   "valid": true
+  },
+  {
+   "chainage_m": 558.0,
+   "elevation_m": 855.226901,
+   "z": 855.226901,
+   "valid": true
+  },
+  {
+   "chainage_m": 559.0,
+   "elevation_m": 855.353289,
+   "z": 855.353289,
+   "valid": true
+  },
+  {
+   "chainage_m": 560.0,
+   "elevation_m": 855.526111,
+   "z": 855.526111,
+   "valid": true
+  },
+  {
+   "chainage_m": 561.0,
+   "elevation_m": 855.833343,
+   "z": 855.833343,
+   "valid": true
+  },
+  {
+   "chainage_m": 562.0,
+   "elevation_m": 856.063139,
+   "z": 856.063139,
+   "valid": true
+  },
+  {
+   "chainage_m": 563.0,
+   "elevation_m": 856.044308,
+   "z": 856.044308,
+   "valid": true
+  },
+  {
+   "chainage_m": 564.0,
+   "elevation_m": 856.245881,
+   "z": 856.245881,
+   "valid": true
+  },
+  {
+   "chainage_m": 565.0,
+   "elevation_m": 856.400703,
+   "z": 856.400703,
+   "valid": true
+  },
+  {
+   "chainage_m": 566.0,
+   "elevation_m": 856.475154,
+   "z": 856.475154,
+   "valid": true
+  },
+  {
+   "chainage_m": 567.0,
+   "elevation_m": 856.863479,
+   "z": 856.863479,
+   "valid": true
+  },
+  {
+   "chainage_m": 568.0,
+   "elevation_m": 857.152322,
+   "z": 857.152322,
+   "valid": true
+  },
+  {
+   "chainage_m": 569.0,
+   "elevation_m": 857.331392,
+   "z": 857.331392,
+   "valid": true
+  },
+  {
+   "chainage_m": 570.0,
+   "elevation_m": 857.459269,
+   "z": 857.459269,
+   "valid": true
+  },
+  {
+   "chainage_m": 571.0,
+   "elevation_m": 857.496881,
+   "z": 857.496881,
+   "valid": true
+  },
+  {
+   "chainage_m": 572.0,
+   "elevation_m": 857.429968,
+   "z": 857.429968,
+   "valid": true
+  },
+  {
+   "chainage_m": 573.0,
+   "elevation_m": 857.332459,
+   "z": 857.332459,
+   "valid": true
+  },
+  {
+   "chainage_m": 574.0,
+   "elevation_m": 857.423876,
+   "z": 857.423876,
+   "valid": true
+  },
+  {
+   "chainage_m": 575.0,
+   "elevation_m": 857.178176,
+   "z": 857.178176,
+   "valid": true
+  },
+  {
+   "chainage_m": 576.0,
+   "elevation_m": 857.119821,
+   "z": 857.119821,
+   "valid": true
+  },
+  {
+   "chainage_m": 577.0,
+   "elevation_m": 857.054032,
+   "z": 857.054032,
+   "valid": true
+  },
+  {
+   "chainage_m": 578.0,
+   "elevation_m": 856.883656,
+   "z": 856.883656,
+   "valid": true
+  },
+  {
+   "chainage_m": 579.0,
+   "elevation_m": 856.559821,
+   "z": 856.559821,
+   "valid": true
+  },
+  {
+   "chainage_m": 580.0,
+   "elevation_m": 856.057531,
+   "z": 856.057531,
+   "valid": true
+  },
+  {
+   "chainage_m": 581.0,
+   "elevation_m": 855.644475,
+   "z": 855.644475,
+   "valid": true
+  },
+  {
+   "chainage_m": 582.0,
+   "elevation_m": 855.50838,
+   "z": 855.50838,
+   "valid": true
+  },
+  {
+   "chainage_m": 583.0,
+   "elevation_m": 855.369504,
+   "z": 855.369504,
+   "valid": true
+  },
+  {
+   "chainage_m": 584.0,
+   "elevation_m": 855.077738,
+   "z": 855.077738,
+   "valid": true
+  },
+  {
+   "chainage_m": 585.0,
+   "elevation_m": 854.991337,
+   "z": 854.991337,
+   "valid": true
+  },
+  {
+   "chainage_m": 586.0,
+   "elevation_m": 854.641958,
+   "z": 854.641958,
+   "valid": true
+  },
+  {
+   "chainage_m": 587.0,
+   "elevation_m": 854.534526,
+   "z": 854.534526,
+   "valid": true
+  },
+  {
+   "chainage_m": 588.0,
+   "elevation_m": 854.251449,
+   "z": 854.251449,
+   "valid": true
+  },
+  {
+   "chainage_m": 589.0,
+   "elevation_m": 854.120608,
+   "z": 854.120608,
+   "valid": true
+  },
+  {
+   "chainage_m": 590.0,
+   "elevation_m": 853.986049,
+   "z": 853.986049,
+   "valid": true
+  },
+  {
+   "chainage_m": 591.0,
+   "elevation_m": 854.147835,
+   "z": 854.147835,
+   "valid": true
+  },
+  {
+   "chainage_m": 592.0,
+   "elevation_m": 854.30359,
+   "z": 854.30359,
+   "valid": true
+  },
+  {
+   "chainage_m": 593.0,
+   "elevation_m": 854.168616,
+   "z": 854.168616,
+   "valid": true
+  },
+  {
+   "chainage_m": 594.0,
+   "elevation_m": 853.891351,
+   "z": 853.891351,
+   "valid": true
+  },
+  {
+   "chainage_m": 595.0,
+   "elevation_m": 853.670235,
+   "z": 853.670235,
+   "valid": true
+  },
+  {
+   "chainage_m": 596.0,
+   "elevation_m": 853.423332,
+   "z": 853.423332,
+   "valid": true
+  },
+  {
+   "chainage_m": 597.0,
+   "elevation_m": 853.236596,
+   "z": 853.236596,
+   "valid": true
+  },
+  {
+   "chainage_m": 598.0,
+   "elevation_m": 853.170732,
+   "z": 853.170732,
+   "valid": true
+  },
+  {
+   "chainage_m": 599.0,
+   "elevation_m": 853.117057,
+   "z": 853.117057,
+   "valid": true
+  },
+  {
+   "chainage_m": 600.0,
+   "elevation_m": 852.920634,
+   "z": 852.920634,
+   "valid": true
+  },
+  {
+   "chainage_m": 601.0,
+   "elevation_m": 852.692771,
+   "z": 852.692771,
+   "valid": true
+  },
+  {
+   "chainage_m": 602.0,
+   "elevation_m": 852.711229,
+   "z": 852.711229,
+   "valid": true
+  },
+  {
+   "chainage_m": 603.0,
+   "elevation_m": 852.929115,
+   "z": 852.929115,
+   "valid": true
+  },
+  {
+   "chainage_m": 604.0,
+   "elevation_m": 853.068653,
+   "z": 853.068653,
+   "valid": true
+  },
+  {
+   "chainage_m": 605.0,
+   "elevation_m": 852.587642,
+   "z": 852.587642,
+   "valid": true
+  },
+  {
+   "chainage_m": 606.0,
+   "elevation_m": 851.858333,
+   "z": 851.858333,
+   "valid": true
+  },
+  {
+   "chainage_m": 607.0,
+   "elevation_m": 851.933693,
+   "z": 851.933693,
+   "valid": true
+  },
+  {
+   "chainage_m": 608.0,
+   "elevation_m": 852.13358,
+   "z": 852.13358,
+   "valid": true
+  },
+  {
+   "chainage_m": 609.0,
+   "elevation_m": 852.10442,
+   "z": 852.10442,
+   "valid": true
+  },
+  {
+   "chainage_m": 610.0,
+   "elevation_m": 851.989072,
+   "z": 851.989072,
+   "valid": true
+  },
+  {
+   "chainage_m": 611.0,
+   "elevation_m": 852.048089,
+   "z": 852.048089,
+   "valid": true
+  },
+  {
+   "chainage_m": 612.0,
+   "elevation_m": 852.201363,
+   "z": 852.201363,
+   "valid": true
+  },
+  {
+   "chainage_m": 613.0,
+   "elevation_m": 852.280375,
+   "z": 852.280375,
+   "valid": true
+  },
+  {
+   "chainage_m": 614.0,
+   "elevation_m": 852.336821,
+   "z": 852.336821,
+   "valid": true
+  },
+  {
+   "chainage_m": 615.0,
+   "elevation_m": 852.433908,
+   "z": 852.433908,
+   "valid": true
+  },
+  {
+   "chainage_m": 616.0,
+   "elevation_m": 852.283746,
+   "z": 852.283746,
+   "valid": true
+  },
+  {
+   "chainage_m": 617.0,
+   "elevation_m": 851.996817,
+   "z": 851.996817,
+   "valid": true
+  },
+  {
+   "chainage_m": 618.0,
+   "elevation_m": 851.459704,
+   "z": 851.459704,
+   "valid": true
+  },
+  {
+   "chainage_m": 619.0,
+   "elevation_m": 851.163413,
+   "z": 851.163413,
+   "valid": true
+  },
+  {
+   "chainage_m": 620.0,
+   "elevation_m": 850.964366,
+   "z": 850.964366,
+   "valid": true
+  },
+  {
+   "chainage_m": 621.0,
+   "elevation_m": 850.778727,
+   "z": 850.778727,
+   "valid": true
+  },
+  {
+   "chainage_m": 622.0,
+   "elevation_m": 850.8563,
+   "z": 850.8563,
+   "valid": true
+  },
+  {
+   "chainage_m": 623.0,
+   "elevation_m": 850.974656,
+   "z": 850.974656,
+   "valid": true
+  },
+  {
+   "chainage_m": 624.0,
+   "elevation_m": 850.894949,
+   "z": 850.894949,
+   "valid": true
+  },
+  {
+   "chainage_m": 625.0,
+   "elevation_m": 850.610577,
+   "z": 850.610577,
+   "valid": true
+  },
+  {
+   "chainage_m": 626.0,
+   "elevation_m": 850.293723,
+   "z": 850.293723,
+   "valid": true
+  },
+  {
+   "chainage_m": 627.0,
+   "elevation_m": 850.155834,
+   "z": 850.155834,
+   "valid": true
+  },
+  {
+   "chainage_m": 628.0,
+   "elevation_m": 850.12646,
+   "z": 850.12646,
+   "valid": true
+  },
+  {
+   "chainage_m": 629.0,
+   "elevation_m": 850.478046,
+   "z": 850.478046,
+   "valid": true
+  },
+  {
+   "chainage_m": 630.0,
+   "elevation_m": 850.244623,
+   "z": 850.244623,
+   "valid": true
+  },
+  {
+   "chainage_m": 631.0,
+   "elevation_m": 850.112925,
+   "z": 850.112925,
+   "valid": true
+  },
+  {
+   "chainage_m": 632.0,
+   "elevation_m": 850.191545,
+   "z": 850.191545,
+   "valid": true
+  },
+  {
+   "chainage_m": 633.0,
+   "elevation_m": 850.249846,
+   "z": 850.249846,
+   "valid": true
+  },
+  {
+   "chainage_m": 634.0,
+   "elevation_m": 850.483782,
+   "z": 850.483782,
+   "valid": true
+  },
+  {
+   "chainage_m": 635.0,
+   "elevation_m": 850.528137,
+   "z": 850.528137,
+   "valid": true
+  },
+  {
+   "chainage_m": 636.0,
+   "elevation_m": 850.570394,
+   "z": 850.570394,
+   "valid": true
+  },
+  {
+   "chainage_m": 637.0,
+   "elevation_m": 850.427413,
+   "z": 850.427413,
+   "valid": true
+  },
+  {
+   "chainage_m": 638.0,
+   "elevation_m": 850.316345,
+   "z": 850.316345,
+   "valid": true
+  },
+  {
+   "chainage_m": 639.0,
+   "elevation_m": 850.192353,
+   "z": 850.192353,
+   "valid": true
+  },
+  {
+   "chainage_m": 640.0,
+   "elevation_m": 849.970857,
+   "z": 849.970857,
+   "valid": true
+  },
+  {
+   "chainage_m": 641.0,
+   "elevation_m": 849.630379,
+   "z": 849.630379,
+   "valid": true
+  },
+  {
+   "chainage_m": 642.0,
+   "elevation_m": 849.659423,
+   "z": 849.659423,
+   "valid": true
+  },
+  {
+   "chainage_m": 643.0,
+   "elevation_m": 849.718725,
+   "z": 849.718725,
+   "valid": true
+  },
+  {
+   "chainage_m": 644.0,
+   "elevation_m": 849.829556,
+   "z": 849.829556,
+   "valid": true
+  },
+  {
+   "chainage_m": 645.0,
+   "elevation_m": 849.677023,
+   "z": 849.677023,
+   "valid": true
+  },
+  {
+   "chainage_m": 646.0,
+   "elevation_m": 849.414297,
+   "z": 849.414297,
+   "valid": true
+  },
+  {
+   "chainage_m": 647.0,
+   "elevation_m": 849.360012,
+   "z": 849.360012,
+   "valid": true
+  },
+  {
+   "chainage_m": 648.0,
+   "elevation_m": 849.082445,
+   "z": 849.082445,
+   "valid": true
+  },
+  {
+   "chainage_m": 649.0,
+   "elevation_m": 848.730251,
+   "z": 848.730251,
+   "valid": true
+  },
+  {
+   "chainage_m": 650.0,
+   "elevation_m": 848.521945,
+   "z": 848.521945,
+   "valid": true
+  },
+  {
+   "chainage_m": 651.0,
+   "elevation_m": 848.638333,
+   "z": 848.638333,
+   "valid": true
+  },
+  {
+   "chainage_m": 652.0,
+   "elevation_m": 848.802743,
+   "z": 848.802743,
+   "valid": true
+  },
+  {
+   "chainage_m": 653.0,
+   "elevation_m": 849.003836,
+   "z": 849.003836,
+   "valid": true
+  },
+  {
+   "chainage_m": 654.0,
+   "elevation_m": 848.537845,
+   "z": 848.537845,
+   "valid": true
+  },
+  {
+   "chainage_m": 655.0,
+   "elevation_m": 848.337755,
+   "z": 848.337755,
+   "valid": true
+  },
+  {
+   "chainage_m": 656.0,
+   "elevation_m": 848.304842,
+   "z": 848.304842,
+   "valid": true
+  },
+  {
+   "chainage_m": 657.0,
+   "elevation_m": 848.390895,
+   "z": 848.390895,
+   "valid": true
+  },
+  {
+   "chainage_m": 658.0,
+   "elevation_m": 848.38951,
+   "z": 848.38951,
+   "valid": true
+  },
+  {
+   "chainage_m": 659.0,
+   "elevation_m": 848.399387,
+   "z": 848.399387,
+   "valid": true
+  },
+  {
+   "chainage_m": 660.0,
+   "elevation_m": 848.360094,
+   "z": 848.360094,
+   "valid": true
+  },
+  {
+   "chainage_m": 661.0,
+   "elevation_m": 848.389533,
+   "z": 848.389533,
+   "valid": true
+  },
+  {
+   "chainage_m": 662.0,
+   "elevation_m": 848.308194,
+   "z": 848.308194,
+   "valid": true
+  },
+  {
+   "chainage_m": 663.0,
+   "elevation_m": 848.212779,
+   "z": 848.212779,
+   "valid": true
+  },
+  {
+   "chainage_m": 664.0,
+   "elevation_m": 848.109928,
+   "z": 848.109928,
+   "valid": true
+  },
+  {
+   "chainage_m": 665.0,
+   "elevation_m": 848.100868,
+   "z": 848.100868,
+   "valid": true
+  },
+  {
+   "chainage_m": 666.0,
+   "elevation_m": 848.04221,
+   "z": 848.04221,
+   "valid": true
+  },
+  {
+   "chainage_m": 667.0,
+   "elevation_m": 847.988501,
+   "z": 847.988501,
+   "valid": true
+  },
+  {
+   "chainage_m": 668.0,
+   "elevation_m": 847.947989,
+   "z": 847.947989,
+   "valid": true
+  },
+  {
+   "chainage_m": 669.0,
+   "elevation_m": 848.06593,
+   "z": 848.06593,
+   "valid": true
+  },
+  {
+   "chainage_m": 670.0,
+   "elevation_m": 848.220883,
+   "z": 848.220883,
+   "valid": true
+  },
+  {
+   "chainage_m": 671.0,
+   "elevation_m": 847.961508,
+   "z": 847.961508,
+   "valid": true
+  },
+  {
+   "chainage_m": 672.0,
+   "elevation_m": 848.126574,
+   "z": 848.126574,
+   "valid": true
+  },
+  {
+   "chainage_m": 673.0,
+   "elevation_m": 848.032362,
+   "z": 848.032362,
+   "valid": true
+  },
+  {
+   "chainage_m": 674.0,
+   "elevation_m": 847.78662,
+   "z": 847.78662,
+   "valid": true
+  },
+  {
+   "chainage_m": 675.0,
+   "elevation_m": 847.53375,
+   "z": 847.53375,
+   "valid": true
+  },
+  {
+   "chainage_m": 676.0,
+   "elevation_m": 847.573062,
+   "z": 847.573062,
+   "valid": true
+  },
+  {
+   "chainage_m": 677.0,
+   "elevation_m": 847.909466,
+   "z": 847.909466,
+   "valid": true
+  },
+  {
+   "chainage_m": 678.0,
+   "elevation_m": 847.948459,
+   "z": 847.948459,
+   "valid": true
+  },
+  {
+   "chainage_m": 679.0,
+   "elevation_m": 847.739344,
+   "z": 847.739344,
+   "valid": true
+  },
+  {
+   "chainage_m": 680.0,
+   "elevation_m": 847.460312,
+   "z": 847.460312,
+   "valid": true
+  },
+  {
+   "chainage_m": 681.0,
+   "elevation_m": 847.168271,
+   "z": 847.168271,
+   "valid": true
+  },
+  {
+   "chainage_m": 682.0,
+   "elevation_m": 847.060168,
+   "z": 847.060168,
+   "valid": true
+  },
+  {
+   "chainage_m": 683.0,
+   "elevation_m": 846.989919,
+   "z": 846.989919,
+   "valid": true
+  },
+  {
+   "chainage_m": 684.0,
+   "elevation_m": 846.686868,
+   "z": 846.686868,
+   "valid": true
+  },
+  {
+   "chainage_m": 685.0,
+   "elevation_m": 846.464286,
+   "z": 846.464286,
+   "valid": true
+  },
+  {
+   "chainage_m": 686.0,
+   "elevation_m": 846.501559,
+   "z": 846.501559,
+   "valid": true
+  },
+  {
+   "chainage_m": 687.0,
+   "elevation_m": 846.774701,
+   "z": 846.774701,
+   "valid": true
+  },
+  {
+   "chainage_m": 688.0,
+   "elevation_m": 846.745857,
+   "z": 846.745857,
+   "valid": true
+  },
+  {
+   "chainage_m": 689.0,
+   "elevation_m": 846.612569,
+   "z": 846.612569,
+   "valid": true
+  },
+  {
+   "chainage_m": 690.0,
+   "elevation_m": 846.165436,
+   "z": 846.165436,
+   "valid": true
+  },
+  {
+   "chainage_m": 691.0,
+   "elevation_m": 845.994884,
+   "z": 845.994884,
+   "valid": true
+  },
+  {
+   "chainage_m": 692.0,
+   "elevation_m": 845.858305,
+   "z": 845.858305,
+   "valid": true
+  },
+  {
+   "chainage_m": 693.0,
+   "elevation_m": 845.856014,
+   "z": 845.856014,
+   "valid": true
+  },
+  {
+   "chainage_m": 694.0,
+   "elevation_m": 845.874997,
+   "z": 845.874997,
+   "valid": true
+  },
+  {
+   "chainage_m": 695.0,
+   "elevation_m": 845.692977,
+   "z": 845.692977,
+   "valid": true
+  },
+  {
+   "chainage_m": 696.0,
+   "elevation_m": 845.572585,
+   "z": 845.572585,
+   "valid": true
+  },
+  {
+   "chainage_m": 697.0,
+   "elevation_m": 845.493257,
+   "z": 845.493257,
+   "valid": true
+  },
+  {
+   "chainage_m": 698.0,
+   "elevation_m": 845.332125,
+   "z": 845.332125,
+   "valid": true
+  },
+  {
+   "chainage_m": 699.0,
+   "elevation_m": 845.278834,
+   "z": 845.278834,
+   "valid": true
+  },
+  {
+   "chainage_m": 700.0,
+   "elevation_m": 845.27445,
+   "z": 845.27445,
+   "valid": true
+  },
+  {
+   "chainage_m": 701.0,
+   "elevation_m": 844.912407,
+   "z": 844.912407,
+   "valid": true
+  },
+  {
+   "chainage_m": 702.0,
+   "elevation_m": 844.792095,
+   "z": 844.792095,
+   "valid": true
+  },
+  {
+   "chainage_m": 703.0,
+   "elevation_m": 844.608147,
+   "z": 844.608147,
+   "valid": true
+  },
+  {
+   "chainage_m": 704.0,
+   "elevation_m": 844.745787,
+   "z": 844.745787,
+   "valid": true
+  },
+  {
+   "chainage_m": 705.0,
+   "elevation_m": 844.822649,
+   "z": 844.822649,
+   "valid": true
+  },
+  {
+   "chainage_m": 706.0,
+   "elevation_m": 844.65125,
+   "z": 844.65125,
+   "valid": true
+  },
+  {
+   "chainage_m": 707.0,
+   "elevation_m": 844.537021,
+   "z": 844.537021,
+   "valid": true
+  },
+  {
+   "chainage_m": 708.0,
+   "elevation_m": 844.553395,
+   "z": 844.553395,
+   "valid": true
+  },
+  {
+   "chainage_m": 709.0,
+   "elevation_m": 844.618185,
+   "z": 844.618185,
+   "valid": true
+  },
+  {
+   "chainage_m": 710.0,
+   "elevation_m": 844.41286,
+   "z": 844.41286,
+   "valid": true
+  },
+  {
+   "chainage_m": 711.0,
+   "elevation_m": 844.000168,
+   "z": 844.000168,
+   "valid": true
+  },
+  {
+   "chainage_m": 712.0,
+   "elevation_m": 843.70105,
+   "z": 843.70105,
+   "valid": true
+  },
+  {
+   "chainage_m": 713.0,
+   "elevation_m": 843.546356,
+   "z": 843.546356,
+   "valid": true
+  },
+  {
+   "chainage_m": 714.0,
+   "elevation_m": 843.328733,
+   "z": 843.328733,
+   "valid": true
+  },
+  {
+   "chainage_m": 715.0,
+   "elevation_m": 843.229925,
+   "z": 843.229925,
+   "valid": true
+  },
+  {
+   "chainage_m": 716.0,
+   "elevation_m": 843.082965,
+   "z": 843.082965,
+   "valid": true
+  },
+  {
+   "chainage_m": 717.0,
+   "elevation_m": 843.3016,
+   "z": 843.3016,
+   "valid": true
+  },
+  {
+   "chainage_m": 718.0,
+   "elevation_m": 843.327932,
+   "z": 843.327932,
+   "valid": true
+  },
+  {
+   "chainage_m": 719.0,
+   "elevation_m": 843.516812,
+   "z": 843.516812,
+   "valid": true
+  },
+  {
+   "chainage_m": 720.0,
+   "elevation_m": 843.926252,
+   "z": 843.926252,
+   "valid": true
+  },
+  {
+   "chainage_m": 721.0,
+   "elevation_m": 844.901787,
+   "z": 844.901787,
+   "valid": true
+  },
+  {
+   "chainage_m": 722.0,
+   "elevation_m": 845.343369,
+   "z": 845.343369,
+   "valid": true
+  },
+  {
+   "chainage_m": 723.0,
+   "elevation_m": 845.407688,
+   "z": 845.407688,
+   "valid": true
+  },
+  {
+   "chainage_m": 724.0,
+   "elevation_m": 845.988659,
+   "z": 845.988659,
+   "valid": true
+  },
+  {
+   "chainage_m": 725.0,
+   "elevation_m": 846.16845,
+   "z": 846.16845,
+   "valid": true
+  },
+  {
+   "chainage_m": 726.0,
+   "elevation_m": 846.381459,
+   "z": 846.381459,
+   "valid": true
+  },
+  {
+   "chainage_m": 727.0,
+   "elevation_m": 847.055647,
+   "z": 847.055647,
+   "valid": true
+  },
+  {
+   "chainage_m": 728.0,
+   "elevation_m": 847.414421,
+   "z": 847.414421,
+   "valid": true
+  },
+  {
+   "chainage_m": 729.0,
+   "elevation_m": 847.576499,
+   "z": 847.576499,
+   "valid": true
+  },
+  {
+   "chainage_m": 730.0,
+   "elevation_m": 848.206747,
+   "z": 848.206747,
+   "valid": true
+  },
+  {
+   "chainage_m": 731.0,
+   "elevation_m": 848.405212,
+   "z": 848.405212,
+   "valid": true
+  },
+  {
+   "chainage_m": 732.0,
+   "elevation_m": 848.792653,
+   "z": 848.792653,
+   "valid": true
+  },
+  {
+   "chainage_m": 733.0,
+   "elevation_m": 849.283679,
+   "z": 849.283679,
+   "valid": true
+  },
+  {
+   "chainage_m": 734.0,
+   "elevation_m": 849.687725,
+   "z": 849.687725,
+   "valid": true
+  },
+  {
+   "chainage_m": 735.0,
+   "elevation_m": 850.005008,
+   "z": 850.005008,
+   "valid": true
+  },
+  {
+   "chainage_m": 736.0,
+   "elevation_m": 850.159595,
+   "z": 850.159595,
+   "valid": true
+  },
+  {
+   "chainage_m": 737.0,
+   "elevation_m": 849.998573,
+   "z": 849.998573,
+   "valid": true
+  },
+  {
+   "chainage_m": 738.0,
+   "elevation_m": 849.167206,
+   "z": 849.167206,
+   "valid": true
+  },
+  {
+   "chainage_m": 739.0,
+   "elevation_m": 848.697835,
+   "z": 848.697835,
+   "valid": true
+  },
+  {
+   "chainage_m": 740.0,
+   "elevation_m": 848.425747,
+   "z": 848.425747,
+   "valid": true
+  },
+  {
+   "chainage_m": 741.0,
+   "elevation_m": 848.114222,
+   "z": 848.114222,
+   "valid": true
+  },
+  {
+   "chainage_m": 742.0,
+   "elevation_m": 847.984778,
+   "z": 847.984778,
+   "valid": true
+  },
+  {
+   "chainage_m": 743.0,
+   "elevation_m": 847.996605,
+   "z": 847.996605,
+   "valid": true
+  },
+  {
+   "chainage_m": 744.0,
+   "elevation_m": 847.943916,
+   "z": 847.943916,
+   "valid": true
+  },
+  {
+   "chainage_m": 745.0,
+   "elevation_m": 847.415277,
+   "z": 847.415277,
+   "valid": true
+  },
+  {
+   "chainage_m": 746.0,
+   "elevation_m": 847.713023,
+   "z": 847.713023,
+   "valid": true
+  },
+  {
+   "chainage_m": 747.0,
+   "elevation_m": 849.351653,
+   "z": 849.351653,
+   "valid": true
+  },
+  {
+   "chainage_m": 748.0,
+   "elevation_m": 849.375317,
+   "z": 849.375317,
+   "valid": true
+  },
+  {
+   "chainage_m": 749.0,
+   "elevation_m": 848.149511,
+   "z": 848.149511,
+   "valid": true
+  },
+  {
+   "chainage_m": 750.0,
+   "elevation_m": 847.367599,
+   "z": 847.367599,
+   "valid": true
+  },
+  {
+   "chainage_m": 751.0,
+   "elevation_m": 847.265878,
+   "z": 847.265878,
+   "valid": true
+  },
+  {
+   "chainage_m": 752.0,
+   "elevation_m": 847.207383,
+   "z": 847.207383,
+   "valid": true
+  },
+  {
+   "chainage_m": 753.0,
+   "elevation_m": 847.250653,
+   "z": 847.250653,
+   "valid": true
+  },
+  {
+   "chainage_m": 754.0,
+   "elevation_m": 847.33811,
+   "z": 847.33811,
+   "valid": true
+  },
+  {
+   "chainage_m": 755.0,
+   "elevation_m": 846.84956,
+   "z": 846.84956,
+   "valid": true
+  },
+  {
+   "chainage_m": 756.0,
+   "elevation_m": 846.252422,
+   "z": 846.252422,
+   "valid": true
+  },
+  {
+   "chainage_m": 757.0,
+   "elevation_m": 846.169892,
+   "z": 846.169892,
+   "valid": true
+  },
+  {
+   "chainage_m": 758.0,
+   "elevation_m": 845.921486,
+   "z": 845.921486,
+   "valid": true
+  },
+  {
+   "chainage_m": 759.0,
+   "elevation_m": 844.818659,
+   "z": 844.818659,
+   "valid": true
+  },
+  {
+   "chainage_m": 760.0,
+   "elevation_m": 844.434274,
+   "z": 844.434274,
+   "valid": true
+  },
+  {
+   "chainage_m": 761.0,
+   "elevation_m": 844.296984,
+   "z": 844.296984,
+   "valid": true
+  },
+  {
+   "chainage_m": 762.0,
+   "elevation_m": 844.132591,
+   "z": 844.132591,
+   "valid": true
+  },
+  {
+   "chainage_m": 763.0,
+   "elevation_m": 843.716978,
+   "z": 843.716978,
+   "valid": true
+  },
+  {
+   "chainage_m": 764.0,
+   "elevation_m": 843.540954,
+   "z": 843.540954,
+   "valid": true
+  },
+  {
+   "chainage_m": 765.0,
+   "elevation_m": 842.964549,
+   "z": 842.964549,
+   "valid": true
+  },
+  {
+   "chainage_m": 766.0,
+   "elevation_m": 842.896137,
+   "z": 842.896137,
+   "valid": true
+  },
+  {
+   "chainage_m": 767.0,
+   "elevation_m": 842.458402,
+   "z": 842.458402,
+   "valid": true
+  },
+  {
+   "chainage_m": 768.0,
+   "elevation_m": 842.018798,
+   "z": 842.018798,
+   "valid": true
+  },
+  {
+   "chainage_m": 769.0,
+   "elevation_m": 841.42706,
+   "z": 841.42706,
+   "valid": true
+  },
+  {
+   "chainage_m": 770.0,
+   "elevation_m": 840.784849,
+   "z": 840.784849,
+   "valid": true
+  },
+  {
+   "chainage_m": 771.0,
+   "elevation_m": 840.82025,
+   "z": 840.82025,
+   "valid": true
+  },
+  {
+   "chainage_m": 772.0,
+   "elevation_m": 841.07306,
+   "z": 841.07306,
+   "valid": true
+  },
+  {
+   "chainage_m": 773.0,
+   "elevation_m": 841.446496,
+   "z": 841.446496,
+   "valid": true
+  },
+  {
+   "chainage_m": 774.0,
+   "elevation_m": 841.416258,
+   "z": 841.416258,
+   "valid": true
+  },
+  {
+   "chainage_m": 775.0,
+   "elevation_m": 841.013515,
+   "z": 841.013515,
+   "valid": true
+  },
+  {
+   "chainage_m": 776.0,
+   "elevation_m": 840.507013,
+   "z": 840.507013,
+   "valid": true
+  },
+  {
+   "chainage_m": 777.0,
+   "elevation_m": 840.571919,
+   "z": 840.571919,
+   "valid": true
+  },
+  {
+   "chainage_m": 778.0,
+   "elevation_m": 841.1076,
+   "z": 841.1076,
+   "valid": true
+  },
+  {
+   "chainage_m": 779.0,
+   "elevation_m": 841.040727,
+   "z": 841.040727,
+   "valid": true
+  },
+  {
+   "chainage_m": 780.0,
+   "elevation_m": 841.261415,
+   "z": 841.261415,
+   "valid": true
+  },
+  {
+   "chainage_m": 781.0,
+   "elevation_m": 840.825901,
+   "z": 840.825901,
+   "valid": true
+  },
+  {
+   "chainage_m": 782.0,
+   "elevation_m": 840.98212,
+   "z": 840.98212,
+   "valid": true
+  },
+  {
+   "chainage_m": 783.0,
+   "elevation_m": 840.934341,
+   "z": 840.934341,
+   "valid": true
+  },
+  {
+   "chainage_m": 784.0,
+   "elevation_m": 840.77192,
+   "z": 840.77192,
+   "valid": true
+  },
+  {
+   "chainage_m": 785.0,
+   "elevation_m": 840.90707,
+   "z": 840.90707,
+   "valid": true
+  },
+  {
+   "chainage_m": 786.0,
+   "elevation_m": 841.003614,
+   "z": 841.003614,
+   "valid": true
+  },
+  {
+   "chainage_m": 787.0,
+   "elevation_m": 840.828882,
+   "z": 840.828882,
+   "valid": true
+  },
+  {
+   "chainage_m": 788.0,
+   "elevation_m": 840.494601,
+   "z": 840.494601,
+   "valid": true
+  },
+  {
+   "chainage_m": 789.0,
+   "elevation_m": 840.248678,
+   "z": 840.248678,
+   "valid": true
+  },
+  {
+   "chainage_m": 790.0,
+   "elevation_m": 840.251876,
+   "z": 840.251876,
+   "valid": true
+  },
+  {
+   "chainage_m": 791.0,
+   "elevation_m": 840.197685,
+   "z": 840.197685,
+   "valid": true
+  },
+  {
+   "chainage_m": 792.0,
+   "elevation_m": 840.081749,
+   "z": 840.081749,
+   "valid": true
+  },
+  {
+   "chainage_m": 793.0,
+   "elevation_m": 840.018425,
+   "z": 840.018425,
+   "valid": true
+  },
+  {
+   "chainage_m": 794.0,
+   "elevation_m": 840.037817,
+   "z": 840.037817,
+   "valid": true
+  },
+  {
+   "chainage_m": 795.0,
+   "elevation_m": 840.096343,
+   "z": 840.096343,
+   "valid": true
+  },
+  {
+   "chainage_m": 796.0,
+   "elevation_m": 840.017159,
+   "z": 840.017159,
+   "valid": true
+  },
+  {
+   "chainage_m": 797.0,
+   "elevation_m": 839.990881,
+   "z": 839.990881,
+   "valid": true
+  },
+  {
+   "chainage_m": 798.0,
+   "elevation_m": 840.023953,
+   "z": 840.023953,
+   "valid": true
+  },
+  {
+   "chainage_m": 799.0,
+   "elevation_m": 840.016825,
+   "z": 840.016825,
+   "valid": true
+  },
+  {
+   "chainage_m": 800.0,
+   "elevation_m": 839.97829,
+   "z": 839.97829,
+   "valid": true
+  },
+  {
+   "chainage_m": 801.0,
+   "elevation_m": 839.755273,
+   "z": 839.755273,
+   "valid": true
+  },
+  {
+   "chainage_m": 802.0,
+   "elevation_m": 840.031205,
+   "z": 840.031205,
+   "valid": true
+  },
+  {
+   "chainage_m": 803.0,
+   "elevation_m": 840.077855,
+   "z": 840.077855,
+   "valid": true
+  },
+  {
+   "chainage_m": 804.0,
+   "elevation_m": 840.049919,
+   "z": 840.049919,
+   "valid": true
+  },
+  {
+   "chainage_m": 805.0,
+   "elevation_m": 839.804295,
+   "z": 839.804295,
+   "valid": true
+  },
+  {
+   "chainage_m": 806.0,
+   "elevation_m": 839.497403,
+   "z": 839.497403,
+   "valid": true
+  },
+  {
+   "chainage_m": 807.0,
+   "elevation_m": 839.357147,
+   "z": 839.357147,
+   "valid": true
+  },
+  {
+   "chainage_m": 808.0,
+   "elevation_m": 839.724823,
+   "z": 839.724823,
+   "valid": true
+  },
+  {
+   "chainage_m": 809.0,
+   "elevation_m": 839.723196,
+   "z": 839.723196,
+   "valid": true
+  },
+  {
+   "chainage_m": 810.0,
+   "elevation_m": 839.605801,
+   "z": 839.605801,
+   "valid": true
+  },
+  {
+   "chainage_m": 811.0,
+   "elevation_m": 839.557805,
+   "z": 839.557805,
+   "valid": true
+  },
+  {
+   "chainage_m": 812.0,
+   "elevation_m": 839.554231,
+   "z": 839.554231,
+   "valid": true
+  },
+  {
+   "chainage_m": 813.0,
+   "elevation_m": 839.571381,
+   "z": 839.571381,
+   "valid": true
+  },
+  {
+   "chainage_m": 814.0,
+   "elevation_m": 839.452099,
+   "z": 839.452099,
+   "valid": true
+  },
+  {
+   "chainage_m": 815.0,
+   "elevation_m": 839.234901,
+   "z": 839.234901,
+   "valid": true
+  },
+  {
+   "chainage_m": 816.0,
+   "elevation_m": 838.82685,
+   "z": 838.82685,
+   "valid": true
+  },
+  {
+   "chainage_m": 817.0,
+   "elevation_m": 838.614957,
+   "z": 838.614957,
+   "valid": true
+  },
+  {
+   "chainage_m": 818.0,
+   "elevation_m": 838.551397,
+   "z": 838.551397,
+   "valid": true
+  },
+  {
+   "chainage_m": 819.0,
+   "elevation_m": 838.645889,
+   "z": 838.645889,
+   "valid": true
+  },
+  {
+   "chainage_m": 820.0,
+   "elevation_m": 838.404772,
+   "z": 838.404772,
+   "valid": true
+  },
+  {
+   "chainage_m": 821.0,
+   "elevation_m": 838.298295,
+   "z": 838.298295,
+   "valid": true
+  },
+  {
+   "chainage_m": 822.0,
+   "elevation_m": 838.566679,
+   "z": 838.566679,
+   "valid": true
+  },
+  {
+   "chainage_m": 823.0,
+   "elevation_m": 838.541365,
+   "z": 838.541365,
+   "valid": true
+  },
+  {
+   "chainage_m": 824.0,
+   "elevation_m": 838.794145,
+   "z": 838.794145,
+   "valid": true
+  },
+  {
+   "chainage_m": 825.0,
+   "elevation_m": 838.922882,
+   "z": 838.922882,
+   "valid": true
+  },
+  {
+   "chainage_m": 826.0,
+   "elevation_m": 838.682894,
+   "z": 838.682894,
+   "valid": true
+  },
+  {
+   "chainage_m": 827.0,
+   "elevation_m": 838.502808,
+   "z": 838.502808,
+   "valid": true
+  },
+  {
+   "chainage_m": 828.0,
+   "elevation_m": 839.166363,
+   "z": 839.166363,
+   "valid": true
+  },
+  {
+   "chainage_m": 829.0,
+   "elevation_m": 839.712109,
+   "z": 839.712109,
+   "valid": true
+  },
+  {
+   "chainage_m": 830.0,
+   "elevation_m": 839.842892,
+   "z": 839.842892,
+   "valid": true
+  },
+  {
+   "chainage_m": 831.0,
+   "elevation_m": 839.481282,
+   "z": 839.481282,
+   "valid": true
+  },
+  {
+   "chainage_m": 832.0,
+   "elevation_m": 839.26726,
+   "z": 839.26726,
+   "valid": true
+  },
+  {
+   "chainage_m": 833.0,
+   "elevation_m": 839.42614,
+   "z": 839.42614,
+   "valid": true
+  },
+  {
+   "chainage_m": 834.0,
+   "elevation_m": 839.630968,
+   "z": 839.630968,
+   "valid": true
+  },
+  {
+   "chainage_m": 835.0,
+   "elevation_m": 839.47773,
+   "z": 839.47773,
+   "valid": true
+  },
+  {
+   "chainage_m": 836.0,
+   "elevation_m": 839.400899,
+   "z": 839.400899,
+   "valid": true
+  },
+  {
+   "chainage_m": 837.0,
+   "elevation_m": 839.818858,
+   "z": 839.818858,
+   "valid": true
+  },
+  {
+   "chainage_m": 838.0,
+   "elevation_m": 839.806895,
+   "z": 839.806895,
+   "valid": true
+  },
+  {
+   "chainage_m": 839.0,
+   "elevation_m": 839.811075,
+   "z": 839.811075,
+   "valid": true
+  },
+  {
+   "chainage_m": 840.0,
+   "elevation_m": 839.942178,
+   "z": 839.942178,
+   "valid": true
+  }
+ ],
+ "stations": [
+  {
+   "station_id": "station_000000460000",
+   "chainage_m": 460.0,
+   "label": "STA.0+460.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000480000",
+   "chainage_m": 480.0,
+   "label": "STA.0+480.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000484210",
+   "chainage_m": 484.21,
+   "label": "STA.0+484.210",
+   "kind": "irregular",
+   "structure": "파형강관 D800"
+  },
+  {
+   "station_id": "station_000000500000",
+   "chainage_m": 500.0,
+   "label": "STA.0+500.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000520000",
+   "chainage_m": 520.0,
+   "label": "STA.0+520.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000540000",
+   "chainage_m": 540.0,
+   "label": "STA.0+540.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000560000",
+   "chainage_m": 560.0,
+   "label": "STA.0+560.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000580000",
+   "chainage_m": 580.0,
+   "label": "STA.0+580.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000581900",
+   "chainage_m": 581.9,
+   "label": "STA.0+581.900",
+   "kind": "irregular",
+   "structure": "파형강관 D800"
+  },
+  {
+   "station_id": "station_000000600000",
+   "chainage_m": 600.0,
+   "label": "STA.0+600.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000620000",
+   "chainage_m": 620.0,
+   "label": "STA.0+620.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000640000",
+   "chainage_m": 640.0,
+   "label": "STA.0+640.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000660000",
+   "chainage_m": 660.0,
+   "label": "STA.0+660.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000676590",
+   "chainage_m": 676.59,
+   "label": "STA.0+676.590",
+   "kind": "irregular",
+   "structure": "파형강관 D1500"
+  },
+  {
+   "station_id": "station_000000680000",
+   "chainage_m": 680.0,
+   "label": "STA.0+680.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000700000",
+   "chainage_m": 700.0,
+   "label": "STA.0+700.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000720000",
+   "chainage_m": 720.0,
+   "label": "STA.0+720.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000740000",
+   "chainage_m": 740.0,
+   "label": "STA.0+740.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000760000",
+   "chainage_m": 760.0,
+   "label": "STA.0+760.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000769280",
+   "chainage_m": 769.28,
+   "label": "STA.0+769.280",
+   "kind": "irregular",
+   "structure": "파형강관 D800"
+  },
+  {
+   "station_id": "station_000000780000",
+   "chainage_m": 780.0,
+   "label": "STA.0+780.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000800000",
+   "chainage_m": 800.0,
+   "label": "STA.0+800.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000820000",
+   "chainage_m": 820.0,
+   "label": "STA.0+820.000",
+   "kind": "regular"
+  },
+  {
+   "station_id": "station_000000840000",
+   "chainage_m": 840.0,
+   "label": "STA.0+840.000",
+   "kind": "regular"
+  }
+ ],
+ "design_profiles": [
+  {
+   "schema_version": 1,
+   "id": "design_grade_line",
+   "name": "계획선",
+   "basis": "ground_polyline",
+   "criteria": {
+    "max_grade_pct": 14.0,
+    "max_reverse_grade_pct": 5.0,
+    "min_vertical_radius_m": 100.0,
+    "min_curve_length_m": 20.0,
+    "min_tangent_length_m": 20.0,
+    "vertical_curve_skip_delta_pct": 5.0,
+    "design_speed_kph": 20,
+    "terrain_type": "special",
+    "paved": false,
+    "main_direction": "auto",
+    "balance_segment_length_m": null,
+    "start_elevation_offset_m": 0.0,
+    "end_elevation_offset_m": 0.0,
+    "enforce_pipe_clearance": false,
+    "resolved_main_direction": "descending"
+   }
+  }
+ ],
+ "profile_alignment": {
+  "schema_version": 1,
+  "policy": {
+   "station_interval_m": 20.0,
+   "curve_radius_ratio": 0.4,
+   "default_curve_length_m": 15.0,
+   "curve_tangent_max_ratio": 0.45,
+   "curve_skip_legal_exception": false,
+   "default_curve_radius_m": 8.0,
+   "balance_tolerance_percent": 10.0,
+   "edit_step_m": 0.1,
+   "grade_violation_policy": "warn",
+   "max_grade_pct": 14.0,
+   "curve_skip_delta_pct": 5.0,
+   "paved": false,
+   "min_plan_radius_m": 0.0,
+   "hairpin_min_radius_m": 0.0
+  },
+  "only_explicit_curves": false,
+  "base_pvi": [
+   {
+    "chainage_m": 460.0,
+    "elevation_m": 855.2479
+   },
+   {
+    "chainage_m": 480.0,
+    "elevation_m": 854.398
+   },
+   {
+    "chainage_m": 484.213,
+    "elevation_m": 854.1746
+   },
+   {
+    "chainage_m": 500.0,
+    "elevation_m": 853.244
+   },
+   {
+    "chainage_m": 520.0,
+    "elevation_m": 853.1798
+   },
+   {
+    "chainage_m": 540.0,
+    "elevation_m": 854.0777
+   },
+   {
+    "chainage_m": 560.0,
+    "elevation_m": 854.8932
+   },
+   {
+    "chainage_m": 580.0,
+    "elevation_m": 854.5863
+   },
+   {
+    "chainage_m": 581.902,
+    "elevation_m": 854.4747
+   },
+   {
+    "chainage_m": 600.0,
+    "elevation_m": 853.617
+   },
+   {
+    "chainage_m": 620.0,
+    "elevation_m": 851.7089
+   },
+   {
+    "chainage_m": 640.0,
+    "elevation_m": 849.5565
+   },
+   {
+    "chainage_m": 660.0,
+    "elevation_m": 848.391
+   },
+   {
+    "chainage_m": 676.591,
+    "elevation_m": 847.4059
+   },
+   {
+    "chainage_m": 680.0,
+    "elevation_m": 847.2193
+   },
+   {
+    "chainage_m": 700.0,
+    "elevation_m": 845.4289
+   },
+   {
+    "chainage_m": 720.0,
+    "elevation_m": 844.6952
+   },
+   {
+    "chainage_m": 740.0,
+    "elevation_m": 844.3864
+   },
+   {
+    "chainage_m": 760.0,
+    "elevation_m": 842.9962
+   },
+   {
+    "chainage_m": 769.28,
+    "elevation_m": 842.016371
+   },
+   {
+    "chainage_m": 780.0,
+    "elevation_m": 840.8845
+   },
+   {
+    "chainage_m": 800.0,
+    "elevation_m": 839.1705
+   },
+   {
+    "chainage_m": 820.0,
+    "elevation_m": 838.4651
+   },
+   {
+    "chainage_m": 840.0,
+    "elevation_m": 837.4166
+   }
+  ],
+  "edits": {
+   "station_offsets": {
+    "769.280": 0.506058,
+    "769.380": 0.051428
+   },
+   "curve_radii": {}
+  }
+ }
+}
\ No newline at end of file
diff --git a/resources/tester/helper_164_detail_zoom.cjs b/resources/tester/helper_164_detail_zoom.cjs
index 9cb7ffa3f..a56ff0baa 100644
--- a/resources/tester/helper_164_detail_zoom.cjs
+++ b/resources/tester/helper_164_detail_zoom.cjs
@@ -35,6 +35,8 @@ const STUBS = {
     svgText,
   },
   "./B06_Section_UI_Cross_Detail_Pick": { DETAIL_TARGETS: {} },
+  // 선 조각 고르기(209-1)는 줌과 무관 — 따로 시험(`test_209_1_detail_select.py`)
+  "./B06_Section_UI_Cross_Detail_Select": { attachDetailSelect: () => ({}), PIECE_HIT_CLASS: "" },
 };
 const resolve = (base) => (fs.existsSync(`${base}.ts`) ? `${base}.ts` : base);
 function loadTs(full) {
diff --git a/resources/tester/helper_179_4_detail_table.cjs b/resources/tester/helper_179_4_detail_table.cjs
index 80bf13535..743921ada 100644
--- a/resources/tester/helper_179_4_detail_table.cjs
+++ b/resources/tester/helper_179_4_detail_table.cjs
@@ -25,6 +25,8 @@ const store = () => {
   };
 };
 globalThis.window = { sessionStorage: store(), localStorage: store() };
+// 조정창 공용 부품(Select → Design_Pick → Cross_Panel_Base)이 불러올 때 문서에 귀를 닮
+globalThis.document = { addEventListener: () => {}, removeEventListener: () => {} };
 
 const STUBS = {
   "@ui/ui_template_context_menu": { createMapContextMenu: () => ({}) },
@@ -38,6 +40,9 @@ function loadTs(full) {
   const box = { exports: {} };
   const localRequire = (request) => {
     if (STUBS[request]) return STUBS[request];
+    if (request.endsWith(".css")) return {};
+    if (request.startsWith("@util/"))
+      return loadTs(resolve(path.join(ROOT, "common_util", request.slice(6))));
     return loadTs(resolve(path.join(path.dirname(full), request)));
   };
   new Function("exports", "module", "require", js)(box.exports, box, localRequire);
@@ -85,12 +90,10 @@ const px = ([offset, elevation]) => [
     (AXES.displayMax - (AXES.elevationMid + (elevation - AXES.elevationMid) * AXES.exaggeration)) *
       AXES.pixelsPerMeter,
 ];
-const points = input.pick
-  .map(px)
-  .map((p) => p.join(","))
-  .join(" ");
-out.length = T.lengthSourceOf(fake(["b06-chart__design-hit"], { points }), AXES);
-out.lengthBad = T.lengthSourceOf(fake(["b06-chart__design-hit"], { points: "1,2" }), AXES);
+// 화면 px → m(209-1 `_Cross_Detail_Select.pxToM`) · 길이 = 옛 저장 꼴(두 끝) 그대로 읽음
+const S = loadTs(path.join(B06, "B06_Section_UI_Cross_Detail_Select.ts"));
+out.pxBack = input.pick.map(px).map(S.pxToM(AXES));
+out.length = { src: "length", start: input.pick[0], end: input.pick[1] };
 out.lengthValue = T.localCellValue(out.length, input.design);
 
 // ③ 우클릭 메뉴 항목
diff --git a/resources/tester/helper_202_1_fill_below.cjs b/resources/tester/helper_202_1_fill_below.cjs
new file mode 100644
index 000000000..73fd59feb
--- /dev/null
+++ b/resources/tester/helper_202_1_fill_below.cjs
@@ -0,0 +1,84 @@
+/* 202-1 — 표 칸 아래로 간 안내 줄 몫이 창 끝까지 셈(`ui_template_data_table.ts` fillViewport)에 들어가는지 단위검증 헬퍼.
+ * 카드 본문 = [표 칸][아래 줄][안내 줄 · 안내 줄 …](B08 `tableCard` 꼴) 가짜 DOM 에서 돌리고 JSON 으로 냄. */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const file = path.join(__dirname, "..", "..", "ui_template", "ui_template_data_table.ts");
+const js = ts.transpileModule(fs.readFileSync(file, "utf8"), {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+}).outputText;
+
+const win = { innerHeight: 900, scrollY: 0, addEventListener() {}, removeEventListener() {} };
+const observers = [];
+class RO {
+  constructor(fn) {
+    this.fn = fn;
+    observers.push(this);
+  }
+  observe() {}
+  disconnect() {}
+}
+const el = (name, css = {}, height = 0) => ({
+  name,
+  css,
+  height,
+  top: 0,
+  parentElement: null,
+  nextElementSibling: null,
+  isConnected: true,
+  style: {},
+  getBoundingClientRect() {
+    return { top: this.top, height: this.height };
+  },
+});
+function link(parent, ...kids) {
+  kids.forEach((k, i) => {
+    k.parentElement = parent;
+    k.nextElementSibling = kids[i + 1] ?? null;
+  });
+  return parent;
+}
+const sty = (n) => ({
+  rowGap: n.css.rowGap ?? "normal",
+  paddingBottom: n.css.paddingBottom ?? "0px",
+  borderBottomWidth: n.css.borderBottomWidth ?? "0px",
+  marginBottom: n.css.marginBottom ?? "0px",
+});
+const box = { exports: {} };
+new Function("exports", "module", "require", "window", "document", "getComputedStyle", "ResizeObserver", js)(
+  box.exports,
+  box,
+  (p) => (p.endsWith(".css") ? {} : require(p)),
+  win,
+  { body: null },
+  sty,
+  RO,
+);
+const m = box.exports;
+
+// 문서: body(padding-bottom 8) > card(padding-bottom 12 · gap 8) > [root][avg 20][info 30][hint 40]
+const body = el("body", { paddingBottom: "8px" });
+const card = el("card", { paddingBottom: "12px", rowGap: "8px" });
+const root = el("root");
+const avg = el("avg", {}, 20);
+const info = el("info", {}, 30);
+const hint = el("hint", {}, 40);
+link(body, card);
+link(card, root, avg, info, hint);
+root.top = 200;
+
+m.fillViewport(root);
+observers.forEach((o) => o.fn());
+const out = { first: parseFloat(root.style.maxHeight) };
+out.below = m.spaceBelow(root);
+out.belowExpected = 3 * 8 + 20 + 30 + 40 + 12 + 8; // 줄 사이 8 셋 · 아래 줄 · 안내 둘 · 카드 · 본문 여백
+out.bottom = root.top + out.first + out.below; // 문서 맨 아래 = 창 아래 끝(페이지 스크롤 0)
+out.viewport = win.innerHeight;
+
+// 안내 줄이 두 줄로 늘어남 → 표 칸이 그만큼 줄어듦
+hint.height = 60;
+observers.forEach((o) => o.fn());
+out.afterHintGrow = parseFloat(root.style.maxHeight);
+out.firstMinusGrow = out.first - 20;
+console.log(JSON.stringify(out));
diff --git a/resources/tester/helper_209_1_detail_select.cjs b/resources/tester/helper_209_1_detail_select.cjs
new file mode 100644
index 000000000..81862f3cd
--- /dev/null
+++ b/resources/tester/helper_209_1_detail_select.cjs
@@ -0,0 +1,117 @@
+/* PLAN 209-1 단위검증 헬퍼 — [상세] 선 조각 고르기(`_Cross_Detail_Geom` · `_Cross_Detail_Select`).
+ * 화면 TS 를 그 자리에서 트랜스파일해 Node 로 돌림. 입력 = 표준입력 JSON {design, samples, axes} ·
+ * 결과 = 표준출력 JSON 한 벌. 짝 = `test_209_1_detail_select.py`(파이썬 `cell_value` 거울).
+ */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+const B06 = path.join(ROOT, "B06_Section");
+const common = fs.readFileSync(path.join(B06, "B06_Section_UI_Section_Common.ts"), "utf8");
+const CROSS_PAD = Function(`return ${/export const CROSS_PAD = (\{[^}]*\})/.exec(common)[1]}`)();
+globalThis.window = { sessionStorage: new Map(), localStorage: new Map() };
+globalThis.document = { addEventListener: () => {}, removeEventListener: () => {} };
+
+const STUBS = {
+  "@ui/ui_template_context_menu": { createMapContextMenu: () => ({}) },
+  "./B06_Section_UI_Section_Common": { CROSS_PAD },
+};
+const resolve = (base) => (fs.existsSync(`${base}.ts`) ? `${base}.ts` : base);
+function loadTs(full) {
+  const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  const localRequire = (request) => {
+    if (STUBS[request]) return STUBS[request];
+    if (request.endsWith(".css")) return {};
+    if (request.startsWith("@util/"))
+      return loadTs(resolve(path.join(ROOT, "common_util", request.slice(6))));
+    return loadTs(resolve(path.join(path.dirname(full), request)));
+  };
+  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
+  return box.exports;
+}
+const G = loadTs(path.join(B06, "B06_Section_UI_Cross_Detail_Geom.ts"));
+const S = loadTs(path.join(B06, "B06_Section_UI_Cross_Detail_Select.ts"));
+const T = loadTs(path.join(B06, "B06_Section_UI_Cross_Detail_Table.ts"));
+
+const { design, samples, axes } = JSON.parse(fs.readFileSync(0, "utf8"));
+const out = {};
+
+// ① 그림 요소(화면 px) → 조각(m) — 설계선(직선 토막 셋) · 원지반선 · 구조물 선 아님
+const px = ([offset, elevation]) =>
+  [
+    CROSS_PAD.left + (axes.maxOffset - offset) * axes.pixelsPerMeter,
+    CROSS_PAD.top +
+      (axes.displayMax -
+        (axes.elevationMid + (elevation - axes.elevationMid) * axes.exaggeration)) *
+        axes.pixelsPerMeter,
+  ].join(",");
+const el = (classes, points, attrs = {}) => ({
+  tagName: "polyline",
+  classList: { contains: (name) => classes.includes(name) },
+  hasAttribute: (name) => name in attrs,
+  getAttribute: (name) => (name === "points" ? points.map(px).join(" ") : (attrs[name] ?? null)),
+});
+const designPts = design.design_line.map((p) => [p.offset_m, p.elevation_m]);
+const groundPts = samples.filter((s) => s.valid !== false).map((s) => [s.offset_m, s.elevation_m]);
+const pieces = S.collectPieces(
+  [
+    el(["b06-chart__design-cross"], designPts, { "data-design-line": "" }),
+    el(["b06-chart__cross-profile"], groundPts),
+    el(
+      ["b06-chart__grid"],
+      [
+        [0, 0],
+        [1, 1],
+      ],
+    ),
+  ],
+  axes,
+);
+out.pieces = pieces;
+
+// ② 여러 고름 — 더하기 · 빼기 · 하나 · 다시 누르면 비움
+out.toggle = {
+  single: S.toggleSelection([1, 2], 3, false),
+  again: S.toggleSelection([3], 3, false),
+  add: S.toggleSelection([1], 3, true),
+  remove: S.toggleSelection([1, 3], 3, true),
+};
+
+// ③ 닫힌 영역 — 땅 아래 설계 골(경사 둘 · 바닥) + 원지반 가운데 조각
+const isGround = (p) => p.line === "ground";
+const mid = (p) => (p.points[0][0] + p.points[p.points.length - 1][0]) / 2;
+const below = pieces.filter(
+  (p) => !isGround(p) && Math.max(...p.points.map((q) => q[1])) <= 100.0001,
+);
+const groundMid = pieces.filter((p) => isGround(p) && Math.abs(mid(p)) < 1);
+const ring = [...below, ...groundMid];
+out.ringCount = ring.length;
+out.label = {
+  ring: S.selectionLabel(design, ring),
+  open: S.selectionLabel(design, below),
+  single: S.selectionLabel(design, [below.find((p) => Math.abs(mid(p)) < 0.5)]),
+  ground: S.selectionLabel(design, groundMid),
+};
+out.area = G.ringArea(ring.map((p) => p.points));
+out.open = G.ringArea(below.map((p) => p.points));
+
+// ④ 칸 넣기 출처(저장 꼴) · 즉시 칸 값(짝 ①)
+out.sourceArea = S.selectionSource("area", ring);
+out.sourceOpen = S.selectionSource("area", below);
+out.sourceLength = S.selectionSource("length", [...below, ...groundMid]);
+const withStructure = {
+  src: "length",
+  pieces: [...out.sourceLength.pieces, { line: "structure", start: [20, 0], end: [23, 4] }],
+};
+const offLine = {
+  src: "length",
+  pieces: [{ line: "ground", start: [0, 101], end: [1, 100] }],
+};
+out.sources = [out.sourceArea, out.sourceLength, withStructure, offLine];
+out.local = out.sources.map((source) => T.localCellValue(source, design, samples));
+out.lengthSum = [...below, ...groundMid].reduce((sum, p) => sum + G.pathLength(p.points), 0);
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_215_1_free_profile.cjs b/resources/tester/helper_215_1_free_profile.cjs
new file mode 100644
index 000000000..7944663cf
--- /dev/null
+++ b/resources/tester/helper_215_1_free_profile.cjs
@@ -0,0 +1,175 @@
+/* 215-1 종단 [자유지정] 단위검증 헬퍼 — `design_profile_free.ts` 를 그 자리에서 트랜스파일해
+ * 범위 · 시작 이음 · 세로선 붙음 · 높이 변환 · 미리 보기 · 기울기 판정 · 종단곡선 · 끝 이음 ·
+ * Esc · Backspace · 적용 편집을 Node 로 돌린다.
+ */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+const cache = new Map();
+function loadTs(file) {
+  const full = path.resolve(file);
+  if (cache.has(full)) return cache.get(full);
+  const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  cache.set(full, box.exports);
+  const localRequire = (request) => {
+    if (request.startsWith(".")) return loadTs(path.join(path.dirname(full), `${request}.ts`));
+    return require(request);
+  };
+  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
+  cache.set(full, box.exports);
+  return box.exports;
+}
+
+const free = loadTs(path.join(ROOT, "A00_Common", "design", "design_profile_free.ts"));
+const align = loadTs(path.join(ROOT, "B05_Profile", "B05_Profile_UI_Profile_Alignment.ts"));
+
+// 전체 측점 폴리라인(20m 간격 · 0~200m) — 계획고 = 지반고, 마디마다 기울기가 다르다.
+const stations = Array.from({ length: 11 }, (_, i) => i * 20);
+const ground = stations.map((s, i) => 100 + 0.3 * i + (i % 2 ? 0.4 : 0));
+const base = {
+  policy: {
+    station_interval_m: 20,
+    curve_radius_ratio: 1,
+    curve_tangent_max_ratio: 0.5,
+    curve_skip_legal_exception: false,
+    default_curve_length_m: 20,
+    default_curve_radius_m: 300,
+    balance_tolerance_percent: 10,
+    edit_step_m: 0.1,
+    grade_violation_policy: "warn",
+    max_grade_pct: 14,
+    curve_skip_delta_pct: 0,
+    paved: true,
+  },
+  onlyExplicitCurves: true,
+  basePvi: stations.map((s, i) => ({ chainage_m: s, elevation_m: ground[i] })),
+  chainage: stations,
+  ground,
+  stations: stations.map((s) => ({ station_id: `S${s}`, chainage_m: s })),
+};
+
+function harness() {
+  let edits = align.emptyEdits();
+  const log = { applied: [], closed: 0, changed: 0 };
+  const draw = free.createFreeDraw({
+    base: () => base,
+    alignment: () => align.buildAlignment(base, edits),
+    edits: () => edits,
+    apply: (next) => {
+      log.applied.push(next);
+      edits = next;
+    },
+    close: () => (log.closed += 1),
+    changed: () => (log.changed += 1),
+  });
+  return { draw, log, edits: () => edits };
+}
+
+const out = {};
+const z0 = (s) => ground[stations.indexOf(s)];
+
+// ① 높이 변환 — 세로 창(기준 + 지금 변환) 왕복 · 변환 글 읽기.
+const view = { center: 100, pxPerM: 10, zero: 150, scale: 1.2, offset: -20 };
+out.yAt103_2 = free.chartYAtElevation(view, 103.2);
+out.zBack = free.elevationAtChartY(view, out.yAt103_2);
+out.parsed = free.parseWindowTransform("translate(0 -20) scale(1 1.2)");
+out.parsedNone = free.parseWindowTransform(null);
+
+// ② 세로선 붙음 — 가장 가까운 측점 · 범위 안만.
+out.snap79 = free.snapStation(stations, 79);
+out.snapOutside = free.snapStation(stations, 190, [40, 160]);
+
+// ③ 범위 → 시작 이음 → 점 → 미리 보기 → 끝 이음.
+{
+  const { draw, log, edits } = harness();
+  draw.click(41, 0, stations); // 범위 첫 세로선(40)
+  out.pendingEdges = draw.marks().edges;
+  draw.click(158, 0, stations); // 범위 끝(160)
+  out.rangePhase = draw.phase();
+  out.band = draw.marks().band;
+  draw.click(100, 105, stations); // 범위 가운데 — 시작 아님
+  out.stillArmed = draw.phase();
+  draw.click(43, 999, stations); // 시작 세로선 근처 — 그 측점 계획고에 이어 시작
+  out.startPhase = draw.phase();
+  out.startDot = draw.marks().dots[0];
+  draw.click(79, 103.456, stations); // 80 에 붙고 높이는 클릭 높이(0.01 단위)
+  out.point1 = draw.marks().dots[1];
+  draw.click(61, 90, stations); // 뒤로 가는 클릭 — 무시
+  out.dotsAfterBack = draw.marks().dots.length;
+  draw.hover({ chainageM: 121, elevationM: 101.2, stations });
+  out.preview = draw.marks().segments.map((s) => ({
+    to: s.to,
+    grade: Number(s.grade_pct.toFixed(4)),
+    over: s.over,
+    preview: s.preview,
+  }));
+  draw.hover({ chainageM: 121, elevationM: 80, stations }); // 기울기 넘음
+  const steep = draw.marks().segments.at(-1);
+  out.steep = { grade: Number(steep.grade_pct.toFixed(2)), over: steep.over };
+  draw.click(121, 101.2, stations);
+  draw.hover({ chainageM: 157, elevationM: 50, stations }); // 끝 세로선 → 그 계획고로 이음
+  out.finishPreview = draw.marks().segments.at(-1).to;
+  out.hint = draw.hint();
+  draw.click(157, 50, stations); // 끝 세로선 근처 = 끝
+  out.appliedCount = log.applied.length;
+  out.closed = log.closed;
+  out.afterPhase = draw.phase();
+  const next = edits();
+  out.offsetKeys = Object.keys(next.station_offsets).sort();
+  out.radiiKeys = Object.keys(next.curve_radii).sort();
+  const built = align.buildAlignment(base, next);
+  const pvi = (s) => built.pvi.find((n) => Math.abs(n.chainage_m - s) < 1e-6).elevation_m;
+  out.pvi = { 40: pvi(40), 60: pvi(60), 80: pvi(80), 100: pvi(100), 120: pvi(120), 140: pvi(140), 160: pvi(160) };
+  out.ground = { 40: z0(40), 160: z0(160) };
+  const g1 = (103.46 - z0(40)) / 40;
+  const g2 = (101.2 - 103.46) / 40;
+  out.expectR80 = Number((20 / Math.abs(g2 - g1)).toFixed(6));
+  out.r80 = next.curve_radii["80.000"];
+  out.curve80L = built.curves.find((c) => Math.abs(c.chainage_m - 80) < 1e-6)?.l_m ?? null;
+  out.outsideUntouched = !("20.000" in next.station_offsets) && !("180.000" in next.station_offsets);
+}
+
+// ④ Enter = 끝(마지막 점 → 끝 세로선) · 끝 세로선에서 거꾸로 시작.
+{
+  const { draw, log, edits } = harness();
+  draw.click(40, 0, stations);
+  draw.click(160, 0, stations);
+  draw.click(162, 0, stations); // 끝 쪽 세로선에서 시작
+  out.reverseAnchor = draw.marks().dots[0].chainage_m;
+  draw.click(100, 104, stations);
+  out.enter = draw.key("Enter");
+  out.enterApplied = log.applied.length;
+  const built = align.buildAlignment(base, edits());
+  const pvi = (s) => built.pvi.find((n) => Math.abs(n.chainage_m - s) < 1e-6).elevation_m;
+  out.enterPvi = { 40: pvi(40), 60: pvi(60), 100: pvi(100), 140: pvi(140), 160: pvi(160) };
+}
+
+// ⑤ Esc = 취소(편집 없음) · Backspace = 마지막 점 빼기.
+{
+  const { draw, log } = harness();
+  draw.click(40, 0, stations);
+  draw.click(160, 0, stations);
+  draw.click(40, 0, stations);
+  draw.click(80, 102, stations);
+  draw.click(120, 103, stations);
+  draw.key("Backspace");
+  out.afterBackspace = draw.marks().dots.map((d) => d.chainage_m);
+  draw.key("Backspace");
+  draw.key("Backspace");
+  out.backspaceToArmed = draw.phase();
+  draw.click(40, 0, stations);
+  draw.click(80, 102, stations);
+  out.escape = draw.key("Escape");
+  out.escApplied = log.applied.length;
+  out.escClosed = log.closed;
+  out.escPhase = draw.phase();
+  out.escDots = draw.marks().dots.length;
+  out.enterOutsideDrawing = draw.key("Enter");
+}
+
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_216_1_b05_station_panel.cjs b/resources/tester/helper_216_1_b05_station_panel.cjs
new file mode 100644
index 000000000..ba1547ed4
--- /dev/null
+++ b/resources/tester/helper_216_1_b05_station_panel.cjs
@@ -0,0 +1,193 @@
+/* PLAN 216-1 단위검증 헬퍼 — B05 종단 측점선 고름 → 좌측 구조물 폼이 B06 카드 고름과 같게.
+ * 화면 TS(`B05_Profile_UI_Selection` · `design_selection`)를 그 자리에서 트랜스파일해 Node 로 돌림 ·
+ * 결과 = 표준출력 JSON 한 벌. 짝 = `test_216_1_b05_station_panel.py`.
+ * B05 포트 배선은 `design_view_profile.ts` 와 같은 꼴 · B06 은 `showAtChainage` 와 같은 꼴(resolveSelection + coverable).
+ */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+const cache = new Map();
+
+const session = new Map();
+const fakeStorage = {
+  getItem: (k) => session.get(k) ?? null,
+  setItem: (k, v) => session.set(k, String(v)),
+  removeItem: (k) => session.delete(k),
+};
+globalThis.window = { sessionStorage: fakeStorage, localStorage: fakeStorage };
+globalThis.sessionStorage = fakeStorage;
+globalThis.localStorage = fakeStorage;
+
+// 비정규 측점 모듈은 설정 별칭(@config)을 끌어오므로 쓰는 두 함수만 같은 꼴로 흉내
+const STUBS = {
+  "./B05_Profile_UI_IrregularStations": {
+    irregularStationId: (id) => `irregular:${id}`,
+    isPipeStation: (s) => s.origin === "pipe",
+  },
+};
+
+function loadTs(file) {
+  const full = path.resolve(file);
+  if (cache.has(full)) return cache.get(full);
+  const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  cache.set(full, box.exports);
+  const localRequire = (request) =>
+    STUBS[request] ??
+    (request.startsWith(".")
+      ? loadTs(path.join(path.dirname(full), `${request}.ts`))
+      : require(request));
+  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
+  cache.set(full, box.exports);
+  return box.exports;
+}
+
+const sel = loadTs(path.join(ROOT, "A00_Common", "design", "design_selection.ts"));
+const sync = loadTs(path.join(ROOT, "B05_Profile", "B05_Profile_UI_Selection.ts"));
+
+const P = "proj-216";
+// 측점 = 일반(s0~s200) + 관 투영(irregular:p1 · 33.4) + A군 수동 횡단수로(irregular:x1 · 140)
+const cards = [0, 20, 40, 60, 80, 100, 120, 160, 180, 200].map((c) => ({
+  station_id: `s${c}`,
+  chainage_m: c,
+}));
+const irregular = [
+  { id: "p1", chainage_m: 33.4, origin: "pipe", structure: "배관" },
+  { id: "x1", chainage_m: 140, structure: "노출형 횡단수로" },
+];
+const pipes = [{ chainage_m: 33.4 }];
+const types = [
+  { type_id: "retaining_wall", group: "C" },
+  { type_id: "cross_channel", group: "A" },
+  { type_id: "pavement", group: "G" },
+];
+const structures = [
+  { structure_id: "wall", type_id: "retaining_wall", start_m: 60, end_m: 80, chainage_m: 60 },
+  { structure_id: "chan", type_id: "cross_channel", chainage_m: 140 },
+  { structure_id: "pave", type_id: "pavement", start_m: 150, end_m: 190, chainage_m: 150 },
+];
+const groupOf = (typeId) => types.find((t) => t.type_id === typeId)?.group;
+
+/** 좌측 폼 흉내 — B05 `_Structures_Panel` 의 selectPipeByChainage · selectById · selectAt 꼴 그대로. */
+function makeForm(onSelect) {
+  const form = { pipe: null, structure: null };
+  const panel = {
+    form,
+    selectPipeByChainage(c) {
+      if (c === null) {
+        form.pipe = null;
+        return;
+      }
+      const hit = pipes.find((p) => Math.abs(p.chainage_m - c) < sel.PIPE_MATCH_M);
+      if (!hit) return;
+      form.pipe = hit.chainage_m;
+      form.structure = null;
+      onSelect?.(null);
+    },
+    selectById(id) {
+      if (id === null) {
+        form.pipe = null;
+        form.structure = null;
+        return;
+      }
+      form.pipe = null;
+      form.structure = id;
+      onSelect?.(structures.find((s) => s.structure_id === id) ?? null);
+    },
+    selectAt(selection, coverable) {
+      const hit = sel.resolveSelection(selection, pipes, structures, coverable);
+      if (hit.pipeChainageM !== null) panel.selectPipeByChainage(hit.pipeChainageM);
+      else panel.selectById(hit.structureId);
+      return hit;
+    },
+  };
+  return panel;
+}
+const formOf = (panel) =>
+  panel.form.pipe !== null ? `pipe-${panel.form.pipe.toFixed(2)}` : panel.form.structure;
+
+// ── B05 종단 보기 — design_view_profile 의 포트 배선 그대로 ─────────────────────
+let syncing = false;
+const rememberPick = (c, sid) =>
+  sel.selectDesign(P, c === null ? sel.NO_SELECTION : { chainageM: c, structureId: sid }, {
+    from: "b05",
+  });
+// 폼이 구조물을 열면 view 의 onStructureSelect 가 그 구조물을 고름 한 칸에 적음(동기화 중이면 그 뒤 return)
+const b05Panel = makeForm((structure) => {
+  if (structure) rememberPick(structure.chainage_m, structure.structure_id);
+});
+const sb = sync.createSelectionSync({
+  stations: () => irregular,
+  isSyncing: () => syncing,
+  setSyncing: (v) => {
+    syncing = v;
+  },
+  selectMarker: () => undefined,
+  selectGraph: () => undefined,
+  selectSidebar: (c) => b05Panel.selectPipeByChainage(c),
+  openAtStation: (c) =>
+    b05Panel.selectAt({ chainageM: c, structureId: null }, (entry) =>
+      sel.coversAtStation(groupOf(entry.type_id)),
+    ),
+  selectBasin: () => undefined,
+  regularChainage: (id) => cards.find((c) => c.station_id === id)?.chainage_m,
+  remember: (c) => rememberPick(c, null),
+});
+
+// ── B06 카드 고름 — showAtChainage 와 같은 꼴(카드 = 관 투영은 가까운 카드) ──────────
+const b06Panel = makeForm();
+const b06Coverable = (entry) => sel.coversAtStation(groupOf(entry.type_id));
+const b06Card = (chainageM) => {
+  const hit = sel.resolveSelection(
+    { chainageM, structureId: null },
+    pipes,
+    structures,
+    b06Coverable,
+  );
+  if (hit.pipeChainageM !== null) b06Panel.selectPipeByChainage(hit.pipeChainageM);
+  else b06Panel.selectById(hit.structureId);
+};
+
+const chainageOf = (id) =>
+  irregular.find((s) => `irregular:${s.id}` === id)?.chainage_m ??
+  cards.find((c) => c.station_id === id)?.chainage_m;
+
+/** 차례대로 고름 — 매 걸음 B05 폼 · B06 폼 · 고름 한 칸. */
+function run(ids) {
+  b05Panel.form.pipe = b05Panel.form.structure = null;
+  b06Panel.form.pipe = b06Panel.form.structure = null;
+  sel.selectDesign(P, sel.NO_SELECTION);
+  return ids.map((id) => {
+    sb.syncIrregularSelection(id);
+    const at = id === null ? null : chainageOf(id);
+    if (at !== undefined) b06Card(at); // 모르는 측점은 B06 카드가 없음
+    return { id, b05: formOf(b05Panel), b06: formOf(b06Panel), pick: sel.readSelection(P) };
+  });
+}
+
+const out = {
+  pipe: run(["irregular:p1"]),
+  // 관 폼이 열린 채 일반 측점 = 폼 비움(새 배치 준비) — 옛 B05 는 관 폼이 남았음
+  pipeThenPlain: run(["irregular:p1", "s100"]),
+  // 옹벽 범위 안 일반 측점 = 옹벽 폼 · 고름 한 칸은 그 측점(구조물 id 없음)
+  wallStation: run(["s20", "s60"]),
+  wallMiddle: run(["s80"]),
+  // A군 수동 횡단수로 측점 = 그 구조물 폼
+  channel: run(["irregular:x1"]),
+  // 노면공만 덮는 측점 = 노면공 안 엶(189-1 · 152-5) — 연 폼은 풂
+  pave: run(["s60", "s160"]),
+  // 같은 측점 다시 = 풂(null)
+  release: run(["s60", null]),
+  // 모르는 측점 = 폼 · 고름 한 칸 안 건드림
+  unknown: run(["s60", "ghost"]),
+  covers: {
+    G: sel.coversAtStation("G"),
+    C: sel.coversAtStation("C"),
+    none: sel.coversAtStation(undefined),
+  },
+};
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_218_1_loupe.cjs b/resources/tester/helper_218_1_loupe.cjs
new file mode 100644
index 000000000..32e247990
--- /dev/null
+++ b/resources/tester/helper_218_1_loupe.cjs
@@ -0,0 +1,402 @@
+/* 돋보기(`ui_template/ui_template_loupe.ts` · 계획서 218-1) 단위검증 헬퍼 —
+ * 그 자리에서 트랜스파일해 Node 로 돌리고 값을 JSON 으로 냄. 가짜 창 · 가짜 시계 · 가짜 요소로 판정. */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+function load(file) {
+  const js = ts.transpileModule(fs.readFileSync(file, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  const req = (p) =>
+    p.endsWith(".css")
+      ? {}
+      : p.endsWith("key_shortcut") // 공용 키 판정(214-2)도 그 자리에서 트랜스파일
+        ? load(path.join(ROOT, "A00_Common", "key_shortcut.ts"))
+        : require(p);
+  new Function("exports", "module", "require", js)(box.exports, box, req);
+  return box.exports;
+}
+const m = load(path.join(ROOT, "ui_template", "ui_template_loupe.ts"));
+
+// ---- 가짜 시계 · 가짜 창 ----
+function fakeWindow(doc) {
+  const win = {
+    innerWidth: 1000,
+    innerHeight: 800,
+    document: doc,
+    now: 0,
+    timers: [],
+    seq: 0,
+    calls: [],
+  };
+  win.addEventListener = (type, fn, capture) => win.calls.push({ type, fn, capture });
+  win.removeEventListener = (type, fn) =>
+    (win.calls = win.calls.filter((c) => c.type !== type || c.fn !== fn));
+  win.setTimeout = (fn, ms) => (win.timers.push({ id: ++win.seq, at: win.now + ms, fn }), win.seq);
+  win.clearTimeout = (id) => (win.timers = win.timers.filter((t) => t.id !== id));
+  win.tick = (ms) => {
+    win.now += ms;
+    for (const t of win.timers.filter((t) => t.at <= win.now)) {
+      win.clearTimeout(t.id);
+      t.fn();
+    }
+  };
+  win.fire = (type, props = {}) => {
+    const ev = {
+      type,
+      button: 0,
+      buttons: 0,
+      clientX: 0,
+      clientY: 0,
+      code: "",
+      target: { tagName: "DIV" },
+      ...props,
+    };
+    ev.prevented = false;
+    ev.stopped = false;
+    ev.preventDefault = () => (ev.prevented = true);
+    ev.stopImmediatePropagation = () => (ev.stopped = true);
+    win.calls.filter((c) => c.type === type).forEach((c) => c.fn(ev));
+    return ev;
+  };
+  return win;
+}
+function fakeView() {
+  const log = [];
+  return {
+    log,
+    show: (x, y) => log.push(["show", x, y]),
+    move: (x, y) => log.push(["move", x, y]),
+    hide: () => log.push(["hide"]),
+  };
+}
+const last = (v) => (v.log.length ? v.log[v.log.length - 1][0] : null);
+
+// ---- 켜는 법 ----
+function setup(on = () => true) {
+  const win = fakeWindow(null);
+  const view = fakeView();
+  m.initLoupe(win, on, view);
+  return { win, view };
+}
+const r = {};
+r.consts = {
+  d: m.LOUPE_DIAMETER,
+  zoom: m.LOUPE_ZOOM,
+  hold: m.LOUPE_HOLD_MS,
+  refresh: m.LOUPE_REFRESH_MS,
+};
+{
+  const { win } = setup();
+  r.listeners = win.calls.map((c) => [c.type, c.capture]);
+}
+{
+  // 길게 누름 — 0.4 초 넘어야 켬 · 떼면 끔 · 뒤따르는 메뉴는 먹음
+  const { win, view } = setup();
+  win.fire("mousedown", { button: 2, buttons: 2, clientX: 300, clientY: 200 });
+  win.tick(399);
+  const before = view.log.length;
+  win.tick(1);
+  const on = last(view);
+  win.fire("mousemove", { buttons: 2, clientX: 310, clientY: 205 });
+  const moved = view.log[view.log.length - 1];
+  win.fire("mouseup", { button: 2 });
+  const off = last(view);
+  const menu = win.fire("contextmenu");
+  const nextMenu = win.fire("contextmenu");
+  r.long = {
+    before,
+    on,
+    show: view.log[0],
+    moved,
+    off,
+    menuPrevented: menu.prevented,
+    menuStopped: menu.stopped,
+    nextStopped: nextMenu.stopped,
+  };
+}
+{
+  // 짧게 누름 — 안 켬 · 메뉴 그대로
+  const { win, view } = setup();
+  win.fire("mousedown", { button: 2, buttons: 2 });
+  win.tick(200);
+  win.fire("mouseup", { button: 2 });
+  win.tick(1000);
+  const menu = win.fire("contextmenu");
+  r.short = { log: view.log.length, menuPrevented: menu.prevented, menuStopped: menu.stopped };
+}
+{
+  // 왼쪽 단추 · 창 밖에서 뗌
+  const { win, view } = setup();
+  win.fire("mousedown", { button: 0, buttons: 1 });
+  win.tick(1000);
+  const left = view.log.length;
+  win.fire("mousedown", { button: 2, buttons: 2 });
+  win.fire("mousemove", { buttons: 0 });
+  win.tick(1000);
+  const lostBeforeHold = view.log.length;
+  win.fire("mousedown", { button: 2, buttons: 2 });
+  win.tick(500);
+  win.fire("mousemove", { buttons: 0 });
+  r.mouseMisc = { left, lostBeforeHold, lostAfterHold: last(view) };
+}
+{
+  // Z 키
+  const { win, view } = setup();
+  const z = (props) => win.fire("keydown", { code: "KeyZ", ...props });
+  z({ key: "ㅋ" });
+  const on = last(view);
+  win.fire("keydown", { code: "KeyZ", repeat: true });
+  const repeatLen = view.log.length;
+  win.fire("keyup", { code: "KeyZ" });
+  const off = last(view);
+  const len = view.log.length;
+  z({ ctrlKey: true });
+  z({ altKey: true });
+  z({ metaKey: true });
+  win.fire("keydown", { code: "KeyX" });
+  const noCombo = view.log.length === len;
+  const typing = {};
+  for (const [k, target] of Object.entries({
+    input: { tagName: "INPUT", type: "text" },
+    inputNoType: { tagName: "INPUT", type: "" },
+    number: { tagName: "INPUT", type: "number" },
+    textarea: { tagName: "TEXTAREA" },
+    select: { tagName: "SELECT" },
+    editable: { tagName: "SPAN", isContentEditable: true },
+    checkbox: { tagName: "INPUT", type: "checkbox" },
+    button: { tagName: "BUTTON" },
+  })) {
+    const n = view.log.length;
+    z({ target });
+    typing[k] = view.log.length > n;
+    win.fire("keyup", { code: "KeyZ" });
+  }
+  z({ shiftKey: true });
+  const shift = last(view);
+  win.fire("blur", { target: { tagName: "INPUT", type: "text" } });
+  const fieldBlur = last(view);
+  win.fire("blur", { target: win });
+  r.key = { on, repeatLen, off, noCombo, typing, shift, fieldBlur, blur: last(view) };
+}
+{
+  // B05~B09 밖이면 안 켬
+  const { win, view } = setup(() => false);
+  win.fire("keydown", { code: "KeyZ" });
+  win.fire("mousedown", { button: 2, buttons: 2 });
+  win.tick(1000);
+  win.fire("mouseup", { button: 2 });
+  const menu = win.fire("contextmenu");
+  r.off = { log: view.log.length, menuStopped: menu.stopped };
+}
+r.routes = {};
+for (const route of [
+  "b04-preprocess",
+  "b05-profile",
+  "b06-section",
+  "b07-design-detail",
+  "b08-quantity",
+  "b09-estimation",
+  "b10-payment",
+  "a01-home",
+  "m01-master-data",
+])
+  r.routes[route] = m.LOUPE_ROUTE.test(route);
+r.origin = {
+  mid: m.loupeOrigin(500, 400, 1000, 800),
+  topLeft: m.loupeOrigin(10, 10, 1000, 800),
+  bottomRight: m.loupeOrigin(995, 795, 1000, 800),
+};
+
+// ---- 가짜 요소 ----
+const SVG_NS = "http://www.w3.org/2000/svg";
+class El {
+  constructor(tagName, opts = {}) {
+    this.tagName = tagName;
+    this.namespaceURI = opts.ns || "http://www.w3.org/1999/xhtml";
+    this.rect = opts.rect || { left: 0, top: 0, right: 100, bottom: 100, width: 100, height: 100 };
+    this.children = [];
+    this.style = {};
+    this.dataset = {};
+    this.attrs = {};
+    this.scrollTop = opts.scrollTop || 0;
+    this.scrollLeft = 0;
+    this.width = opts.width || 0;
+    this.height = opts.height || 0;
+    this.value = opts.value || "";
+    this.checked = !!opts.checked;
+    this.type = opts.type || "";
+    this.className = "";
+    this.hidden = false;
+    this.contentDocument = opts.contentDocument || null;
+    this.drawn = [];
+    this.parent = null;
+    this.mark = opts.mark || "";
+  }
+  getBoundingClientRect() {
+    return this.rect;
+  }
+  setAttribute(k, v) {
+    this.attrs[k] = v;
+  }
+  append(...nodes) {
+    for (const n of nodes) ((n.parent = this), this.children.push(n));
+  }
+  replaceChildren() {
+    this.children = [];
+  }
+  replaceWith(n) {
+    const i = this.parent.children.indexOf(this);
+    n.parent = this.parent;
+    this.parent.children[i] = n;
+  }
+  cloneNode(deep) {
+    const c = new El(this.tagName, {
+      ns: this.namespaceURI,
+      rect: this.rect,
+      width: this.width,
+      height: this.height,
+      type: this.type,
+      mark: this.mark,
+    });
+    c.cloned = true; // 값 · 스크롤 · 그림은 복제에 안 따라옴(실제 DOM 과 같게)
+    if (deep) c.append(...this.children.map((k) => k.cloneNode(true)));
+    return c;
+  }
+  getContext() {
+    return { drawImage: (src, x, y, w, h) => this.drawn.push([src.mark, x, y, w, h]) };
+  }
+  querySelectorAll(sel) {
+    const out = [];
+    const visit = (e) => (
+      e.tagName.toLowerCase() === sel && out.push(e),
+      e.children.forEach(visit)
+    );
+    this.children.forEach(visit);
+    return out;
+  }
+}
+const far = { left: 0, top: 2000, right: 100, bottom: 2100, width: 100, height: 100 };
+function makePage() {
+  const app = new El("DIV", {
+    rect: { left: 0, top: 0, right: 1000, bottom: 800, width: 1000, height: 800 },
+  });
+  const scroller = new El("DIV", { scrollTop: 120, mark: "scroller" });
+  const canvas = new El("CANVAS", { width: 50, height: 40, mark: "canvas2d" });
+  const blank = new El("CANVAS", { mark: "blank" });
+  const input = new El("INPUT", { value: "12.5", type: "text" });
+  const check = new El("INPUT", { checked: true, type: "checkbox" });
+  const offscreen = new El("SECTION", { rect: far, mark: "off" });
+  offscreen.append(new El("P"), new El("P"));
+  const table = new El("TABLE");
+  const row = new El("TR", { rect: far, mark: "row" });
+  row.append(new El("TD", { rect: far }));
+  table.append(row);
+  const svg = new El("svg", { ns: SVG_NS });
+  svg.append(new El("path", { ns: SVG_NS }));
+  const frameDoc = new El("HTML");
+  frameDoc.append(
+    new El("CANVAS", {
+      width: 300,
+      height: 200,
+      mark: "cad",
+      rect: { left: 5, top: 6, width: 300, height: 200 },
+    }),
+  );
+  const frame = new El("IFRAME", {
+    contentDocument: frameDoc,
+    rect: { left: 0, top: 0, right: 320, bottom: 240, width: 320, height: 240 },
+  });
+  scroller.append(canvas, blank, input, check);
+  app.append(scroller, offscreen, table, svg, frame);
+  return app;
+}
+function fakeDocument(app) {
+  const doc = { body: new El("BODY") };
+  doc.createElement = (tag) => new El(tag.toUpperCase());
+  doc.getElementById = (id) => (id === "app" ? app : null);
+  return doc;
+}
+{
+  const app = makePage();
+  const doc = fakeDocument(app);
+  const win = fakeWindow(doc);
+  const observers = [];
+  win.MutationObserver = class {
+    constructor(fn) {
+      this.fn = fn;
+      this.watching = null;
+      observers.push(this);
+    }
+    observe(target, opts) {
+      this.watching = target;
+      this.opts = opts;
+    }
+    disconnect() {
+      this.watching = null;
+    }
+  };
+  const view = m.createLoupeView(win);
+  view.show(500, 400);
+  const root = doc.body.children[0];
+  const stage = root.children[0];
+  const page = stage.children[0];
+  const copy = page.children[0];
+  const [scroller, offscreen, table, svg, frame] = copy.children;
+  const [canvas, blank, input, check] = scroller.children;
+  r.capture = {
+    rootClass: root.className,
+    rootSize: [root.style.width, root.style.height],
+    inert: root.inert,
+    ariaHidden: root.attrs["aria-hidden"],
+    hidden: root.hidden,
+    rootTransform: root.style.transform,
+    stageTransform: stage.style.transform,
+    pageBox: [page.style.left, page.style.top, page.style.width, page.style.height],
+    isClone: copy.cloned === true && copy !== app,
+    canvasDrawn: canvas.drawn.map((d) => d[0]),
+    blankDrawn: blank.drawn.length,
+    inputValue: input.value,
+    checkChecked: check.checked,
+    scrollTop: scroller.scrollTop,
+    offscreenChildren: offscreen.children.length,
+    offscreenSize: [offscreen.style.width, offscreen.style.height],
+    rowKept: table.children[0].children.length,
+    svgKept: svg.children.length,
+    frameTag: frame.tagName,
+    frameDrawn: frame.drawn,
+    frameSize: [frame.width, frame.height],
+    watching: observers[0].watching === app,
+    observeOpts: observers[0].opts,
+    scrollListen: win.calls.some((c) => c.type === "scroll" && c.capture),
+  };
+  // 화면이 바뀜 — 0.5 초 뒤 한 번만 다시 뜸
+  const firstCopy = copy;
+  observers[0].fn();
+  observers[0].fn();
+  win.tick(499);
+  const sameBefore = stage.children[0].children[0] === firstCopy;
+  win.tick(1);
+  const recaptured = stage.children[0].children[0] !== firstCopy && stage.children.length === 1;
+  view.move(10, 10);
+  const nearEdge = root.style.transform;
+  view.hide();
+  r.hide = {
+    sameBefore,
+    recaptured,
+    nearEdge,
+    stageChildren: stage.children.length,
+    hidden: root.hidden,
+    disconnected: observers[0].watching === null,
+    scrollListen: win.calls.some((c) => c.type === "scroll"),
+  };
+  observers[0].fn();
+  win.tick(1000);
+  r.hide.noRecaptureAfterHide = stage.children.length;
+  view.show(500, 400);
+  r.hide.reuseRoot = doc.body.children.length;
+}
+console.log(JSON.stringify(r));
diff --git a/resources/tester/helper_219_1_arrow_owner.cjs b/resources/tester/helper_219_1_arrow_owner.cjs
new file mode 100644
index 000000000..dd6bae490
--- /dev/null
+++ b/resources/tester/helper_219_1_arrow_owner.cjs
@@ -0,0 +1,184 @@
+/* PLAN 219-1 단위검증 헬퍼 — 횡단 보기 방향키가 관을 몰래 옮기던 흠.
+ * 실제 TS(`B05_Profile_UI_Profile_Panel_Tools` · `B06_Section_UI_Cross_Panel_Base`)를 그 자리에서
+ * 트랜스파일해 Node 로 돌림 · 결과 = 표준출력 JSON 한 벌. 짝 = `test_219_1_arrow_owner.py`.
+ * 창 · 문서 듣개는 흉내(누름 = 문서 잡기 단계 · 키 = 문서 듣개(횡단 조정창) 뒤 창 듣개(종단도) 차례).
+ */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+
+const ROOT = path.join(__dirname, "..", "..");
+const cache = new Map();
+
+const listeners = { window: {}, document: {} };
+const on = (where) => (type, fn) => (listeners[where][type] ??= new Set()).add(fn);
+const off = (where) => (type, fn) => listeners[where][type]?.delete(fn);
+const session = new Map();
+globalThis.sessionStorage = {
+  getItem: (k) => session.get(k) ?? null,
+  setItem: (k, v) => session.set(k, String(v)),
+  removeItem: (k) => session.delete(k),
+};
+globalThis.window = {
+  addEventListener: on("window"),
+  removeEventListener: off("window"),
+  setTimeout: () => 0,
+  clearTimeout: () => undefined,
+  setInterval: () => 0,
+  clearInterval: () => undefined,
+};
+globalThis.document = { addEventListener: on("document"), removeEventListener: off("document") };
+
+// 화면 계산 · 이력 · 도구줄은 이 흠과 무관 — 쓰는 꼴만 흉내
+const calls = { move: [], edits: 0 };
+const STUBS = {
+  "./B05_Profile_UI_Profile_Alignment": { adjustStation: () => (calls.edits++, {}) },
+  "./B05_Profile_UI_Profile_Edit": { HOLD_DELAY_MS: 500, HOLD_INTERVAL_MS: 100 },
+  "./B05_Profile_UI_Profile_History": {
+    createProfileHistory: () => ({
+      record: () => undefined,
+      pause: () => undefined,
+      resume: () => undefined,
+      undo: () => undefined,
+      redo: () => undefined,
+      canUndo: () => false,
+      canRedo: () => false,
+    }),
+  },
+  "./B05_Profile_UI_Profile_Tools": {
+    createProfileTools: () => ({ mode: () => "none", clear: () => undefined }),
+  },
+  "./B05_Profile_UI_Profile_Straighten": {},
+  // [자유지정](215-1) — 화면 설정(@config) 줄기를 끌고 옴 · 이 흠과 무관
+  "../A00_Common/design/design_profile_free": {
+    createFreeDraw: () => ({ key: () => false, hint: () => "" }),
+  },
+  "../A00_Common/design/design_profile_free_view": {
+    createFreeView: () => ({ mount: () => undefined, redraw: () => undefined }),
+  },
+};
+
+function loadTs(file) {
+  const full = path.resolve(file);
+  if (cache.has(full)) return cache.get(full);
+  const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  cache.set(full, box.exports);
+  const localRequire = (request) =>
+    STUBS[request] ??
+    (request.startsWith(".")
+      ? loadTs(path.join(path.dirname(full), `${request}.ts`))
+      : require(request));
+  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
+  cache.set(full, box.exports);
+  return box.exports;
+}
+
+const tools = loadTs(path.join(ROOT, "B05_Profile", "B05_Profile_UI_Profile_Panel_Tools.ts"));
+const base = loadTs(path.join(ROOT, "B06_Section", "B06_Section_UI_Cross_Panel_Base.ts"));
+
+// 엄상준 263.21 관 — 횡단 보기에서 그 관 카드가 골라져 종단도도 그 관 측점을 고른 상태
+const pipe = { id: "p1", chainage_m: 263.21, origin: "pipe" };
+tools.createPanelTools({
+  root: { isConnected: true },
+  base: () => ({}),
+  alignment: () => null,
+  edits: () => ({}),
+  applyEdits: () => undefined,
+  selectedStationId: () => "irregular:p1",
+  irregularStations: () => [pipe],
+  stationIdOf: (s) => `irregular:${s.id}`,
+  moveStation: (s, to) => calls.move.push([s.chainage_m, to]),
+  drainage: { pipeChainages: () => [], setPipeChainages: () => undefined },
+  restore: () => undefined,
+  restoreSaved: () => undefined,
+  canRestoreSaved: () => false,
+  refresh: () => undefined,
+});
+
+/** 누른 자리 — 종단도 안이면 closest 가 그 판을 줌(새 창 요소처럼 Element 가 아닌 것도). */
+const spot = (inProfile) => ({
+  closest: (sel) => (inProfile && sel === ".b05-route-profile" ? {} : null),
+});
+const press = (target) => listeners.document.pointerdown?.forEach((fn) => fn({ target }));
+
+/** 횡단 조정창 흉내 — 관 · 도수로 띠를 고른 동안 `swallowsArrows` 면 삼킴(Cross_Structure_Panel 배선과 같음). */
+let side = "";
+const crossPanel = (event) => {
+  if (base.swallowsArrows(side, event.key)) event.preventDefault();
+};
+listeners.document.keydown = new Set([crossPanel]);
+
+function key(name) {
+  const event = {
+    key: name,
+    target: null,
+    repeat: false,
+    defaultPrevented: false,
+    preventDefault() {
+      this.defaultPrevented = true;
+    },
+  };
+  listeners.document.keydown.forEach((fn) => fn(event));
+  listeners.window.keydown?.forEach((fn) => fn(event));
+  listeners.window.keyup?.forEach((fn) => fn({ key: name }));
+  return event.defaultPrevented;
+}
+
+function run(steps) {
+  calls.move = [];
+  calls.edits = 0;
+  steps();
+  return { move: calls.move, edits: calls.edits };
+}
+
+const out = {
+  // 횡단 카드를 누른 뒤(조정창 없음) ← → = 안 옮김 — 옛 흠: 263.21 → 263.31
+  cardThenArrows: run(() => {
+    press(spot(false));
+    key("ArrowRight");
+    key("ArrowLeft");
+  }),
+  // 종단도를 누른 뒤 ← → = 지금처럼 0.1 m 이동
+  profileThenArrows: run(() => {
+    press(spot(true));
+    key("ArrowRight");
+  }),
+  // 새 창 종단도(다른 창 요소)도 종단도 안
+  popoutThenArrows: run(() => {
+    press(Object.create(null, { closest: { value: spot(true).closest } }));
+    key("ArrowLeft");
+  }),
+  // 횡단에서 도수로 띠 고름 · 카드 쪽 누름 = 방향키 넷 다 아무것도 안 옮김(계획고도)
+  chute: run(() => {
+    side = "chute";
+    press(spot(false));
+    ["ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown"].forEach(key);
+  }),
+  pipeSide: run(() => {
+    side = "pipe";
+    press(spot(false));
+    key("ArrowRight");
+    key("ArrowUp");
+  }),
+  // 도수로 고른 채 종단도를 누르면 방향키는 종단도 몫
+  chuteThenProfile: run(() => {
+    side = "chute";
+    press(spot(true));
+    key("ArrowRight");
+  }),
+  // 조정창 있는 벽 고름 · 고름 없음 = 삼키지 않음(조정창 · 종단도 제 길)
+  swallow: {
+    wall: base.swallowsArrows("inlet", "ArrowRight"),
+    none: base.swallowsArrows("", "ArrowRight"),
+    letter: base.swallowsArrows("chute", "a"),
+  },
+};
+side = "";
+out.cardUpArrow = run(() => {
+  press(spot(false));
+  key("ArrowUp"); // 고름 없는 카드 ▲ = 계획고(24-3b 그대로)
+});
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_b09_group_cards.py b/resources/tester/helper_b09_group_cards.py
index 45027fdd4..11887582b 100644
--- a/resources/tester/helper_b09_group_cards.py
+++ b/resources/tester/helper_b09_group_cards.py
@@ -15,7 +15,7 @@ COMMON = "ui_template/ui_template_group_cards.ts"
 TABS = "B09_Estimation/B09_Estimation_UI_Tabs.ts"
 GROUPS = "B09_Estimation/B09_Estimation_UI_Tabs_Groups.ts"
 
-# 기억(b_page_state) 대신 Map · 단추(createButton) 대신 가짜 button · 157-3 원문번호 풍선(raw) 짝
+# 기억(b_page_state) 대신 Map · 단추(createButton) 대신 가짜 button · 호버(attachHoverInfo) = 부른 자리 기록 · 157-3 원문번호 풍선(raw) 짝
 STUBS = r"""
 const kept = new Map();
 const readState = (name) => (kept.has(name) ? JSON.parse(kept.get(name)) : null);
@@ -27,6 +27,8 @@ const createButton = (o) => {
   if (o.onClick) b.addEventListener("click", o.onClick);
   return b;
 };
+const hoverCalls = [];
+const attachHoverInfo = (root, text, selector) => { hoverCalls.push({ root, text, selector }); return () => {}; };
 """
 
 RAW = r"""
diff --git a/resources/tester/test_124_b08_surcharge_panel.py b/resources/tester/test_124_b08_surcharge_panel.py
index 6b8ea454b..52faf1c38 100644
--- a/resources/tester/test_124_b08_surcharge_panel.py
+++ b/resources/tester/test_124_b08_surcharge_panel.py
@@ -126,6 +126,6 @@ def test_화면_연결():
     ui = (ROOT / "B08_Quantity/B08_Quantity_UI_Material.ts").read_text(encoding="utf-8")
     assert "liveSurcharge(projectId, payload.surcharge_pct)" in ui
     assert "onOptionsChange(host," in ui
-    assert 'key === "surcharge" && !rows[i].panel' in ui and "할증 = 좌측 패널" in ui
+    assert 'key === "surcharge" && !rows[keep[i]].panel' in ui and "할증 = 좌측 패널" in ui
     panel = (ROOT / "B08_Quantity/B08_Quantity_UI_Options.ts").read_text(encoding="utf-8")
     assert "put({ material_surcharge_pct:" in panel and "body.material_surcharge_pct" in panel
diff --git a/resources/tester/test_139_1_pipe_height_follow.py b/resources/tester/test_139_1_pipe_height_follow.py
index 978ac0f69..ddc9e2c0f 100644
--- a/resources/tester/test_139_1_pipe_height_follow.py
+++ b/resources/tester/test_139_1_pipe_height_follow.py
@@ -59,13 +59,16 @@ def test_화면_높이_규칙(tmp_path: Path) -> None:
     assert run.returncode == 0, run.stderr[-2000:]
     got = json.loads(result.read_text(encoding="utf-8"))
 
-    for key in ("inlet_revet_height_m", "outlet_revet_height_m", "inlet_basin_height_m"):
+    for key in ("outlet_revet_height_m", "inlet_basin_height_m"):
         assert got["fresh"][key] == pytest.approx(1.7), key  # Φ1200 → 1.7
+    assert got["fresh"]["inlet_revet_height_m"] == pytest.approx(1.9)  # 유입 흙막이 + 0.7(211-1)
     assert "inlet_revet_height_m" not in got["noPipe"]  # 관경 없음 = 안 채움
     assert got["read"]["inlet"][0]["height"] == "1.7"  # 옛 1.5 · Φ1200 → 1.7
     assert got["read"]["outlet"][0]["height"] == "1.6"  # 손 값 그대로
     assert got["small"]["inlet"][0]["height"] == "1.5"  # Φ800 의 1.5 는 그대로
-    assert got["change"]["inlet"][0]["height"] == "2"  # 옛 규칙 값(1.7) → 새 규칙(2.0)
+    assert (
+        got["change"]["inlet"][0]["height"] == "2.2"
+    )  # 옛 + 0.5 값(1.7) → 유입 새 규칙(1.5 + 0.7)
     assert got["change"]["outlet"][0]["height"] == "2.2"  # 손 값 그대로
-    assert got["old"]["inlet"][0]["height"] == "1.3"  # 옛 1.5 → Φ800 규칙
+    assert got["old"]["inlet"][0]["height"] == "1.5"  # 옛 1.5 → Φ800 유입 규칙(0.8 + 0.7)
     assert got["old"]["outlet"][0]["height"] == ""  # 빈 칸 그대로
diff --git a/resources/tester/test_143_3_b08_material_cards.py b/resources/tester/test_143_3_b08_material_cards.py
index b21cffa34..5253fcfa4 100644
--- a/resources/tester/test_143_3_b08_material_cards.py
+++ b/resources/tester/test_143_3_b08_material_cards.py
@@ -27,5 +27,7 @@ def test_자재_셋_값_없는_줄_숨김():
 
 
 def test_표_넷_공용_카드_안():
-    assert "createCard({ body: [toolbar, table.root, excel] })" in MATERIAL  # + 엑셀 알림(160-4)
-    assert "createCard({ body: parts })" in SUMMARY
+    assert (
+        "createCard({ body: [toolbar, table.root, excel, notes] })" in MATERIAL
+    )  # + 엑셀 알림(160-4) · 안내 = 아래(202-1)
+    assert "createCard({ body: [table, ...parts] })" in SUMMARY
diff --git a/resources/tester/test_144_b09_skeleton.py b/resources/tester/test_144_b09_skeleton.py
index 5c652cd11..7b4409486 100644
--- a/resources/tester/test_144_b09_skeleton.py
+++ b/resources/tester/test_144_b09_skeleton.py
@@ -1,6 +1,6 @@
 """144-1 B09 뼈대 — 탭 차례 · 저장 자리 · 길 · 빈칸 규칙 · 「연결 없음」 목록 · 단가 굳히기.
 
-- 탭 = 기번3 공통 엑셀 보이는 탭 차례(목차 · 안내 = 「연결 점검」 한 탭 · INITIAL 안 옮김)
+- 탭 = 기번3 공통 엑셀 보이는 탭 차례(목차 · 안내 = 좌측 「데이터 점검」 묶음 203-1 · INITIAL 안 옮김)
 - 저장 = 프로젝트 안 `B09_Estimation/v1/`(사용자 값 · 굳힌 단가) · 결과는 저장 안 함
 - 줄 = 수요 따라(사용자 승인 ①) — 연결된 사본 없으면 노무 · 경비 · 중기 빈 표
   · B08 자재만 줄 · 출처 빈칸
@@ -45,8 +45,7 @@ def test_탭_차례가_엑셀과_같다():
         source.index("export const TABS") : source.index("];", source.index("export const TABS"))
     ]
     names = re.findall(r'\["\w+", "([^"]+)"\]', block)
-    assert names[0] == "연결 점검"
-    assert names[1:] == EXCEL_TABS
+    assert names == EXCEL_TABS  # 203-1 「연결 점검」 탭 = 좌측 묶음으로 옮김
 
 
 def test_길_셋():
diff --git a/resources/tester/test_155_b09_tabs.py b/resources/tester/test_155_b09_tabs.py
index 4f58a2581..a59f43219 100644
--- a/resources/tester/test_155_b09_tabs.py
+++ b/resources/tester/test_155_b09_tabs.py
@@ -52,16 +52,18 @@ def test_155_2_일위대가표_제목_굵게_하위_ㄴ():
     out = _node(
         f"\nconst t = buildDaegaBlocks({{ sheets: {{ daega_blocks: [{json.dumps(BLOCK)}] }} }});"
         "\nconsole.log(JSON.stringify({ names: t.rows.map((r) => r.name),"
-        " cls: t.rows.map((_, i) => t.rowClass(i) ?? null) }));"
+        " cls: t.rows.map((_, i) => t.rowClass(i) ?? null),"
+        " lv: [t.level.key, ...t.rows.map((_, i) => t.level.of(i))] }));"
     )
     assert out["names"] == [
         "제 1 호표  찰쌓기",
-        "  ㄴ 건설표준품셈 7-1-2",
-        "  ㄴ 석공",
-        "  ㄴ 뒷채움",
-        "  합  계",
-    ]
+        "ㄴ 건설표준품셈 7-1-2",
+        "ㄴ 석공",
+        "ㄴ 뒷채움",
+        "합  계",
+    ]  # 201-1 들여쓰기 = 공용 표 level(앞 빈칸 없앰)
     assert out["cls"] == ["is-title", None, None, None, "is-title"]
+    assert out["lv"] == ["name", 1, 2, 2, 2, 1]
 
 
 SG = {
@@ -92,12 +94,12 @@ def test_155_5_단가산출근거_엑셀_꼴_칸():
     rows = out["rows"]
     assert [(r.get("kind"), r["text"]) for r in rows] == [
         ("제 1 호표", "뒷채움 / m3"),
-        (None, "  산림품셈 13-3-2 적용"),
-        (None, "  규격 : 150 mm"),
-        ("노무", "  보통인부 : 165,545 * 0.018 = 2,979.8"),
-        ("중기", "  굴착기 노무비 : 55,700 * 0.07 = 3,899.0"),
-        ("", "  굴착기 재료비 : 7,695 * 0.07 = 538.6"),
-        ("", "  굴착기 경비 : 13,041 * 0.07 = 912.8"),
+        (None, "산림품셈 13-3-2 적용"),
+        (None, "규격 : 150 mm"),
+        ("노무", "보통인부 : 165,545 * 0.018 = 2,979.8"),
+        ("중기", "굴착기 노무비 : 55,700 * 0.07 = 3,899.0"),
+        ("중기", "굴착기 재료비 : 7,695 * 0.07 = 538.6"),  # 201-1 같은 공종 = 세로 병합
+        ("중기", "굴착기 경비 : 13,041 * 0.07 = 912.8"),
         ("총  계", "계 : 노무비 6,878 + 재료비 538 + 경비 912 = 8,328"),
     ]
     assert [r.get("sum") for r in rows[3:7]] == [2979.8, 3899.0, 538.6, 912.8]
diff --git a/resources/tester/test_166_2_b09_bill_hand.py b/resources/tester/test_166_2_b09_bill_hand.py
index 9b2c75113..45a41bbca 100644
--- a/resources/tester/test_166_2_b09_bill_hand.py
+++ b/resources/tester/test_166_2_b09_bill_hand.py
@@ -229,8 +229,9 @@ console.log(JSON.stringify(out));
     assert out["title"] == [*add, "아래에 하위 줄 추가", "새 공종 추가(1단)", "-", "줄 지우기"]
     assert out["auto"] == [*add, "새 공종 추가(1단)", "-", "연결", "-", "아래로 ↓", "내어쓰기 ←",
                            "-", "자동값으로 되돌리기", "줄 지우기"]  # fmt: skip
+    # 204 — 위 항목 아래로 들여쓰기 됨(그 항목 = 저절로 묶음)
     assert out["hand"] == [*add, "새 공종 추가(1단)", "-", "연결", "연결 풀기", "-", "위로 ↑",
-                           "내어쓰기 ←", "묶음 줄로 바꾸기", "-", "줄 지우기"]  # fmt: skip
+                           "들여쓰기 →", "내어쓰기 ←", "묶음 줄로 바꾸기", "-", "줄 지우기"]  # fmt: skip
     # 위에 줄 = 같은 부모 앞 · 옛 꼴 → v2(옛 손 줄 칸 · 수량 덮개 옮김)
     above = out["above"]
     assert [e["key"][:5] for e in above["rows"]] == ["sec:1", "sec:1", "hand:", "earth", "hand:"]
diff --git a/resources/tester/test_171_3_b09_group_tabs.py b/resources/tester/test_171_3_b09_group_tabs.py
index aaee869e7..4ac6abbc9 100644
--- a/resources/tester/test_171_3_b09_group_tabs.py
+++ b/resources/tester/test_171_3_b09_group_tabs.py
@@ -142,21 +142,21 @@ def test_화면_보기_바꿈_누름_이동():
     out = run(
         [COMMON, TABS, f"{B09}Labor.ts", GROUPS],
         f"\nconst spec = buildDaegaBlocks({{ sheets: {{ daega_blocks: [{json.dumps(DG, ensure_ascii=False)}] }} }});"
-        "\nconst gone = []; let redraws = 0; const focused = [];"
+        "\nconst gone = []; let redraws = 0; const focused = []; const calls = [];"
         "\nconst o = { tab: 'dg', spec, hint: null, focus: 'DG1|1', goto: (l) => gone.push(l),"
-        " redraw: () => redraws++, makeTable: () => ({ root: document.createElement('table'),"
+        " redraw: () => redraws++, setTools: (t) => calls.push(t), makeTable: () => ({ root: document.createElement('table'),"
         " focusRow: (i) => focused.push(i) }) };"
         "\nconst [view] = renderGroupPanel(o);"
-        "\nconst btn = view.querySelector('[data-b09-group-view]');"
+        "\nconst btn = calls[0].find((e) => e.dataset.b09GroupView);"
         "\nconst label = btn.textContent;"
         "\nview.querySelector('[data-at=\"2\"]').click();"
         "\nview.querySelector('[data-at=\"0\"]').click();"
         "\nconst lit = view.querySelector('[data-at=\"3\"]').classList.contains('is-focus');"
         "\nconst box = view.querySelector('.ui-group-card').classList.contains('is-pick');"
         "\nbtn.click();"
-        "\nconst [bar2, view2] = renderGroupPanel(o);"
+        "\nconst [view2] = renderGroupPanel(o);"
         "\nconsole.log(JSON.stringify({ label, table: view.dataset.b09Table, gone, lit, box, redraws,"
-        " label2: bar2.children[0].textContent, tag2: view2.tagName, focused,"
+        " label2: calls[1].find((e) => e.dataset.b09GroupView).textContent, tag2: view2.tagName, focused,"
         " kept: Object.fromEntries(kept) }));",
         RAW,
     )
@@ -171,7 +171,11 @@ def test_화면_보기_바꿈_누름_이동():
 
 def test_잇기():
     shell = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Shell.ts").read_text("utf-8")
-    assert "if (isGroupTab(tab)) {" in shell and "renderGroupPanel({ tab, spec," in shell
+    assert (
+        "if (isGroupTab(tab)) {" in shell
+        and "renderGroupPanel({" in shell
+        and "setTools: bars.setTools" in shell
+    )
     state = (ROOT / "A00_Common" / "b_page_state.ts").read_text("utf-8")
     assert '"b09-group-view": { bucket: "pref", scope: "global" },' in state
     assert '"b09-group-cols": { bucket: "pref", scope: "global" },' in state
diff --git a/resources/tester/test_174_b07_cross_cell_stack.py b/resources/tester/test_174_b07_cross_cell_stack.py
index cb4982436..eefcac2ce 100644
--- a/resources/tester/test_174_b07_cross_cell_stack.py
+++ b/resources/tester/test_174_b07_cross_cell_stack.py
@@ -11,7 +11,7 @@
 
 import pytest
 
-from B07_DesignDetail.B07_DesignDetail_Engine_Cad import GROUND_LAYER_ID
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad import GROUND_COLOR
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import (
     CELL_TABLE_PAD_MM,
     build_cross_sheet,
@@ -95,7 +95,9 @@ def test_같은_행_표_한_높이_그림_중심_칸_가운데() -> None:
     assert tables[0][0] == pytest.approx(tables[1][0])
     # 도로 중심(offset 0) = 칸 가운데 · 그림(원지반) 아래 끝 = 글(없으면 표) 위 8 mm
     grounds = [
-        entities_bbox([e]) for e in drawing["entities"] if e.get("layerId") == GROUND_LAYER_ID
+        entities_bbox([e])
+        for e in drawing["entities"]
+        if e.get("type") == "PolyLine" and e.get("lineColor") == GROUND_COLOR
     ]
     for placement, slot, table, design, ground in zip(
         drawing["cross_placements"], sheet["slots"], tables, designs, grounds, strict=True
diff --git a/resources/tester/test_179_4_detail_table.py b/resources/tester/test_179_4_detail_table.py
index a513fc37e..6df144346 100644
--- a/resources/tester/test_179_4_detail_table.py
+++ b/resources/tester/test_179_4_detail_table.py
@@ -113,10 +113,8 @@ def test_그래프_고르기_띠_키_판정_선_m(out):
     assert area["fill"] == {"src": "area", "key": "embankment"}
     assert area["spoil"] == {"src": "area", "key": "spoil_fill"}
     assert area["other"] is None
-    length = out["length"]
-    assert length["src"] == "length"
-    assert length["start"] == pytest.approx(PICK[0]) and length["end"] == pytest.approx(PICK[1])
-    assert out["lengthBad"] is None
+    # 화면 px → m(209-1 `pxToM`) · 옛 저장 꼴(두 끝) 길이 = hypot 그대로
+    assert out["pxBack"][0] == pytest.approx(PICK[0]) and out["pxBack"][1] == pytest.approx(PICK[1])
     assert out["lengthValue"] == pytest.approx(hypot(4.0, 2.0))
 
 
@@ -261,4 +259,5 @@ def test_저장_patch_배선_초안_등록():
     assert '"detail-table": { bucket: "draft", scope: "route" }' in state
     detail = (ROOT / "B06_Section" / "B06_Section_UI_Cross_Detail.ts").read_text(encoding="utf-8")
     assert "designForTable(state.section, projectId, routeId)" in detail
-    assert "const detachTable = attachDetailTable({" in detail
+    assert "const tablePick = attachDetailTable({" in detail
+    assert "tablePick.redraw();" in detail
diff --git a/resources/tester/test_180_2_b07_cross_scale.py b/resources/tester/test_180_2_b07_cross_scale.py
index 3fc8dec6e..e9d47710d 100644
--- a/resources/tester/test_180_2_b07_cross_scale.py
+++ b/resources/tester/test_180_2_b07_cross_scale.py
@@ -14,7 +14,7 @@ from pathlib import Path
 
 import pytest
 
-from B07_DesignDetail.B07_DesignDetail_Engine_Cad import DRAWING_FORMAT, GROUND_LAYER_ID
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad import DRAWING_FORMAT, GROUND_COLOR
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import (
     CELL_TABLE_PAD_MM,
     build_cross_sheet,
@@ -81,7 +81,9 @@ def test_배율_15_표_크기와_쌓기() -> None:
         bottom = shape["origin"]["y"] - sum(shape["rowHeights"])
         assert bottom == pytest.approx(slot[1] - h / 4 + CELL_TABLE_PAD_MM)  # 표 아래선 그대로
     grounds = [
-        entities_bbox([e]) for e in drawing["entities"] if e.get("layerId") == GROUND_LAYER_ID
+        entities_bbox([e])
+        for e in drawing["entities"]
+        if e.get("type") == "PolyLine" and e.get("lineColor") == GROUND_COLOR
     ]
     # 글 2 줄 × 3.0 × 1.5 = 9 mm · 간격 8 mm 는 배율 안 탐
     tops = [t["shapeData"]["origin"]["y"] for t in tables]
diff --git a/resources/tester/test_180_b07_cross_group.py b/resources/tester/test_180_b07_cross_group.py
index 4feffb1a1..d98296baa 100644
--- a/resources/tester/test_180_b07_cross_group.py
+++ b/resources/tester/test_180_b07_cross_group.py
@@ -10,6 +10,7 @@
 
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad import (
     FRAME_LAYER_ID,
+    GROUND_COLOR,
     GROUND_LAYER_ID,
     build_cross_drawing,
 )
@@ -57,7 +58,9 @@ def _ground_locked(drawing: dict) -> bool:
 
 
 def test_원지반_층_안_잠김() -> None:
-    assert _ground_locked(_drawing()) is False
+    # 장 = 원지반이 측점 층에(212-2) · 도각 말고 잠긴 층 없음
+    layers = _drawing()["layers"]
+    assert not any(layer["isLocked"] for layer in layers if layer["id"] != FRAME_LAYER_ID)
     single = build_cross_drawing(_source(0.0), "cross_00000m", _design_line(), None, None, "")
     assert _ground_locked(single) is False
 
@@ -72,9 +75,9 @@ def test_측점마다_groupId_하나() -> None:
     assert {e["groupId"] for e in grouped} == set(group_ids)
     for group_id in group_ids:
         members = [e for e in grouped if e["groupId"] == group_id]
-        layers = {e["layerId"] for e in members}
         types = {e["type"] for e in members}
-        assert GROUND_LAYER_ID in layers and "Table" in types and "Text" in types
+        ground = any(e["type"] == "PolyLine" and e["lineColor"] == GROUND_COLOR for e in members)
+        assert ground and "Table" in types and "Text" in types
     # 격자선 · 도각은 묶지 않음
     assert all("groupId" not in e for e in drawing["entities"] if e["layerId"] == FRAME_LAYER_ID)
     assert all(e["layerId"] != FRAME_LAYER_ID for e in grouped)
diff --git a/resources/tester/test_181_1_b09_tab_groups.py b/resources/tester/test_181_1_b09_tab_groups.py
index c1e288330..12f27f1d5 100644
--- a/resources/tester/test_181_1_b09_tab_groups.py
+++ b/resources/tester/test_181_1_b09_tab_groups.py
@@ -1,6 +1,6 @@
-"""181-1 B09 탭 두 층 — 위 탭 10 · 아래 탭 묶음(사용자 30번) · 줄 그리기 · 마지막 본 아래 탭.
+"""181-1 B09 탭 두 층 — 위 탭 9(203-1 연결 점검 뺌) · 아래 탭 묶음(사용자 30번) · 줄 그리기 · 마지막 본 아래 탭.
 
-- 위 탭 = `TAB_GROUPS`(`TABS` 19 키를 빠짐 · 겹침 없이 묶음) · `TABS`(엑셀 차례)는 그대로
+- 위 탭 = `TAB_GROUPS`(`TABS` 18 키를 빠짐 · 겹침 없이 묶음) · `TABS`(엑셀 차례)는 그대로
 - 줄 = 위 md · 아래 sm · 아래 탭 없는 위 탭 = 빈 보조 줄(B08 꼴)
 """
 
@@ -18,7 +18,6 @@ BAR = "B09_Estimation/B09_Estimation_UI_TabBar.ts"
 
 # 사용자 30번 — 위 탭 차례 = 지금 탭 차례(묶음 첫 자리) · 아래 = 글에 적힌 차례
 EXPECTED = [
-    ["연결 점검", ["check"]],
     ["공사원가계산서", ["cost"]],
     ["총괄설계내역서", ["total"]],
     ["설계내역서", ["bill"]],
@@ -31,7 +30,7 @@ EXPECTED = [
 ]
 
 
-def test_묶음_표_사용자_30번과_같고_19_탭이_한_번씩():
+def test_묶음_표_사용자_30번과_같고_18_탭이_한_번씩():
     out = run(
         [TABS],
         "\nconsole.log(JSON.stringify({ groups: TAB_GROUPS, ids: TABS.map(([t]) => t),"
@@ -39,11 +38,11 @@ def test_묶음_표_사용자_30번과_같고_19_탭이_한_번씩():
     )
     assert out["groups"] == EXPECTED
     flat = [t for _, tabs in out["groups"] for t in tabs]
-    assert sorted(flat) == sorted(out["ids"]) and len(flat) == len(set(flat)) == 19
+    assert sorted(flat) == sorted(out["ids"]) and len(flat) == len(set(flat)) == 18
     # 위 탭 차례 = 엑셀 차례에서 묶음이 처음 나오는 자리
     firsts = list(dict.fromkeys(out["of"]))
     assert firsts == [g[0] for g in EXPECTED]
-    assert len(firsts) == 10
+    assert len(firsts) == 9
 
 
 def test_줄_그리기_두_층_빈_줄_마지막_본_아래_탭():
@@ -55,32 +54,32 @@ const bars = createTabBars((t) => picks.push(t));
 const view = () => ({
   top: bars.top.children.map((b) => [b.textContent, b.className, b.attrs['aria-selected'],
     b.dataset.b09Group, b.dataset.b09Tab ?? null]),
-  sub: bars.sub.children.map((b) => [b.textContent, b.attrs['aria-selected'], b.dataset.b09Tab ?? null]),
+  sub: bars.sub.children.filter((b) => !b.classList.contains('b09-estimation__tools')).map((b) => [b.textContent, b.attrs['aria-selected'], b.dataset.b09Tab ?? null]),
   blank: bars.sub.classList.contains('b09-estimation__tabs--blank'),
   role: bars.sub.attrs.role,
 });
 bars.draw('dg');
 const a = view();
-bars.top.children[4].click();            // 켜진 위 탭 다시 누름 = 아무 일 없음
+bars.top.children[3].click();            // 켜진 위 탭 다시 누름 = 아무 일 없음
 bars.sub.children[0].click();            // 일위대가목록표
 bars.draw('compare');                    // 묶음을 넘는 이동 = 위 탭 따라 켜짐
 const b = view();
 bars.draw('sum_material');
 bars.draw('dg');
-bars.top.children[8].click();            // 재료 = 마지막 본 아래 탭(재료비수량금액집계표)
-bars.top.children[7].click();            // 중기 = 본 적 없음 → 첫 아래 탭
+bars.top.children[7].click();            // 재료 = 마지막 본 아래 탭(재료비수량금액집계표)
+bars.top.children[6].click();            // 중기 = 본 적 없음 → 첫 아래 탭
 bars.draw('cost');
 const c = view();
-bars.top.children[0].click();            // 연결 점검 = 단독 위 탭
+bars.top.children[1].click();            // 총괄설계내역서 = 단독 위 탭
 bars.sub.children[0].click();            // 빈 줄 단추(숨김) = 누름 없음
 console.log(JSON.stringify({ a, b, c, picks }));
 """,
     )
     a, b, c = out["a"], out["b"], out["c"]
-    assert len(a["top"]) == 10 and [t[0] for t in a["top"]][:5] == [
-        "연결 점검", "공사원가계산서", "총괄설계내역서", "설계내역서", "일위대가"
+    assert len(a["top"]) == 9 and [t[0] for t in a["top"]][:5] == [
+        "공사원가계산서", "총괄설계내역서", "설계내역서", "일위대가", "단가산출"
     ]  # fmt: skip
-    assert [t[2] for t in a["top"]] == ["false"] * 4 + ["true"] + ["false"] * 5
+    assert [t[2] for t in a["top"]] == ["false"] * 3 + ["true"] + ["false"] * 5
     assert all("ui-btn--ghost" in t[1] for t in a["top"] if t[2] == "false")
     assert a["sub"] == [["일위대가목록표", "false", "dg_list"], ["일위대가표", "true", "dg"]]
     assert not a["blank"] and a["role"] == "tablist"
@@ -89,11 +88,11 @@ console.log(JSON.stringify({ a, b, c, picks }));
         ["자재단가대비표", "true", "compare"],
         ["재료비수량금액집계표", "false", "sum_material"],
     ]  # fmt: skip
-    assert b["top"][8][2] == "true" and b["top"][4][2] == "false"
+    assert b["top"][7][2] == "true" and b["top"][3][2] == "false"
     # 단독 위 탭 — 위 단추가 탭 키도 가짐 · 아래 줄 = 숨긴 단추 한 개
     assert c["blank"] and c["role"] == "presentation" and len(c["sub"]) == 1
-    assert c["top"][1][3] == "cost" and c["top"][1][4] == "cost" and c["top"][4][4] is None
-    assert out["picks"] == ["dg_list", "sum_material", "machine", "check"]
+    assert c["top"][0][3] == "cost" and c["top"][0][4] == "cost" and c["top"][3][4] is None
+    assert out["picks"] == ["dg_list", "sum_material", "machine", "total"]
 
 
 def test_잇기_쉘이_두_줄을_쓰고_CSS_빈_줄_규칙():
diff --git a/resources/tester/test_181_2_b09_box_pick.py b/resources/tester/test_181_2_b09_box_pick.py
index 05d14ce34..f078bc23f 100644
--- a/resources/tester/test_181_2_b09_box_pick.py
+++ b/resources/tester/test_181_2_b09_box_pick.py
@@ -49,7 +49,7 @@ def test_표_보기_줄_class_넘김():
         [COMMON, TABS, GROUPS],
         f"\nconst spec = {{ columns: [{{ key: 'key' }}], rows: {json.dumps(ROWS)} }};"
         "\nlet extra = null;"
-        "\nconst o = { tab: 'dg', spec, hint: null, focus: 'B|1', goto: () => {}, redraw: () => {},"
+        "\nconst o = { tab: 'dg', spec, hint: null, focus: 'B|1', goto: () => {}, redraw: () => {}, setTools: () => {},"
         " makeTable: (e) => { extra = e; return { root: document.createElement('table'),"
         " focusRow: () => {} }; } };"
         "\nchosen.set('dg', 'table');"
diff --git a/resources/tester/test_182_b09_bill_level.py b/resources/tester/test_182_b09_bill_level.py
index f9f68a211..cccc9ecf4 100644
--- a/resources/tester/test_182_b09_bill_level.py
+++ b/resources/tester/test_182_b09_bill_level.py
@@ -281,6 +281,7 @@ const out = {
   connect: ["hand:a", "hand:c", "hand:g1", "earth:4"].map((k) => table.rows[at(k)].connect),
   link: [table.link(at("hand:a"), "connect"), table.link(at("hand:a"), "name")],
   cls: ["sec:1", "hand:g1", "hand:a", "earth:4"].map((k) => table.rowClass(at(k))),
+  lv: [table.level.key, ...["sec:1", "hand:g1", "hand:a", "earth:4"].map((k) => table.level.of(at(k)))],
   edit: [table.editable(at("hand:g1"), "name"), table.editable(at("hand:g1"), "qty")],
 };
 table.onCell(at("hand:a"), "connect");
@@ -309,9 +310,20 @@ def test_연결_단추_칸_메뉴_고르기_창_TS():
     # 184-3 모든 항목 줄 · 새 줄 연결됨 = 호표 번호 · 자동 줄 연결됨 = 「연결됨」 · 묶음 = 없음
     assert out["link"] == [None, {"tab": "dg", "key": "DG:a"}]  # 단추 칸 = 이동 안 함
     assert out["cls"] == [
-        "is-lv1 is-title", "is-lv3 is-group is-hand", "is-lv4 is-hand", "is-lv3"]  # fmt: skip
+        "is-title",
+        "is-group is-hand",
+        "is-hand",
+        None,
+    ]  # fmt: skip  201-1 레벨 = 공용 표 level
+    assert out["lv"] == ["name", 1, 3, 4, 3]
     assert out["edit"] == [True, False]  # 묶음 줄 = 이름만
-    picks = ["일위대가 호표", "단가산출 호표", "단가산출 로직(M01 · 새 산근)"]
+    picks = [
+        "일위대가 호표",
+        "단가산출 호표",
+        "서고 구조물조합(마스터 · 회사 · 개인)",
+        "서고 일위대가 사전조합(마스터 · 회사 · 개인)",
+        "단가산출 로직(M01 · 새 산근)",
+    ]  # 204-2
     # 누른 칸 아래(left · bottom) · 묶음 줄 = 안 엶 · 연결된 줄(자동 줄도) = 연결 풀기 더함
     unlink = [10, 40, [*picks, "-", "연결 풀기"]]
     assert out["menus"] == [unlink, unlink, [10, 40, picks]]
diff --git a/resources/tester/test_184_3_b09_bill_menu.py b/resources/tester/test_184_3_b09_bill_menu.py
index c9062f9a3..653d8a64d 100644
--- a/resources/tester/test_184_3_b09_bill_menu.py
+++ b/resources/tester/test_184_3_b09_bill_menu.py
@@ -125,10 +125,13 @@ def test_메뉴_모든_줄():
     # 자동 항목 = 더함 · 연결 · 옮김 · 지움(고친 칸 없음 = 자동값으로 없음)
     assert out["earth:4"] == [*add, "새 공종 추가(1단)", "-", "연결", "연결 풀기", "-",
                               "아래로 ↓", "내어쓰기 ←", "-", "줄 지우기"]  # fmt: skip
+    # 204 — 위 형제가 항목이어도 들여쓰기 됨(그 항목 = 저절로 묶음)
     assert out["earth:5"] == [*add, "새 공종 추가(1단)", "-", "연결", "-", "위로 ↑", "아래로 ↓",
-                              "내어쓰기 ←", "-", "자동값으로 되돌리기", "줄 지우기"]  # fmt: skip
+                              "들여쓰기 →", "내어쓰기 ←", "-", "자동값으로 되돌리기",
+                              "줄 지우기"]  # fmt: skip
     assert out["hand:g"] == [*add, "아래에 하위 줄 추가", "새 공종 추가(1단)", "-", "위로 ↑",
-                             "아래로 ↓", "내어쓰기 ←", "항목으로 바꾸기", "-", "줄 지우기"]  # fmt: skip
+                             "아래로 ↓", "들여쓰기 →", "내어쓰기 ←", "항목으로 바꾸기", "-",
+                             "줄 지우기"]  # fmt: skip
     assert out["hand:a"] == [*add, "새 공종 추가(1단)", "-", "연결", "연결 풀기", "-", "내어쓰기 ←",
                              "묶음 줄로 바꾸기", "-", "줄 지우기"]  # fmt: skip
     # 조달수수료 · 관급 자재 = 연결 · 옮김 · 지움 없음 · 관급자재대 제목 = 옮김 · 지움 없음
diff --git a/resources/tester/test_185_1_b09_total_level.py b/resources/tester/test_185_1_b09_total_level.py
index e6011ee2b..6608e4ae1 100644
--- a/resources/tester/test_185_1_b09_total_level.py
+++ b/resources/tester/test_185_1_b09_total_level.py
@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
-"""185-1 B09 총괄설계내역서 · 공사원가계산서 줄 레벨 — 줄 `level` · 줄 class(182 is-lvN) · 칸 class · CSS.
+"""185-1 B09 총괄설계내역서 · 공사원가계산서 줄 레벨 — 줄 `level` · 1단 굵게 · 공용 표 level 옵션(201-1).
 
 레벨 = 화면이 정함(줄 짜임이 `B09_Estimation_UI_Tabs_Total.ts` 에 있음 · 셈 짝은 값만 냄 → 거울 없음).
 총괄 = 가.~바. 소계 1(굵게) · 그 밖 2 · 원가계산서 = 구분만 1 · 비목 소계 2 · 세목 3.
-들여쓰기 = 명칭 칸(is-indent) · 앞 칸(is-flat)은 그대로.
+들여쓰기 = 공용 표 level { key: 명칭 칸 · of = 줄 level }(201-1 · 옛 is-lvN · is-indent · is-flat 갈음).
 """
 
 import json
@@ -20,7 +20,7 @@ SUMS = {"material": 194234417, "labor": 346800554, "expense": 169324165, "supply
 BODY = f"""
 const user = {{ estimate: {{}} }};
 const ctx = {{ sheets: {{ total: computeTotal({json.dumps(SUMS)}, user.estimate) }}, payload: {{}}, user, setUser: () => {{}} }};
-const pack = (t) => t.rows.map((r, i) => [r.key, r.level, t.rowClass(i), t.cellClass(i, "name"), t.cellClass(i, t.columns[0].key), t.cellClass(i, "amount")]);
+const pack = (t) => t.rows.map((r, i) => [r.key, r.level, t.rowClass(i), t.level.key, t.level.of(i), t.cellClass ?? null]);
 console.log(JSON.stringify({{ total: pack(buildTotal(ctx)), cost: pack(buildCost(ctx)) }}));
 """
 
@@ -42,39 +42,35 @@ def _run() -> dict:
 def test_총괄_레벨():
     rows = {k: (lv, cls) for k, lv, cls, *_ in _run()["total"]}
     top = ["direct", "net_cost", "da", "supply_price", "contract", "grand"]
-    assert all(rows[k] == (1, "is-lv1 is-title") for k in top)
+    assert all(rows[k] == (1, "is-title") for k in top)
     for k in ["in_price", "in_env", "indirect_labor", "machine", "retirement", "overhead", "vat",
               "supply"]:  # fmt: skip
-        assert rows[k] == (2, "is-lv2"), k
+        assert rows[k] == (2, None), k
     assert {lv for lv, _ in rows.values()} == {1, 2}
 
 
 def test_원가계산서_레벨():
     rows = {k: (lv, cls) for k, lv, cls, *_ in _run()["cost"]}
     for k in ["overhead", "profit", "supply_price", "vat", "contract", "supply", "grand"]:
-        assert rows[k] == (1, "is-lv1 is-title"), k
+        assert rows[k] == (1, "is-title"), k
     for k in ["material", "labor", "expense_sum"]:
-        assert rows[k] == (2, "is-lv2"), k
+        assert rows[k] == (2, None), k
     for k in ["direct_material", "scrap", "direct_labor", "indirect_labor", "expense", "safety"]:
-        assert rows[k] == (3, "is-lv3"), k
+        assert rows[k] == (3, None), k
 
 
-def test_칸_class_명칭만_들여씀():
+def test_명칭_칸만_들여씀_공용_level():
     out = _run()
     for tab in ("total", "cost"):
-        for _k, _lv, _cls, name, first, amount in out[tab]:
-            assert (name, first, amount) == ("is-indent", "is-flat", None)
+        for _k, lv, _cls, key, of, cell in out[tab]:
+            assert (key, of, cell) == ("name", lv, None)  # 칸 class(is-indent · is-flat) 없음
 
 
-def test_CSS_레벨_규칙():
+def test_CSS_옛_레벨_규칙_없음_공용_표로():
     css = (B09 / "B09_Estimation_UI_Page.css").read_text(encoding="utf-8")
+    assert "is-indent" not in css and "is-flat" not in css and "is-lv" not in css
+    common = (ROOT / "ui_template" / "ui_template_data_table.css").read_text(encoding="utf-8")
     assert re.search(
-        r'tr\[class\*="is-lv"\] td\.is-flat:first-child \{\s*padding-left: var\(--spacing-8\);', css
+        r"td\.ui-data-table__lv \{\s*padding-left: calc\(var\(--spacing-8\) \+ var\(--dt-lv, 0\) \* 1em\);",
+        common,
     )
-    for lv, em in ((2, 1), (3, 2)):
-        assert re.search(
-            rf"tr\.is-lv{lv} td\.is-indent \{{\s*padding-left: calc\(var\(--spacing-8\) \+ {em}em\);",
-            css,
-        )
-    # 글자 크기 = 182 규칙 재사용(줄 높이 28px → 16px 까지)
-    assert re.search(r"tr\.is-lv1 td \{\s*font-size: var\(--text-body\);", css)
diff --git a/resources/tester/test_185_2_b09_view_bar.py b/resources/tester/test_185_2_b09_view_bar.py
index 7ddc65174..4aebd6501 100644
--- a/resources/tester/test_185_2_b09_view_bar.py
+++ b/resources/tester/test_185_2_b09_view_bar.py
@@ -1,7 +1,7 @@
-"""185-2 B09 묶음 탭 도구 줄 — 보기 바꿈 단추 글 한 줄 · 가로 열 수 단추와 같은 줄.
+"""185-2 B09 묶음 탭 보기 바꿈 단추 글 한 줄 · 가로 열 수 단추와 같은 줄.
 
-- 카드 보기 = 보기 바꿈 단추가 가로 열 수 줄(`ui-group-cards__bar`) 안 · 표 보기 = 머리 줄(`b09-estimation__bar`)
-- 단추 · 라벨 = `white-space: nowrap` · 도구 줄 = 줄바꿈 없음(`flex-wrap: nowrap`)
+- 보기 바꿈 단추 · 가로 열 수 = 도구 묶음(`setTools` · 202-1 로 페이지 보조 탭 줄 오른쪽) · 카드 판 머리 띠 = 묶음 수만
+- 단추 · 라벨 = `white-space: nowrap` · 도구 묶음 = 줄바꿈 없음(`flex-wrap: nowrap`)
 """
 
 import json
@@ -27,39 +27,43 @@ def _block(css: str, selector: str) -> str:
 
 
 def _panel(view: str, hint: str):
-    """고른 보기 · 안내 글로 그린 뒤 보기 바꿈 단추가 든 줄 · 그 줄의 열 수 단추."""
+    """고른 보기 · 안내 글로 그린 뒤 도구 묶음(보기 바꿈 단추 · 열 수 단추) · 판 안 머리 띠."""
     return run(
         [COMMON, TABS, f"{B09}Labor.ts", GROUPS],
         f"\nconst spec = buildDaegaBlocks({{ sheets: {{ daega_blocks: [{json.dumps(DG, ensure_ascii=False)}] }} }});"
         f"\nchosen.set('dg', '{view}');"
+        "\nconst tools = [];"
         f"\nconst o = {{ tab: 'dg', spec, hint: {hint}, goto: () => {{}}, redraw: () => {{}},"
+        " setTools: (t) => tools.push(...t),"
         " makeTable: () => ({ root: document.createElement('table'), focusRow: () => {} }) };"
         "\nconst out = renderGroupPanel(o);"
-        "\nconst top = out.find((e) => e.all('[data-b09-group-view]').length || e.dataset.b09GroupView);"
-        "\nconst btn = top.dataset.b09GroupView ? top : top.querySelector('[data-b09-group-view]');"
-        "\nconst bar = btn.closest('.ui-group-cards__bar') ?? btn.closest('.b09-estimation__bar') ?? top;"
+        "\nconst btn = tools.find((e) => e.dataset.b09GroupView);"
+        "\nconst bar = out[0].all('.ui-group-cards__bar')[0] ?? null;"
         "\nconsole.log(JSON.stringify({ n: out.length, first: out[0].className, label: btn.textContent,"
-        " bar: bar.className, cols: bar.all('[data-group-cols]').map((b) => b.dataset.groupCols) }));",
+        " cols: tools.flatMap((e) => e.all('[data-group-cols]')).map((b) => b.dataset.groupCols),"
+        " barBtn: bar ? bar.all('[data-b09-group-view]').length : null,"
+        " barCols: bar ? bar.all('[data-group-cols]').length : null }));",
         RAW,
     )
 
 
-def test_카드_보기_단추가_가로_열수_줄에():
+def test_카드_보기_단추가_열수_단추와_같은_도구_묶음에():
     out = _panel("cards", "null")
-    assert out["bar"] == "ui-group-cards__bar" and out["label"] == "표로 보기"
-    assert out["cols"] == ["1", "2", "3", "4"]  # 같은 줄에 열 수 단추 넷
+    assert out["label"] == "표로 보기"
+    assert out["cols"] == ["1", "2", "3", "4"]  # 같은 묶음에 열 수 단추 넷
+    assert out["barBtn"] == 0 and out["barCols"] == 0  # 카드 판 머리 띠에는 없음
     assert out["n"] == 1  # 안내 글 없으면 카드 판 하나뿐
 
 
-def test_카드_보기_안내_글은_카드_위에_따로():
+def test_카드_보기_안내_글은_카드_판_아래에():
+    # 202-1 — 안내 글 = 카드 판 아래(상세 = test_202_1)
     out = _panel("cards", HINT)
-    assert out["n"] == 2 and out["first"] == "hint"
-    assert out["bar"] == "ui-group-cards__bar"
+    assert out["n"] == 2 and out["first"] == "ui-group-cards"
 
 
-def test_표_보기_단추는_머리_줄():
+def test_표_보기_단추는_도구_묶음에():
     out = _panel("table", "null")
-    assert out["bar"] == "b09-estimation__bar" and out["label"] == "박스보기"
+    assert out["label"] == "박스보기" and out["n"] == 1
     assert out["cols"] == []  # 표 보기 = 열 수 단추 없음
 
 
@@ -72,5 +76,9 @@ def test_CSS_한_줄_nowrap():
     )
     assert "white-space: nowrap" in item and "flex: none" in item
     page = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Page.css").read_text("utf-8")
-    assert "white-space: nowrap" in _block(page, ".b09-estimation__bar .ui-btn")
+    assert "flex-wrap: nowrap" in _block(page, ".b09-estimation__tools")
+    tools = _block(
+        page, ".b09-estimation__tools .ui-btn,\n.b09-estimation__tools .ui-group-cards__label"
+    )
+    assert "white-space: nowrap" in tools
     assert "actions: [toggle]" in (ROOT / GROUPS).read_text("utf-8")
diff --git a/resources/tester/test_192_1_moved_pipe_station.py b/resources/tester/test_192_1_moved_pipe_station.py
index 9e3d9f902..680bf5e4a 100644
--- a/resources/tester/test_192_1_moved_pipe_station.py
+++ b/resources/tester/test_192_1_moved_pipe_station.py
@@ -4,7 +4,8 @@
 769.28 에 남음 → B06(측점 769.28)과 B05(관 769.38) 두 자리에 계획고 편집이 남아 0.1m 사이
 −465% 계단 · 769.38 은 측점선 없는 꼭짓점.
 고침: 판정 폭 0.005m(측점 스냅 폭) · 측점을 다시 뜨면 사라진 측점의 꼭짓점 · 편집을 지움
-(반올림 차이 0.006m 안은 옮김). 사용자 storage 는 읽기만 — 사본(tmp_path)으로 재현.
+(반올림 차이 0.006m 안은 옮김). 자료 = 고정 사본(fixtures/b05_192_1_moved_pipe_longitudinal.json ·
+226fc805 종단 460~840m · 측점 769.28 인 192 이전 상태 · 213-2) — 사용자 storage 에 기대지 않음.
 """
 
 from __future__ import annotations
@@ -22,17 +23,13 @@ if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))
 
 import B05_Profile.B05_Profile_Engine_Sections as sections  # noqa: E402
+from B05_Profile.B05_Profile_Engine_Grade_Profile import rebuild_alignment_profile  # noqa: E402
 from B05_Profile.B05_Profile_Router_Confirm import _merge_irregular_into_longitudinal  # noqa: E402
 from B06_Section.B06_Section_Router_Stations import _missing_marks  # noqa: E402
 
-SOURCE = (
-    PROJECT_ROOT
-    / "storage/1/3/226fc805-26c8-4f5a-9956-bacb200e10a5/B06_Section/longitudinal/longitudinal.json"
-)
+SOURCE = PROJECT_ROOT / "resources/tester/fixtures/b05_192_1_moved_pipe_longitudinal.json"
 REL = "B06_Section/longitudinal/longitudinal.json"
 
-needs_copy = pytest.mark.skipif(not SOURCE.is_file(), reason="검증_랩탑메인 storage 없음")
-
 
 def _copy(tmp_path: Path) -> Path:
     target = tmp_path / REL
@@ -58,20 +55,18 @@ def _irregular(data: dict, old: float, new: float) -> list[dict]:
     return result
 
 
-@needs_copy
 def test_원본_자료가_숨은_꼭짓점을_가짐() -> None:
     """까닭 근거 — 769.38 꼭짓점은 측점 목록에 없고 두 편집 사이 −465%."""
     data = _load(SOURCE)
-    alignment = data["profile_alignment"]
+    alignment, _ = rebuild_alignment_profile(data, data["profile_alignment"]["edits"])
     stations = [s["chainage_m"] for s in data["stations"]]
     pvis = [p["chainage_m"] for p in alignment["pvi"]]
     assert 769.38 in pvis and 769.38 not in stations and 769.28 in stations
-    assert set(alignment["edits"]["station_offsets"]) == {"769.280", "769.380"}
+    assert {"769.280", "769.380"} <= set(alignment["edits"]["station_offsets"])
     step = next(s for s in alignment["segments"] if s["from_m"] == 769.28)
     assert step["to_m"] == 769.38 and step["grade_percent"] < -400
 
 
-@needs_copy
 def test_관_옮긴_측점_다시_뜨면_숨은_꼭짓점_사라짐(tmp_path: Path) -> None:
     path = _copy(tmp_path)
     data = _load(path)
@@ -90,7 +85,6 @@ def test_관_옮긴_측점_다시_뜨면_숨은_꼭짓점_사라짐(tmp_path: Pa
     assert after["design_profiles"][0]["summary"]["max_grade_pct"] == summary["max_grade_pct"]
 
 
-@needs_copy
 def test_반올림_차이만_다르면_편집을_옮김(tmp_path: Path) -> None:
     path = _copy(tmp_path)
     data = _load(path)
@@ -101,7 +95,6 @@ def test_반올림_차이만_다르면_편집을_옮김(tmp_path: Path) -> None:
     assert "484.210" not in offsets and offsets["484.213"] == pytest.approx(0.3)
 
 
-@needs_copy
 def test_측점이_그대로면_계획선을_건드리지_않음(tmp_path: Path) -> None:
     path = _copy(tmp_path)
     data = _load(path)
diff --git a/resources/tester/test_196_1_b06_notice_chips.py b/resources/tester/test_196_1_b06_notice_chips.py
index 7027d4783..82ea5dbb6 100644
--- a/resources/tester/test_196_1_b06_notice_chips.py
+++ b/resources/tester/test_196_1_b06_notice_chips.py
@@ -144,9 +144,10 @@ def test_측점_누르면_그_카드로_다시_그려도_연_칩_유지_0이면_
         """
 bar.update(items(["a", "b"], [], []));
 chip("fill").click();
-panel.children[1].click();
+panel.children[1].click();  // 207-1 — 고르면 내용 칸 접힘
 chipsRow.children[0].click(); chipsRow.children[0].click();  // 칩 누름은 측점 고름 아님
 out.picks = picks.slice();
+chip("fill").click();
 bar.update(items(["a", "b", "x"], [], []));
 out.kept = view();
 bar.update(items([], ["p"], []));
@@ -165,7 +166,7 @@ out.gone = view();
 def test_알림_줄은_칩을_쓰고_긴_설명은_호버_짧은_이름은_사전():
     src = (B06 / "B06_Section_UI_Cross_FillSlope_Notice.ts").read_text(encoding="utf-8")
     assert "<details" not in src and '"details"' not in src and "summary" not in src
-    assert "createNoticeChips(onPick)" in src
+    assert "createNoticeChips(onPick, selected)" in src  # 207-1 고른 측점 넘김
     for label, hint in (
         ('L("B06_Notice_FillSlope")', "FILL_SLOPE_WARN_TEXT"),
         ('L("B06_Notice_PaveSuggested")', 'L("B06_Design_Paved_Suggested")'),
diff --git a/resources/tester/test_200_1_b09_box_tool_line.py b/resources/tester/test_200_1_b09_box_tool_line.py
new file mode 100644
index 000000000..e2ac75c0f
--- /dev/null
+++ b/resources/tester/test_200_1_b09_box_tool_line.py
@@ -0,0 +1,188 @@
+"""200-1 B09 박스보기 안내 글 줄임표 + 호버 · 카드 같은 가로 줄 높이 같게.
+
+- 안내 글 = 줄임표 한 줄 · 잘렸을 때만 공용 호버(`attachHoverInfo`)로 전문 · 자리 = 표 · 카드 판 아래(202-1 로 옮김)
+- 카드 격자 = 행 늘림(`align-items: stretch`) · 카드 = 세로 flex · 몸통이 늘어 합계 줄이 아래
+- 카드 제목 줄 · 합계 줄 바탕색(200-3)
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from resources.tester.helper_b09_group_cards import COMMON, GROUPS, RAW, TABS, run  # noqa: E402
+
+B09 = "B09_Estimation/B09_Estimation_UI_Tabs_"
+DG = {"id": "DG1", "no": 1, "name": "찰쌓기", "unit": "m2", "lines": [], "sum": 0}
+LONG = "손료 = 기준가(천원) × 손료계수 ÷ 10,000 · 운전사 = 인 × 시간 노임 · 연료 = ℓ/hr × 적용 단가"
+HINT = (
+    "(() => { const h = document.createElement('p');"
+    f" h.className = 'ui-general-block__empty'; h.textContent = '{LONG}'; return h; }})()"
+)
+
+
+def _block(css: str, selector: str) -> str:
+    m = re.search(re.escape(selector) + r"\s*\{([^}]*)\}", css)
+    assert m, selector
+    return m.group(1)
+
+
+def _panel(view: str, hint: str):
+    """고른 보기 · 안내 글로 그린 뒤 안내 글 자리 · 호버 기록."""
+    return run(
+        [COMMON, TABS, f"{B09}Labor.ts", GROUPS],
+        f"\nconst spec = buildDaegaBlocks({{ sheets: {{ daega_blocks: [{json.dumps(DG, ensure_ascii=False)}] }} }});"
+        f"\nchosen.set('dg', '{view}');"
+        f"\nconst hint = {hint};"
+        "\nconst o = { tab: 'dg', spec, hint, goto: () => {}, redraw: () => {}, setTools: () => {},"
+        " makeTable: () => ({ root: document.createElement('table'), focusRow: () => {} }) };"
+        "\nconst out = renderGroupPanel(o);"
+        "\nconst last = out[out.length - 1];"
+        "\nconst inBar = hint ? out.some((e) => e.all('.ui-group-cards__bar').some((b) => b.contains(hint))) : false;"
+        "\nconst call = hoverCalls[0];"
+        "\nconst wide = call ? call.text({ scrollWidth: 900, clientWidth: 300, textContent: 'T' }) : null;"
+        "\nconst fit = call ? call.text({ scrollWidth: 300, clientWidth: 300, textContent: 'T' }) : null;"
+        "\nconsole.log(JSON.stringify({ n: out.length, hintLast: !!hint && last === hint, inBar,"
+        " hintCls: hint ? hint.className : '', hover: hoverCalls.length,"
+        " hoverIsHint: call ? call.root === hint : false, wide, fit, first: out[0].tagName }));",
+        RAW,
+    )
+
+
+def test_카드_보기_안내_글은_카드_판_아래():
+    out = _panel("cards", HINT)
+    assert out["n"] == 2 and out["hintLast"] and not out["inBar"]  # 카드 판 + 안내 글(맨 아래)
+    assert "b09-estimation__line-hint" in out["hintCls"]
+
+
+def test_표_보기_안내_글은_표_아래():
+    out = _panel("table", HINT)
+    assert out["n"] == 2 and out["first"] == "TABLE" and out["hintLast"]  # 표 + 안내 글
+
+
+def test_안내_글_잘렸을_때만_공용_호버로_전문():
+    for view in ("cards", "table"):
+        out = _panel(view, HINT)
+        assert out["hover"] == 1 and out["hoverIsHint"]
+        assert out["wide"] == "T"  # 잘림(scrollWidth > clientWidth) = 전문
+        assert out["fit"] is None  # 다 보이면 안 띄움
+
+
+def test_안내_글_없으면_호버도_없음():
+    for view in ("cards", "table"):
+        out = _panel(view, "null")
+        assert out["n"] == 1 and out["hintLast"] is False and out["hover"] == 0
+
+
+def test_CSS_안내_글_줄임표_한_줄():
+    page = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Page.css").read_text("utf-8")
+    hint = _block(page, ".b09-estimation__line-hint")
+    for need in (
+        "overflow: hidden",
+        "text-overflow: ellipsis",
+        "white-space: nowrap",
+        "min-width: 0",
+    ):
+        assert need in hint, need
+
+
+def test_CSS_카드_같은_줄_높이_같게():
+    css = (ROOT / "ui_template" / "ui_template_group_cards.css").read_text("utf-8")
+    grid = _block(css, ".ui-group-cards__grid")
+    assert "align-items: stretch" in grid and "align-items: start" not in grid
+    card = _block(css, ".ui-group-card")
+    assert "display: flex" in card and "flex-direction: column" in card
+    assert "flex: 1 1 auto" in _block(css, ".ui-group-card__body")  # 합계 줄 = 카드 아래
+
+
+def test_잇기():
+    groups = (ROOT / GROUPS).read_text("utf-8")
+    assert "attachHoverInfo(hint," in groups and "placeTools: o.setTools" in groups
+    cards = (ROOT / COMMON).read_text("utf-8")
+    assert "opts.lead" not in cards and "if (opts.placeTools) {" in cards
+
+
+# ── 200-3 카드 제목 줄 · 합계 줄 바탕색(밝음 · 어두움) ─────────────────────────
+
+
+def _theme_vars(dark: bool) -> dict:
+    """테마 CSS 의 `:root`(밝음) · 어두움 덮어쓰기 토큰 → 한 벌."""
+    css = (ROOT / "ui_template" / "ui_template_theme.css").read_text("utf-8")
+    light = dict(re.findall(r"(--[\w-]+):\s*([^;]+);", _block(css, ":root")))
+    if dark:
+        light.update(re.findall(r"(--[\w-]+):\s*([^;]+);", _block(css, ':root[data-theme="dark"]')))
+    return light
+
+
+def _rgb(token: str, theme: dict) -> tuple:
+    """토큰 → (r, g, b) · var() 별칭 따라감 · 16진수만."""
+    val = theme[token].split("/*")[0].strip()
+    while m := re.fullmatch(r"var\((--[\w-]+)\)", val):
+        val = theme[m.group(1)].split("/*")[0].strip()
+    assert re.fullmatch(r"#[0-9a-fA-F]{6}", val), (token, val)
+    return tuple(int(val[i : i + 2], 16) for i in (1, 3, 5))
+
+
+def _mix(spec: str, theme: dict) -> tuple:
+    """`color-mix(in srgb, var(A) N%, var(B))` → 섞은 (r, g, b)."""
+    m = re.fullmatch(
+        r"color-mix\(in srgb,\s*var\((--[\w-]+)\)\s*(\d+)%,\s*var\((--[\w-]+)\)\)", spec
+    )
+    assert m, spec
+    a, n, b = _rgb(m.group(1), theme), int(m.group(2)) / 100, _rgb(m.group(3), theme)
+    return tuple(a[i] * n + b[i] * (1 - n) for i in range(3))
+
+
+def _lum(c: tuple) -> float:
+    ch = [
+        (v / 255) / 12.92 if v / 255 <= 0.03928 else (((v / 255) + 0.055) / 1.055) ** 2.4 for v in c
+    ]
+    return 0.2126 * ch[0] + 0.7152 * ch[1] + 0.0722 * ch[2]
+
+
+def _contrast(a: tuple, b: tuple) -> float:
+    hi, lo = sorted((_lum(a), _lum(b)), reverse=True)
+    return (hi + 0.05) / (lo + 0.05)
+
+
+def _tokens() -> tuple:
+    css = (ROOT / "ui_template" / "ui_template_group_cards.css").read_text("utf-8")
+    root = _block(css, ".ui-group-cards")
+    head = re.search(r"--group-head-bg:\s*([^;]+);", root)
+    foot = re.search(r"--group-foot-bg:\s*([^;]+);", root)
+    assert head and foot
+    return css, head.group(1), foot.group(1)
+
+
+def test_카드_제목_줄과_합계_줄_바탕색_토큰():
+    css, head, foot = _tokens()
+    assert head != foot
+    assert "background-color: var(--group-head-bg)" in _block(css, ".ui-group-card__head")
+    assert "background-color: var(--group-foot-bg)" in _block(css, ".ui-group-card__foot")
+    for spec in (head, foot):  # 고른 값 없이 테마 변수만(색 고정값 없음)
+        assert "#" not in spec and "rgb(" not in spec
+
+
+def test_밝음_어두움_두_색이_다르고_글_대비_유지():
+    _, head, foot = _tokens()
+    for dark in (False, True):
+        theme = _theme_vars(dark)
+        h, f = _mix(head, theme), _mix(foot, theme)
+        assert sum(abs(h[i] - f[i]) for i in range(3)) >= 40, (dark, h, f)  # 서로 다른 색
+        card = _rgb("--color-surface-raised", theme)
+        assert sum(abs(f[i] - card[i]) for i in range(3)) >= 40  # 카드 바탕과도 구분
+        for color in ("--color-text", "--color-text-secondary", "--color-accent"):
+            assert _contrast(_rgb(color, theme), h) >= 4.5, (dark, "head", color)
+        for color in ("--color-text", "--color-text-body", "--color-text-secondary"):
+            assert _contrast(_rgb(color, theme), f) >= 4.5, (dark, "foot", color)
+
+
+def test_어두움_테마_값():
+    # 어두움 테마에서 쓰는 토큰이 실제로 어두움 값으로 덮임(밝음 값 그대로가 아님)
+    light, dark = _theme_vars(False), _theme_vars(True)
+    for token in ("--color-surface", "--color-surface-raised", "--color-accent"):
+        assert _rgb(token, light) != _rgb(token, dark), token
diff --git a/resources/tester/test_200_2_b09_bill_level_bar.py b/resources/tester/test_200_2_b09_bill_level_bar.py
new file mode 100644
index 000000000..3a544d33c
--- /dev/null
+++ b/resources/tester/test_200_2_b09_bill_level_bar.py
@@ -0,0 +1,196 @@
+"""200-2 B09 설계내역서 레벨 글 · 레벨 도구 줄 — 글 칸 왼쪽 맞춤 · 레벨 = 공종 · 명칭 칸 padding 들여쓰기 ·
+글자 크기 한 벌 · 단추 넷(고른 줄 · 못 하면 disabled) · 키 셋(Tab · Shift+Tab · Alt+↑↓) · 편집 중엔 키 안 먹음.
+
+- 단추 · 키 = 우클릭 메뉴(billMenu) 같은 항목을 부름 — 줄 꼴 · 저장 꼴은 184-3 시험 그대로
+- 표 · 문서 = 가짜 DOM(줄 tr · 글 칸 input) · 다시 그림 = buildBill + levelBar 다시
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_184_3_b09_bill_menu import ROWS, _node, _ts  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[2]
+B09 = ROOT / "B09_Estimation"
+
+BAR_JS = """
+class FakeEl {
+  constructor(tag) {
+    this.tagName = tag.toUpperCase(); this.kids = []; this.dataset = {}; this.cls = new Set();
+    this.on = {}; this.parent = null; this.isConnected = true; this.disabled = false; this.textContent = "";
+  }
+  set className(v) { this.cls = new Set(v.split(" ").filter(Boolean)); }
+  get classList() { const s = this.cls; return { add: (c) => s.add(c), remove: (c) => s.delete(c) }; }
+  append(...kids) { for (const k of kids) { k.parent = this; this.kids.push(k); } }
+  addEventListener(type, f) { (this.on[type] ??= []).push(f); }
+  fire(type, ev) { for (const f of this.on[type] ?? []) f(ev); }
+  contains(x) { for (let n = x; n; n = n.parent) if (n === this) return true; return false; }
+  all() { return this.kids.flatMap((k) => [k, ...k.all()]); }
+  closest() { for (let n = this; n; n = n.parent) if (n.tagName === "TR") return n; return null; }
+  querySelectorAll() { return this.all().filter((n) => n.tagName === "TR" && n.cls.has("is-focus")); }
+  querySelector(sel) { const i = sel.match(/data-i="(-?\\d+)"/)[1]; return this.all().find((n) => n.dataset.i === i) ?? null; }
+  focus() { doc.activeElement = this; }
+  blur() { doc.activeElement = doc.body; }
+}
+const doc = new FakeEl("#document");
+doc.body = new FakeEl("body");
+doc.activeElement = doc.body;
+doc.createElement = (t) => new FakeEl(t);
+globalThis.document = doc;
+const hovers = [];
+function createButton(o) {
+  const b = new FakeEl("button");
+  b.label = o.label; b.variant = o.variant;
+  b.addEventListener("click", o.onClick);
+  return b;
+}
+function attachHoverInfo(el, text) { hovers.push([el.textContent, text]); }
+
+let user = {};
+let table, root, bar;
+const draw = () => {
+  table = buildBill({ sheets: { bill: { rows: __ROWS__, totals: null } }, payload: {},
+    get user() { return user; }, setUser: (u) => (user = u) });
+  if (root) root.isConnected = false;
+  if (root?.contains(doc.activeElement)) doc.activeElement = doc.body; // 지운 요소 초점 = body
+  root = new FakeEl("div");
+  table.rows.forEach((r, i) => {
+    const tr = new FakeEl("tr"); tr.dataset.i = String(i);
+    const td = new FakeEl("td"); const input = new FakeEl("input");
+    td.append(input); tr.append(td); root.append(tr);
+  });
+  bar = levelBar(root, table);
+};
+const at = (key) => table.rows.findIndex((r) => r.key === key);
+const tr = (key) => root.kids[at(key)];
+const pick = (key) => root.fire("click", { target: tr(key).kids[0] });
+const buttons = () => bar.kids.filter((k) => k.tagName === "BUTTON");
+const off = () => buttons().map((b) => b.disabled);
+const order = () => (user.bill?.rows ?? []).map((e) => [e.key, e.parent ?? null]);
+const key = (k, more = {}) => {
+  let stopped = false;
+  doc.fire("keydown", { key: k, shiftKey: false, altKey: false, ...more, preventDefault: () => (stopped = true) });
+  return stopped;
+};
+const out = {};
+draw();
+out.labels = buttons().map((b) => [b.label, b.dataset.b09Level, b.variant]);
+out.guide = bar.kids.at(-1).textContent;
+out.hover = hovers.length;
+out.none = off();
+pick("earth:4");
+out.earth4 = off();
+out.focus = [tr("earth:4").cls.has("is-focus"), pickedClass(table.rows[at("earth:4")]),
+  pickedClass(table.rows[at("earth:5")])];
+buttons()[3].fire("click");
+out.down = order();
+user = {}; draw();
+out.kept = [off(), tr("earth:4").cls.has("is-focus"), pickedClass(table.rows[at("earth:4")])];
+root.focus();
+out.tabStop = key("Tab");
+out.tabNoop = order();
+out.shiftTab = [key("Tab", { shiftKey: true }), order()];
+user = {}; draw();
+pick("earth:5");
+root.focus();
+out.altUp = [key("ArrowUp", { altKey: true }), order()];
+user = {}; draw(); pick("earth:4");
+out.altDown = [key("ArrowDown", { altKey: true }), order()];
+user = {}; draw(); pick("earth:4");
+doc.activeElement = tr("earth:4").kids[0].kids[0];
+out.editing = [key("Tab", { shiftKey: true }), key("ArrowDown", { altKey: true }), order()];
+out.esc = [key("Escape"), doc.activeElement === root];
+out.afterEsc = [key("Tab", { shiftKey: true }), order().length > 0];
+user = {}; draw(); pick("earth:4");
+doc.activeElement = new FakeEl("input");
+out.outside = [key("Tab", { shiftKey: true }), order()];
+root.focus();
+key("Escape");
+out.unpick = [off(), tr("earth:4").cls.has("is-focus"), key("Tab")];
+out.keyAct = [
+  keyAct({ key: "Tab", shiftKey: false, altKey: false }, false),
+  keyAct({ key: "Tab", shiftKey: true, altKey: false }, false),
+  keyAct({ key: "ArrowUp", shiftKey: false, altKey: true }, false),
+  keyAct({ key: "ArrowDown", shiftKey: false, altKey: true }, false),
+  keyAct({ key: "Tab", shiftKey: false, altKey: false }, true),
+  keyAct({ key: "ArrowUp", shiftKey: false, altKey: false }, false),
+  keyAct({ key: "Tab", shiftKey: false, altKey: false, ctrlKey: true }, false),
+];
+console.log(JSON.stringify(out));
+"""
+
+SRC = ["UI_Tabs", "UI_Tabs_Bill_Link", "UI_Tabs_Bill_Edit", "UI_Tabs_Bill", "UI_Tabs_Bill_Drag",
+       "UI_Tabs_Bill_Level"]  # fmt: skip
+IN, OUT, UP, DOWN = "들여쓰기 →", "내어쓰기 ←", "위로 ↑", "아래로 ↓"
+
+
+def _bar():
+    body = BAR_JS.replace("__ROWS__", json.dumps(ROWS, ensure_ascii=False))
+    return json.loads(_node(_ts(SRC) + body))
+
+
+def _keys(order):
+    return [k for k, _ in order]
+
+
+def test_단추_넷_고른_줄_못_하면_흐림():
+    out = _bar()
+    assert out["labels"] == [["→ 들여쓰기", IN, "ghost"], ["← 내어쓰기", OUT, "ghost"],
+                             ["↑ 위로", UP, "ghost"], ["↓ 아래로", DOWN, "ghost"]]  # fmt: skip
+    assert "Tab" in out["guide"] and "Shift+Tab" in out["guide"] and "Alt+↑↓" in out["guide"]
+    assert out["hover"] == 1  # 안내 한 줄 = 공용 호버로 자세히
+    assert out["none"] == [True] * 4  # 고른 줄 없음 = 모두 흐림
+    # earth:4 = 1.1 첫 줄 — 들여(위 형제 없음) · 위로 = 못 함 · 내어 · 아래로 = 됨(184-3 메뉴와 같음)
+    assert out["earth4"] == [True, False, True, False]
+    assert out["focus"] == [True, "is-focus", None]
+    # [↓ 아래로] = 메뉴 「아래로 ↓」 와 같은 결과
+    keys = _keys(out["down"])
+    assert keys.index("earth:5") + 1 == keys.index("earth:4")
+    # 다시 그려도 고른 줄 · 단추 상태 남음
+    assert out["kept"] == [[True, False, True, False], True, "is-focus"]
+
+
+def test_키_셋_편집_중엔_안_먹음():
+    out = _bar()
+    assert out["tabStop"] is True and out["tabNoop"] == []  # 못 하는 들여쓰기 = 바뀜 없음
+    stopped, order = out["shiftTab"]
+    assert stopped and ("earth:4", "sec:1") in [tuple(x) for x in order]  # 내어쓰기
+    for name in ("altUp", "altDown"):
+        stopped, order = out[name]
+        keys = _keys(order)
+        assert stopped and keys.index("earth:5") + 1 == keys.index("earth:4"), name
+    # 글 칸 편집 중 = 키 안 먹음(기본 동작 그대로) · Esc = 편집 끝(표에 초점) → 키 먹음
+    assert out["editing"] == [False, False, []]
+    assert out["esc"] == [False, True]
+    assert out["afterEsc"] == [True, True]
+    # 초점이 표 · 도구 줄 밖 = 안 먹음 · Esc(편집 아님) = 고름 풂 → 흐림 · Tab 은 기본 동작
+    assert out["outside"] == [False, []]
+    assert out["unpick"] == [[True] * 4, False, False]
+    # 그냥 ↑ = 옮기기(204 방향키 · test_204_1)
+    assert out["keyAct"] == [IN, OUT, UP, DOWN, None, UP, None]
+
+
+def test_왼쪽_맞춤_레벨_들여쓰기_글자_크기_한_벌():
+    css = (B09 / "B09_Estimation_UI_Page.css").read_text("utf-8")
+    bill = '.b09-estimation [data-b09-table="bill"]'
+    # 201-1 레벨 들여쓰기 = 공용 표 level 옵션(test_201_1) · 레벨별 글자 크기 규칙 없음(한 벌)
+    assert "is-lv" not in css and "font-size: 13px" not in css
+    src = (B09 / "B09_Estimation_UI_Tabs_Bill.ts").read_text("utf-8")
+    assert 'level: { key: "name", of: (i) => rows[i]?.level' in src
+    # 글 칸 왼쪽 맞춤(수량만 오른쪽)
+    assert re.search(
+        re.escape(f'{bill} .ui-data-table__input:not([data-k="qty"]) {{') + r"\s*text-align: left;",
+        css,
+    )
+    assert re.search(r"\.b09-estimation__level \{\s*display: flex;", css)
+
+
+def test_셸_배선():
+    src = (B09 / "B09_Estimation_UI_Shell.ts").read_text("utf-8")
+    assert "makeTable(bill ? (i) => pickedClass(bill.rows[i]) : undefined)" in src
+    assert "...(level ? [level] : []), table.root" in src
+    lvl = (B09 / "B09_Estimation_UI_Tabs_Bill_Level.ts").read_text("utf-8")
+    assert "table.menu(index)" in lvl  # 단추 · 키 = 우클릭 메뉴 같은 함수
diff --git a/resources/tester/test_201_1_table_level_merge.py b/resources/tester/test_201_1_table_level_merge.py
new file mode 100644
index 000000000..dbcf7093d
--- /dev/null
+++ b/resources/tester/test_201_1_table_level_merge.py
@@ -0,0 +1,135 @@
+"""201-1 공용 표 level(보기 전용) · mergeSame(같은 값 세로 병합) 옵션 + B08 · B09 적용 표.
+
+- level { key, of } = 그 열 칸 class ui-data-table__lv · 줄 style --dt-lv(레벨 − 1) · 글 상자 칸도 · 다루기 단추 없음
+- mergeSame [열] = 위아래 같은 글이 이어지면 rowspan · 앞 병합 열이 갈리면 갈림 · 빈 값 · 빈칸 글 · 고칠 칸 안 합침 ·
+  합계 줄 안 합침 · 그린 구간(win) 안에서만 · 병합 표 칸 = data-c(열 번호)
+- 옵션 없으면 무변(rowspan · data-c · --dt-lv 없음)
+"""
+
+import json
+import re
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+JS = r"""
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(process.argv[1], "config", "node_modules", "typescript"));
+const file = path.join(process.argv[1], "ui_template", "ui_template_data_table.ts");
+const js = ts.transpileModule(fs.readFileSync(file, "utf8"), {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+}).outputText;
+const box = { exports: {} };
+new Function("exports", "module", "require", js)(box.exports, box, (p) => (p.endsWith(".css") ? {} : require(p)));
+const m = box.exports;
+const body = (html) => html.split("<tbody>")[1].split("</tbody>")[0].split("</tr>").filter(Boolean);
+const columns = [
+  { key: "g", label: "구분" }, { key: "s", label: "규격" }, { key: "n", label: "명칭" },
+  { key: "v", label: "값", kind: "number" },
+];
+const rows = [
+  { g: "흙깍기", s: "가", n: "a", v: 1 },
+  { g: "흙깍기", s: "가", n: "b", v: 1 },
+  { g: "흙깍기", s: "나", n: "c", v: 1 },
+  { g: "운반", s: "나", n: "d", v: 2 },
+  { g: "운반", s: " ", n: "e", v: 2 },
+  { g: "", s: " ", n: "f", v: 2 },
+  { g: "", s: "다", n: "g", v: 3 },
+];
+const total = { g: "계", v: 12 };
+const out = {};
+out.plain = m.renderDataTableHtml({ columns, rows, total });
+const merged = { columns, rows, total, mergeSame: ["g", "s"] };
+out.merged = body(m.renderDataTableHtml(merged));
+out.mergedFoot = m.renderDataTableHtml(merged).split("<tfoot>")[1];
+out.spans = m.mergeSpans(merged, 0, rows.length);
+out.win = m.mergeSpans(merged, 1, 4);
+out.edit = m.mergeSpans({ ...merged, editable: (i, k) => i === 1 && k === "g" }, 0, 3);
+out.level = body(m.renderDataTableHtml({
+  columns, rows: rows.slice(0, 3), level: { key: "n", of: (i) => [1, 2, null][i] },
+  editable: (i, k) => i === 1 && k === "n",
+}));
+out.cell = [m.cellColumn({ dataset: { c: "3" }, cellIndex: 1 }), m.cellColumn({ dataset: {}, cellIndex: 1 })];
+console.log(JSON.stringify(out));
+"""
+
+
+def _run() -> dict:
+    result = subprocess.run(
+        ["node", "-e", JS, str(ROOT)], capture_output=True, text=True, encoding="utf-8", timeout=60
+    )
+    assert result.returncode == 0, result.stderr
+    return json.loads(result.stdout)
+
+
+def test_옵션_없으면_무변():
+    html = _run()["plain"]
+    assert "rowspan" not in html.split("<tbody>")[1]
+    assert "data-c=" not in html and "--dt-lv" not in html and "ui-data-table__lv" not in html
+
+
+def test_mergeSame_같은_값만_rowspan():
+    out = _run()
+    # 구분: 흙깍기 3 · 운반 2 · 빈 값 2(안 합침) / 규격: 가 2(흙깍기 안) · 나 = 구분이 갈려 따로 · 빈칸 글 안 합침
+    assert [s[0] for s in out["spans"]] == [3, 0, 0, 2, 0, 1, 1]
+    assert [s[1] for s in out["spans"]] == [2, 0, 1, 1, 1, 1, 1]
+    assert all(s[2] == 1 and s[3] == 1 for s in out["spans"])  # 지정 안 한 열 = 그대로
+    rows = out["merged"]
+    assert '<td rowspan="3" data-c="0">흙깍기</td>' in rows[0].replace(' class="is-merged"', "")
+    assert 'class="is-merged"' in rows[0]
+    assert (
+        rows[1].count("<td") == 2 and '<td data-c="2">b</td>' in rows[1]
+    )  # 합쳐진 칸 빠짐 · 열 번호
+    assert '<td data-num="" data-c="3">2</td>' in rows[4]  # 숫자 값 그대로
+    assert "rowspan" not in out["mergedFoot"]  # 합계 줄 안 합침
+    # 그린 구간(1~3줄) 안에서만 · 고칠 칸 안 합침
+    assert out["win"] == [[2, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]]
+    assert [s[0] for s in out["edit"]] == [1, 1, 1]
+    assert out["cell"] == [3, 1]
+
+
+def test_level_보기_전용_들여쓰기():
+    rows = _run()["level"]
+    assert [re.search(r'style="--dt-lv:(\d)"', r).group(1) for r in rows] == ["0", "1", "0"]
+    assert '<td class="ui-data-table__lv">a</td>' in rows[0]
+    assert rows[0].count("ui-data-table__lv") == 1  # 지정 열만
+    assert '<td class="is-edit ui-data-table__lv" data-num="">' in rows[1]  # 글 상자 칸도
+    assert "button" not in "".join(rows)  # 다루기 단추 없음(설계내역서만)
+    css = (ROOT / "ui_template" / "ui_template_data_table.css").read_text("utf-8")
+    pad = r"padding-left: calc\(var\(--spacing-8\) \+ var\(--dt-lv, 0\) \* 1em\);"
+    assert re.search(r"td\.ui-data-table__lv \{\s*" + pad + r"\s*text-align: left;", css)
+    assert re.search(r"td\.ui-data-table__lv \.ui-data-table__input \{\s*" + pad, css)
+    assert re.search(r"td\.is-merged \{\s*vertical-align: top;", css)
+
+
+#: 적용 표 — [파일, 들어 있어야 할 글]
+APPLIED = [
+    ("B08_Quantity/B08_Quantity_UI_Earthwork_Sheets.ts", 'mergeSame: ["group", "spec"]'),
+    ("B08_Quantity/B08_Quantity_UI_Material.ts", 'mergeSame: ["name"]'),
+    ("B08_Quantity/B08_Quantity_UI_Material.ts", 'mergeSame: ["group"]'),
+    ("B08_Quantity/B08_Quantity_UI_Material.ts", "mergeSame: built.mergeSame"),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Base.ts", 'mergeSame: ["part"]'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Base.ts", 'level: blockLevel("name"'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts", 'level: blockLevel("name"'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts", 'level: blockLevel("text"'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Sangeun.ts", 'mergeSame: ["kind"]'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Total.ts", 'mergeSame: ["group", "part"]'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Total.ts", 'mergeSame: ["part"]'),
+    ("B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts", 'level: { key: "name"'),
+    ("B09_Estimation/B09_Estimation_UI_Shell.ts", "mergeSame: spec.mergeSame"),
+]
+
+
+def test_B08_B09_적용():
+    for path, text in APPLIED:
+        assert text in (ROOT / path).read_text("utf-8"), (path, text)
+    # 옛 글 빈칸 지우기 · 앞 빈칸 들여쓰기는 없앰(병합 · level 로 갈음)
+    mat = (ROOT / "B08_Quantity/B08_Quantity_UI_Material.ts").read_text("utf-8")
+    assert '=== row.name ? ""' not in mat and '=== row.group ? ""' not in mat
+    labor = (ROOT / "B09_Estimation/B09_Estimation_UI_Tabs_Labor.ts").read_text("utf-8")
+    assert 'const CHILD = "ㄴ "' in labor and '"  합  계"' not in labor
+    # 셸 칸 → 열 = cellColumn(병합 표에서 cellIndex 가 밀림)
+    shell = (ROOT / "B09_Estimation/B09_Estimation_UI_Shell.ts").read_text("utf-8")
+    assert ".cellIndex" not in shell and shell.count("cellColumn(") == 2
diff --git a/resources/tester/test_202_1_table_hint_bottom.py b/resources/tester/test_202_1_table_hint_bottom.py
new file mode 100644
index 000000000..a4db1829a
--- /dev/null
+++ b/resources/tester/test_202_1_table_hint_bottom.py
@@ -0,0 +1,175 @@
+"""202-1 B08 · B09 표 칸 — 안내 · 경고 줄 = 맨 아래 · 박스보기 · 가로 열 수 = 보조 탭 줄 오른쪽.
+
+- B09 안내 줄 = 표 · 카드 판 아래(마지막 자식) · 묶음 탭 도구(보기 단추 · 열 수) = 아래 탭 줄 오른쪽 · 단독 탭 빈 줄에서도
+- B08 안내 · 경고 줄 = 표 · 아래 줄 뒤 맨 아래(토공 · 운반 시트 · 자재 · 구조물 집계)
+- 창 끝까지 셈(199-1) = 아래로 간 안내 줄 몫 포함
+"""
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from resources.tester.helper_b09_group_cards import COMMON, GROUPS, RAW, TABS, run  # noqa: E402
+
+B09 = "B09_Estimation/B09_Estimation_UI_"
+BAR = f"{B09}TabBar.ts"
+DG = {"id": "DG1", "no": 1, "name": "찰쌓기", "unit": "m2", "lines": [], "sum": 0}
+
+
+def _block(css: str, selector: str) -> str:
+    m = re.search(re.escape(selector) + r"\s*\{([^}]*)\}", css)
+    assert m, selector
+    return m.group(1)
+
+
+# ── B09 보조 탭 줄 오른쪽 도구 ──────────────────────────────────────────────
+
+
+def test_도구_자리_보조_줄_오른쪽_빈_줄에서도_보임():
+    out = run(
+        [TABS, BAR],
+        """
+const bars = createTabBars(() => {});
+const mk = (n) => { const b = document.createElement('button'); b.textContent = n; return b; };
+const snap = () => ({
+  kids: bars.sub.children.map((c) => (c.classList.contains('b09-estimation__tools') ? 'TOOLS' : c.textContent)),
+  last: bars.sub.children[bars.sub.children.length - 1].children.map((x) => x.textContent),
+});
+bars.draw('dg');
+bars.setTools([mk('가'), mk('나')]);
+const a = snap();
+bars.draw('compare');                     // 다른 묶음으로 옮겨도 도구 자리는 그대로 마지막
+const b = snap();
+bars.draw('cost');                        // 단독 탭 = 빈 보조 줄
+const c = snap();
+const ghost = bars.sub.children[0];
+bars.setTools([]);
+const d = snap();
+console.log(JSON.stringify({
+  a: a.kids, aLast: a.last,
+  b: b.kids.slice(-1), bLast: b.last,
+  c: c.kids, cLast: c.last,
+  blank: bars.sub.classList.contains('b09-estimation__tabs--blank'),
+  subHidden: bars.sub.attrs['aria-hidden'] ?? null, ghostHidden: ghost.attrs['aria-hidden'],
+  dLast: d.last.length,
+}));
+""",
+    )
+    tools = "TOOLS"
+    assert out["a"] == ["일위대가목록표", "일위대가표", tools]  # 아래 탭 뒤 오른쪽 자리
+    assert out["aLast"] == ["가", "나"]
+    assert out["b"] == [tools] and out["bLast"] == ["가", "나"]  # 탭을 옮겨도 도구는 그대로
+    assert out["blank"] and len(out["c"]) == 2 and out["c"][1] == tools  # 숨은 단추 + 도구
+    assert out["cLast"] == ["가", "나"]
+    assert out["subHidden"] is None and out["ghostHidden"] == "true"  # 줄 전체가 아니라 숨은 단추만
+    assert out["dLast"] == 0  # 비움
+
+
+def test_묶음_탭_단추가_보조_줄에_안내는_아래에():
+    """쉘이 하는 대로 — 줄 그림 → 묶음 판 그림(`setTools` = 보조 줄 도구) → 단추는 줄에, 판에는 없음."""
+    out = run(
+        [COMMON, TABS, f"{B09}Tabs_Labor.ts", GROUPS, BAR],
+        f"\nconst spec = buildDaegaBlocks({{ sheets: {{ daega_blocks: [{json.dumps(DG, ensure_ascii=False)}] }} }});"
+        "\nconst bars = createTabBars(() => {});"
+        "\nconst hint = document.createElement('p');"
+        "\nconst res = {};"
+        "\nfor (const view of ['cards', 'table']) {"
+        "\n  chosen.set('dg', view);"
+        "\n  bars.draw('dg'); bars.setTools([]);"
+        "\n  const panel = renderGroupPanel({ tab: 'dg', spec, hint, goto: () => {}, redraw: () => {},"
+        " makeTable: () => ({ root: document.createElement('table'), focusRow: () => {} }),"
+        " setTools: bars.setTools });"
+        "\n  const tools = bars.sub.children[bars.sub.children.length - 1];"
+        "\n  res[view] = { inRow: tools.all('[data-b09-group-view]').map((b) => b.textContent),"
+        " cols: tools.all('[data-group-cols]').length,"
+        " inPanel: panel.flatMap((e) => [e, ...e.all('[data-b09-group-view]'), ...e.all('[data-group-cols]')])"
+        ".filter((e) => e.dataset.b09GroupView || e.dataset.groupCols).length,"
+        " hintLast: panel[panel.length - 1] === hint, n: panel.length };"
+        "\n}"
+        "\nconsole.log(JSON.stringify(res));",
+        RAW,
+    )
+    assert out["cards"]["inRow"] == ["표로 보기"] and out["cards"]["cols"] == 4
+    assert out["table"]["inRow"] == ["박스보기"] and out["table"]["cols"] == 0
+    for view in ("cards", "table"):
+        assert out[view]["inPanel"] == 0  # 판 안에는 단추 없음
+        assert out[view]["hintLast"] and out[view]["n"] == 2  # 판 + 안내 줄(맨 아래)
+
+
+def test_잇기_쉘_안내_줄_아래_도구_비움():
+    shell = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Shell.ts").read_text("utf-8")
+    assert (
+        "panel.replaceChildren(...(level ? [level] : []), table.root, ...(hint ? [hint] : []))"
+        in shell
+    )  # 200-2 레벨 줄 · 203-1 연결 점검 탭 없앰과 합침
+    assert "...(hint ? [hint] : []), table.root" not in shell  # 위 자리 없음
+    assert re.search(r"bars\.draw\(tab\);\s*bars\.setTools\(\[\]\);", shell)
+    assert "setTools: bars.setTools" in shell
+
+
+def test_CSS_도구_오른쪽_맞춤_빈_줄_숨김_규칙에_안_걸림():
+    css = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Page.css").read_text("utf-8")
+    tools = _block(css, ".b09-estimation__tools")
+    assert "margin-left: auto" in tools and "flex-wrap: nowrap" in tools
+    hidden = _block(css, ".b09-estimation__tabs--blank > .ui-btn")
+    assert "visibility: hidden" in hidden  # 직계 단추만 — 도구 묶음은 안 숨김
+    assert ".b09-estimation__bar" not in css  # 옛 머리 줄(안내 + 단추) 풂
+
+
+# ── B08 안내 · 경고 줄 맨 아래 ──────────────────────────────────────────────
+
+
+def test_B08_표_카드_차례_표_아래줄_안내():
+    src = (ROOT / "B08_Quantity" / "B08_Quantity_UI_Earthwork.ts").read_text("utf-8")
+    fn = re.search(r"export function tableCard\(.*?\n}\n", src, re.S)
+    assert fn
+    code = fn.group(0).replace("export ", "")
+    js = (
+        "const createCard = ({ body }) => body;\n"
+        + code
+        + "\nconsole.log(JSON.stringify(tableCard(['i1', 'i2'], 'T', ['a1', 'a2'])));"
+    )
+    result = subprocess.run(
+        ["node", "--experimental-strip-types", "--no-warnings", "--input-type=module-typescript"],
+        input=js,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert result.returncode == 0, result.stderr
+    assert json.loads(result.stdout) == ["T", "a1", "a2", "i1", "i2"]  # 표 · 아래 줄 · 안내 줄
+
+
+def test_B08_자재_구조물_안내_줄_표_아래():
+    material = (ROOT / "B08_Quantity" / "B08_Quantity_UI_Material.ts").read_text("utf-8")
+    assert "createCard({ body: [toolbar, table.root, excel, notes] })" in material
+    assert "toolbar.append(save);" in material  # 저장 단추만 위 줄(안내는 아래)
+    summary = (ROOT / "B08_Quantity" / "B08_Quantity_UI_Summary.ts").read_text("utf-8")
+    assert "createCard({ body: [table, ...parts] })" in summary
+    css = (ROOT / "B08_Quantity" / "B08_Quantity_UI_Page.css").read_text("utf-8")
+    assert "justify-content: flex-end" in _block(css, ".b08-material__toolbar")
+
+
+# ── 창 끝까지 셈(199-1)에 아래 줄 몫 ────────────────────────────────────────
+
+
+def test_창_끝까지_셈에_아래_안내_줄_포함():
+    proc = subprocess.run(
+        ["node", str(ROOT / "resources" / "tester" / "helper_202_1_fill_below.cjs")],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    r = json.loads(proc.stdout)
+    assert r["below"] == r["belowExpected"] == 134  # 아래 줄 · 안내 줄 둘 + 여백
+    assert r["bottom"] == r["viewport"]  # 문서 맨 아래 = 창 끝 → 페이지 스크롤 0
+    assert r["afterHintGrow"] == r["firstMinusGrow"]  # 안내 줄이 늘면 표 칸이 그만큼 줄어듦
diff --git a/resources/tester/test_203_1_b09_data_check.py b/resources/tester/test_203_1_b09_data_check.py
new file mode 100644
index 000000000..2beecbcb5
--- /dev/null
+++ b/resources/tester/test_203_1_b09_data_check.py
@@ -0,0 +1,112 @@
+"""203-1 B09 좌측 「데이터 점검」 묶음(사용자 60번).
+
+- 묶음 이름 = 데이터 점검 · 안 설명 글 없음(굳힌 시각 · 까닭 = [업데이트] 공용 호버)
+- [단가 갱신] → [업데이트] · 낡으면(서버 `book_stale` = 지금 M01 로 굳힌 책과 다름) 점 배지(is-pending)
+- 「연결 점검」 탭 내용 = 묶음 안 목록(누르면 그 탭 그 줄) · 위 탭 줄에서 뺌 · 첫 탭 = 공사원가계산서
+"""
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from B09_Estimation import B09_Estimation_Prices as prices  # noqa: E402
+from resources.tester.helper_b09_group_cards import TABS, run  # noqa: E402
+
+CHECK = "B09_Estimation/B09_Estimation_UI_Check.ts"
+SHELL = (ROOT / "B09_Estimation/B09_Estimation_UI_Shell.ts").read_text("utf-8")
+
+
+def test_묶음_이름_단추_글_설명_없음():
+    assert 'heading.textContent = "데이터 점검";' in SHELL and "원가 단가" not in SHELL
+    assert 'label: "업데이트",' in SHELL and "단가 갱신" not in SHELL
+    # 옛 굳힌 시각 안내 글(made) 없음 · 묶음 = 제목 · [업데이트] · 연결 점검
+    assert "made.textContent" not in SHELL and "b09-estimation__hint" not in SHELL
+    assert "section.append(heading, refresh, check.list);" in SHELL
+    assert "check.draw(payload, sheets);" in SHELL
+
+
+def test_연결_점검_탭_없음_첫_탭_공사원가계산서():
+    out = run(
+        [TABS],
+        "\nconsole.log(JSON.stringify({ ids: TABS.map(([t]) => t), names: TABS.map(([, n]) => n),"
+        " groups: TAB_GROUPS.map(([n]) => n), first: TABS[0][0] }));",
+    )
+    assert "check" not in out["ids"] and "연결 점검" not in out["names"] + out["groups"]
+    assert out["first"] == "cost" and out["groups"][0] == "공사원가계산서"
+    assert "let current: TabId = TABS[0][0];" in SHELL
+    assert "buildCheck" not in SHELL and "check:" not in SHELL
+
+
+def test_좌측_목록_이동_호버_배지():
+    out = run(
+        [TABS, CHECK],
+        """
+const moves = [];
+const refresh = document.createElement("button");
+const panel = createCheckPanel(refresh, (link) => moves.push(link));
+const sheets = { gaps: [
+  { tab: "dg", key: "DG1", name: "찰쌓기", why: "대가 원천 없음" },
+  { tab: "material", key: "MT9", name: "모래", why: "단가 없음" },
+] };
+const payload = { book: { made: "2026-10-01T09:00:00" }, stale: "M01 에서 바뀐 단가 2",
+  notes: ["B08 자재 집계표 못 읽음"], inputs: { missing: ["EQ1", "LB2"] } };
+panel.draw(payload, sheets);
+const view = () => ({
+  pending: refresh.classList.contains("is-pending"),
+  texts: panel.list.children.map((c) => c.text),
+  rows: (panel.list.children[1]?.children ?? []).map((r) => [r.dataset.i, r.className, r.text]),
+});
+const a = view();
+const rowsBox = panel.list.children[1];
+rowsBox.children[1].click();
+const tipRefresh = hoverCalls.find((h) => h.root === refresh).text();
+const rowHover = hoverCalls.find((h) => h.root === panel.list);
+const tipRow = rowHover.text(rowsBox.children[0]);
+panel.draw({ book: null, stale: null }, { gaps: [] });
+const b = view();
+const tipEmpty = refreshTip({ book: null, stale: "단가 아직 안 굳힘" });
+console.log(JSON.stringify({ a, b, moves, tipRefresh, tipRow, selector: rowHover.selector, tipEmpty }));
+""",
+    )
+    a, b = out["a"], out["b"]
+    assert a["pending"] and not b["pending"]
+    assert a["texts"][0] == "연결 없음 2곳"
+    assert a["rows"] == [
+        ["0", "ui-sidebar-row", "찰쌓기일위대가표"],
+        ["1", "ui-sidebar-row", "모래재료비목록표"],
+    ]
+    assert a["texts"][2:] == ["B08 자재 집계표 못 읽음", "M01 에 없는 키 2 — EQ1 · LB2"]
+    assert out["moves"] == [{"tab": "material", "key": "MT9"}]
+    assert out["tipRow"] == "대가 원천 없음" and out["selector"] == "[data-i]"
+    assert "단가 굳힘 2026-10-01 09:00:00" in out["tipRefresh"]
+    assert "업데이트 필요 — M01 에서 바뀐 단가 2" in out["tipRefresh"]
+    assert b["texts"] == ["연결 없음 0곳"] and b["rows"] == []
+    assert out["tipEmpty"].startswith("단가 아직 안 굳힘") and "업데이트 필요" in out["tipEmpty"]
+
+
+def test_배지_조건_서버_book_stale():
+    keys = ["EQ000004"]  # 불도저 · 조종원 · 경유(test_144 와 같은 견본)
+    book = json.loads(json.dumps(prices.refresh_book(keys), ensure_ascii=False))
+    assert prices.book_stale(book, keys) is None  # 방금 굳힌 책 = 업데이트 필요 없음
+    assert prices.book_stale(None, keys) == "단가 아직 안 굳힘"
+    first, *rest = list(book["rows"])
+    old = {**book, "rows": {k: book["rows"][k] for k in rest}, "fx": []}
+    old["rows"][rest[0]] = {**old["rows"][rest[0]], "price": -1}
+    old["driver_factor"] = {"num": 1, "den": 1, "text": "1/1"}
+    assert prices.book_stale(old, keys) == (
+        "새 단가 줄 1 · M01 에서 바뀐 단가 1 · 운전사 계수 바뀜 · 환율 바뀜"
+    )
+    router = (ROOT / "B09_Estimation/B09_Estimation_Router.py").read_text("utf-8")
+    assert '"stale": await asyncio.to_thread(prices.book_stale, book, keys),' in router
+
+
+def test_배지_꼴_경고_색_토큰():
+    css = (ROOT / "B09_Estimation/B09_Estimation_UI_Page.css").read_text("utf-8")
+    block = css[css.index(".b09-options .ui-btn.is-pending::after") :]
+    block = block[: block.index("}")]
+    assert "position: absolute" in block and "border-radius: 50%" in block
+    assert "background: var(--color-warning)" in block
diff --git a/resources/tester/test_204_1_b09_bill_drag.py b/resources/tester/test_204_1_b09_bill_drag.py
new file mode 100644
index 000000000..20367728b
--- /dev/null
+++ b/resources/tester/test_204_1_b09_bill_drag.py
@@ -0,0 +1,242 @@
+"""204-1 B09 설계내역서 — 방향키 · 끌기 레벨 · 이동 · 자손 함께 · 묶음 자동 · 합 전달.
+
+- 방향키 = 고른 줄(편집 중 아님) → 들여 · ← 내어 · ↑↓ 옮김(200-2 메뉴 항목 그대로) · Alt+←→ 안 받음
+- 끌기 자리 = `dropAt`(틈 · 바라는 레벨 → 부모 · 앞 줄) ·
+  놓기 = 표 drop(`dropMove` · 메뉴와 같은 지킬 것)
+- 묶음 자동 = 셈(짝 `Calc_Bill` · 거울) — 자식이 생긴 항목 = 묶음(자손 합 · 위로 전달) ·
+  자식이 빠지면 다시 항목(제 수량 · 단가) · 자식이 다 빠진 새 묶음 = 항목(화면 · 맨 위 공종 빼고)
+"""
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_184_2_b09_bill_free import (  # noqa: E402
+    BASE,
+    BOOKS,
+    DG,
+    INPUTS,
+    _calc,
+    _freeze,
+    _put,
+    _rows,
+)
+from test_184_2_b09_bill_free import _node as _node_calc  # noqa: E402
+from test_184_3_b09_bill_menu import ROWS, _node, _row, _ts  # noqa: E402
+from test_200_2_b09_bill_level_bar import BAR_JS  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from B09_Estimation import B09_Estimation_Store as store  # noqa: E402
+from B09_Estimation.B09_Estimation_Calc_Bill import compute_estimation  # noqa: E402
+
+SRC = ["UI_Tabs", "UI_Tabs_Bill_Link", "UI_Tabs_Bill_Edit", "UI_Tabs_Bill", "UI_Tabs_Bill_Drag",
+       "UI_Tabs_Bill_Level"]  # fmt: skip
+
+
+def _order(bill):
+    return [(e["key"], e.get("parent"), e.get("kind")) for e in (bill or {}).get("rows", [])]
+
+
+# --- 방향키 -----------------------------------------------------------------------------
+
+KEYS_JS = """
+const out = {};
+const press = (pickKey, k, more = {}) => {
+  user = {}; draw(); pick(pickKey); root.focus();
+  return [key(k, more), order()];
+};
+out.right = press("earth:5", "ArrowRight");
+out.left = press("earth:4", "ArrowLeft");
+out.up = press("earth:5", "ArrowUp");
+out.down = press("earth:4", "ArrowDown");
+out.altLeft = press("earth:4", "ArrowLeft", { altKey: true });
+user = {}; draw(); pick("earth:5");
+doc.activeElement = tr("earth:5").kids[0].kids[0];
+out.editing = [key("ArrowRight"), key("ArrowUp"), order()];
+out.guide = bar.kids.at(-1).textContent;
+console.log(JSON.stringify(out));
+"""
+
+
+def test_방향키_넷_편집_중엔_안_먹음():
+    head = BAR_JS[: BAR_JS.index("const out = {};")]
+    body = head.replace("__ROWS__", json.dumps(ROWS, ensure_ascii=False)) + KEYS_JS
+    out = json.loads(_node(_ts(SRC) + body))
+    stopped, order = out["right"]  # → = 위 항목 아래로(earth:4 = 저절로 묶음)
+    assert stopped and ["earth:5", "earth:4"] in order
+    stopped, order = out["left"]  # ← = 1.1 밖으로(1 아래)
+    assert stopped and ["earth:4", "sec:1"] in order
+    for name in ("up", "down"):  # ↑↓ = 같은 부모 안 자리 바꿈
+        stopped, order = out[name]
+        keys = [k for k, _ in order]
+        assert stopped and keys.index("earth:5") + 1 == keys.index("earth:4"), name
+    assert out["altLeft"] == [False, []]  # Alt+← = 브라우저 뒤로 — 안 받음
+    assert out["editing"] == [False, False, []]  # 글 칸 편집 중 = 글 칸 커서
+    assert "←→" in out["guide"] and "↑↓" in out["guide"] and "끌기" in out["guide"]
+
+
+# --- 끌기 자리 · 놓기 ------------------------------------------------------------------------
+
+DROP_JS = """
+const start = __USER__;
+let user = start;
+const ctx = { sheets: { bill: { rows: __ROWS__, totals: null } }, payload: {},
+  get user() { return user; }, setUser: (u) => (user = u) };
+const table = buildBill(ctx);
+const at = (k) => table.rows.findIndex((r) => r.key === k);
+const order = (b) => (b?.rows ?? []).map((e) => [e.key, e.parent ?? null, e.kind ?? null]);
+const out = { at: {}, drop: {} };
+for (const [name, k, gap, want] of __ATS__) out.at[name] = dropAt(table.rows, at(k), gap, want);
+for (const [name, k, parent, before] of __DROPS__) {
+  user = start;
+  const run = table.drop(at(k), parent, before);
+  if (run) run();
+  out.drop[name] = run ? order(user.bill) : null;
+}
+console.log(JSON.stringify(out));
+"""
+
+#: ROWS + 맨 위 새 공종(hand:n · 자식 hand:k) — 4 자재대 뒤
+ROWS2 = [*ROWS[:9], _row("hand:n", None, 1, "group", no="5"), _row("hand:k", "hand:n", 2),
+         *ROWS[9:]]  # fmt: skip
+
+
+def _drag(ats=(), drops=(), rows=ROWS2, user=None):
+    body = (
+        DROP_JS.replace("__ROWS__", json.dumps(rows, ensure_ascii=False))
+        .replace("__USER__", json.dumps(user or {}, ensure_ascii=False))
+        .replace("__ATS__", json.dumps([list(a) for a in ats], ensure_ascii=False))
+        .replace("__DROPS__", json.dumps([list(d) for d in drops], ensure_ascii=False))
+    )
+    return json.loads(_node(_ts(SRC) + body))
+
+
+def test_끌기_자리_레벨():
+    # 차례 0 sec:1 · 1 sec:1.2 · 2 earth:4 · 3 earth:5 · 4 hand:g · 5 hand:a · 6 hand:b · 7 sec:4 ·
+    #      8 mat:M1 · 9 hand:n · 10 hand:k · 11 sec:G · 12 mat:M2 · 13 fee
+    out = _drag(
+        ats=[
+            ("오른쪽", "earth:5", 3, 4),  # 제자리 + 한 칸 오른쪽 = 위 항목 아래로
+            ("제자리", "earth:5", 3, 3),
+            ("제자리끝", "earth:5", 4, 3),
+            ("자손안", "hand:g", 5, 3),
+            ("위로", "hand:g", 2, 3),
+            ("멀리오른쪽", "hand:g", 2, 9),  # 레벨 = 위 줄 + 1 까지
+            ("자재아래", "earth:5", 9, 3),  # 자재 줄 = 자식 못 둠 → 형제로
+            ("맨위안됨", "earth:5", 7, 1),  # 항목 = 맨 위(1) 못 감 → 2
+            ("맨위공종", "sec:4", 0, 1),
+        ]
+    )["at"]
+    assert out["오른쪽"] == {"parent": "earth:4", "before": None, "level": 4}
+    assert out["제자리"] is None and out["제자리끝"] is None and out["자손안"] is None
+    assert out["위로"] == {"parent": "sec:1.2", "before": "earth:4", "level": 3}
+    assert out["멀리오른쪽"] == out["위로"]
+    assert out["자재아래"] == {"parent": "sec:4", "before": None, "level": 2}
+    assert out["맨위안됨"] == {"parent": "sec:1", "before": None, "level": 2}
+    assert out["맨위공종"] == {"parent": None, "before": "sec:1", "level": 1}
+
+
+def test_놓기_자손_함께_묶음_자동_막음():
+    out = _drag(
+        drops=[
+            ("자손", "hand:g", "sec:1.2", "earth:4"),
+            ("항목아래", "earth:5", "earth:4", None),
+            ("하나빠짐", "hand:a", "sec:1.2", "hand:b"),
+            ("맨위남음", "hand:k", "sec:4", None),
+            ("관급밖", "mat:M2", "sec:1", None),
+            ("수수료", "fee", "sec:1", None),
+            ("관급제목", "sec:G", None, "sec:1"),
+            ("자재아래", "earth:5", "mat:M1", None),
+            ("자기자손", "hand:g", "hand:a", None),
+        ]
+    )["drop"]
+    keys = [k for k, *_ in out["자손"]]
+    # 묶음 통째 — 자식 hand:a 는 부모 키 그대로 · 차례 = hand:g 바로 뒤
+    assert keys[keys.index("hand:g") + 1] == "hand:a" and keys.index("hand:g") < keys.index(
+        "earth:4"
+    )
+    assert ["hand:a", "hand:g", None] in out["자손"]
+    assert ["earth:5", "earth:4", None] in out["항목아래"]  # 저장 = 부모만(묶음 = 셈이 정함)
+    # 자식이 다 빠진 새 묶음 = 항목(kind 지움) · 맨 위 공종 = 묶음 그대로
+    assert ["hand:g", "sec:1.2", None] in out["하나빠짐"]
+    assert ["hand:n", None, "group"] in out["맨위남음"]
+    for name in ("관급밖", "수수료", "관급제목", "자재아래", "자기자손"):
+        assert out[name] is None, name
+
+
+def test_깊이_5_넘는_놓기_막음():
+    deep = [
+        _row("sec:1", None, 1, "title"), _row("sec:1.2", "sec:1", 2, "title"),
+        _row("hand:g", "sec:1.2", 3, "group"), _row("hand:g2", "hand:g", 4, "group"),
+        _row("hand:g3", "hand:g2", 5, "group"), _row("hand:z", "hand:g2", 5),
+        _row("hand:y", "sec:1.2", 3),
+    ]  # fmt: skip
+    out = _drag(drops=[("깊음", "hand:g", "hand:y", None), ("됨", "hand:z", "hand:y", None)],
+                rows=deep)["drop"]  # fmt: skip
+    assert out["깊음"] is None
+    assert ["hand:z", "hand:y", None] in out["됨"]
+
+
+# --- 셈 — 묶음 ↔ 항목 자동 · 합 전달 · 거울 -----------------------------------------------------
+
+HANDS = [
+    {"key": "hand:a", "parent": "sec:3", "name": "a", "unit": "㎡", "qty": 2, "ref": DG},
+    {"key": "hand:c", "parent": "hand:a", "name": "c", "unit": "㎡", "qty": 1, "ref": DG},
+]
+
+
+def _bills():
+    frozen = _freeze(_calc())
+    under = _put(frozen, "earth:1", parent="earth:4")  # 1.1 규준틀 → 절토(토사) 아래
+    hands = {**frozen, "rows": frozen["rows"] + HANDS}
+    alone = {**frozen, "rows": frozen["rows"] + HANDS[:1]}
+    mat = _put(frozen, "earth:5", parent="mat:b08:sand")
+    return frozen, under, hands, alone, mat
+
+
+def test_자식_생긴_항목_묶음_합_전달_빠지면_다시_항목():
+    plain = _calc()
+    frozen, under, hands, alone, mat = _bills()
+    base = _rows(plain)
+    rows = _rows(_calc(under))
+    e1, e4 = rows["earth:1"], rows["earth:4"]
+    assert (e4["kind"], e4["auto"], e4["qty"], e4["ref"], e4["price_sum"]) == (
+        "group", True, None, None, None)  # fmt: skip
+    assert (e1["parent"], e1["level"], e4["level"]) == ("earth:4", 4, 3)
+    # 묶음 금액 = 자손 합 → 1.2 · 1 로 전달 · 제 금액은 빠짐
+    assert e4["sum"] == e1["sum"] == base["earth:1"]["sum"]
+    assert rows["sec:1.2"]["sum"] == e1["sum"] and rows["sec:1.1"]["sum"] == 0
+    assert rows["sec:1"]["sum"] == base["sec:1"]["sum"] - base["earth:4"]["sum"]
+    gaps = _calc(under)["bill"]["gaps"]
+    assert not [g for g in gaps if "earth:4" in json.dumps(g, ensure_ascii=False)]
+    # 자식이 빠지면(원래 부모로) = 다시 항목 · 제 수량 · 단가 · 표 그대로
+    assert _calc(_put(under, "earth:1", parent="sec:1.1"))["bill"] == plain["bill"]
+    # 새 항목(수량 2 · 대가3) — 자식이 생기면 묶음(자식 합) · 빠지면 제 값 다시
+    rows = _rows(_calc(hands))
+    assert (rows["hand:a"]["kind"], rows["hand:a"]["sum"], rows["hand:c"]["level"]) == (
+        "group", 1230, 3)  # fmt: skip
+    a = _rows(_calc(alone))["hand:a"]
+    assert (a["kind"], a["qty"], a["sum"]) == ("item", 2, 2460)
+    # 저장 다듬기 = 자식 있는 새 항목도 제 수량 · 연결 지킴(묶음은 셈이 정함)
+    kept = {r["key"]: r for r in store.clean_bill(hands)["rows"]}["hand:a"]
+    assert (kept.get("kind"), kept["qty"], kept["ref"]) == (None, 2, DG)
+    # 자재 줄 = 부모 못 됨 → 기본 부모
+    rows = _rows(_calc(mat))
+    assert rows["earth:5"]["parent"] == "sec:1.2" and rows["mat:b08:sand"]["kind"] == "item"
+
+
+def test_거울_TS_가_같은_값():
+    calc = _ts(["Calc_Base", "Calc_Bill"])
+    users = [{**BASE, "bill": b} for b in _bills()]
+    body = (
+        f"\nconst i = {json.dumps(INPUTS, ensure_ascii=False)};"
+        f"\nconst us = {json.dumps(users, ensure_ascii=False)};"
+        f"\nconst b = {json.dumps(BOOKS, ensure_ascii=False)};"
+        "\nconsole.log(JSON.stringify(us.map((u) => computeEstimation(i, u, null, b))));"
+    )
+    got = json.loads(_node_calc(calc + body))
+    assert got == [compute_estimation(INPUTS, u, None, BOOKS) for u in users]
diff --git a/resources/tester/test_204_2_b09_bill_library.py b/resources/tester/test_204_2_b09_bill_library.py
new file mode 100644
index 000000000..c89d23564
--- /dev/null
+++ b/resources/tester/test_204_2_b09_bill_library.py
@@ -0,0 +1,244 @@
+"""204-2 B09 설계내역서 연결 고르기 — 프로젝트 호표 + 서고(마스터 · 회사 · 개인)
+구조물조합 · 사전조합.
+
+- 서고 고름 = 프로젝트 사본 들여옴(`B09_Estimation/v1/library/{폴더}`) + 새 대가 호표(`libs`) +
+  줄 연결 `{tab: dg, key: 블록 id, lib: 폴더}` · 다시 고르면 같은 사본(만듦 거짓 · 같은 호표)
+- 사본 단가 묶음(로직 · 사전조합 자재 · 고른 자재) · 원본을 지워도 그대로 · 단가 수요 키에 듦
+- [저장] = 줄이 안 잇는 사본 지움 · 덮개 저장 꼴이 `lib` 를 지킴
+- 층 권한 = `M02_Layer_Access`(남의 회사 403 · 회사 없는 개인 409)
+- 화면 — 연결 메뉴 출처 다섯 · 사전조합 창(서고 줄만) → 들여오기 → 원가 자료 바꿔 끼움 · 줄 연결
+임시 층(견본 마스터 · 임시 storage) · 실제 마스터 · 프로젝트는 안 씀.
+"""
+
+import asyncio
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from fastapi import HTTPException
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from B09_Estimation import B09_Estimation_Bill_Library as library  # noqa: E402
+from B09_Estimation import B09_Estimation_Router as router  # noqa: E402
+from B09_Estimation import B09_Estimation_Store as store_b09  # noqa: E402
+from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs  # noqa: E402
+from B09_Estimation.B09_Estimation_Linked import linked_resource_keys  # noqa: E402
+from config import config_system  # noqa: E402
+from M02_MasterTemplete import M02_Labor_Ref as refs  # noqa: E402
+from M02_MasterTemplete import M02_MasterTemplete_Store as store  # noqa: E402
+from M02_MasterTemplete import M02_Template_Layers as layers  # noqa: E402
+from resources.tester.helper_m02_master_sample import copy_master_sample  # noqa: E402
+
+STONE = "GF000219"  # 돌쌓기 메쌓기 원/㎡
+NET = "GC000337"  # 낙석방지망 — 고름 4 = NET_ITEM
+NET_ITEM = "MT006697"
+MAT = "MT000008"
+COMBO = "SS000011"  # 견본 관공 관매설(옛 UA 조합 줄)
+IMPORTS = re.compile(r"^import[^;]*;\r?\n", re.MULTILINE)
+
+
+@pytest.fixture()
+def world(tmp_path, monkeypatch):
+    system = copy_master_sample(tmp_path / "master")
+    monkeypatch.setattr(store, "FOLDER", system)
+    monkeypatch.setattr(layers, "SYSTEM_ROOT", system)
+    monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(tmp_path / "storage"))
+    lines = [
+        {"로직": STONE, "수량": {"손": 2}},
+        {"로직": NET, "수량": {"손": 1}, "고름": {"4": NET_ITEM}},
+    ]
+    with store.at(system):
+        key = refs.create(
+            "precombo",
+            {"이름": "서고 조합", "단위": "㎡", "담은로직": lines,
+             "자재": [{"코드": MAT, "수량": {"손": 3}}]},
+        )["이름"]  # fmt: skip
+    company = layers.company_dir(7)
+    company.mkdir(parents=True)
+    with store.at(company):
+        other = refs.create("precombo", {"이름": "회사 조합", "담은로직": lines[:1]})["이름"]
+    project = tmp_path / "storage" / "7" / "1" / "proj"
+    project.mkdir(parents=True)
+    return {"system": system, "key": key, "company": other, "root": project}
+
+
+def _block(root, folder):
+    got = daega_inputs(root)
+    bid = got["libs"][folder]
+    return got, next(b for b in got["blocks"] if b["id"] == bid)
+
+
+def test_사전조합_고름_사본_들여옴_새_호표_다시_고르면_재사용(world):
+    root = world["root"]
+    made = library.import_copy(root, "precombo", "system", None, world["key"])
+    folder = made["폴더"]
+    assert made == {"폴더": f"precombo@system@-@{world['key']}", "만듦": True}
+    copy = library.library_dir(root) / folder
+    assert {p.name for p in copy.iterdir()} == {"일위대가.json", "단가.json", "manifest.json"}
+    got, block = _block(root, folder)
+    assert (block["kind"], block["name"], block["unit"]) == ("사전조합", "서고 조합", "㎡")
+    kinds = [(ln["kind"], ln.get("qty")) for ln in block["lines"]]
+    assert kinds == [("sangeun", 2.0), ("sangeun", 1.0), ("material", 3.0)]
+    assert got["owners"] == {}  # 구조물 사본 없어도 호표
+    # 단가 묶음 = 담은 로직 · 사전조합 자재 · 고른 자재(사본 셈이 마스터를 안 읽음)
+    bundle = json.loads((copy / "단가.json").read_text("utf-8"))
+    text = json.dumps(bundle, ensure_ascii=False)
+    assert all(code in text for code in (STONE, NET, MAT, NET_ITEM))
+    keys = linked_resource_keys(root)
+    assert MAT in keys and any(k.startswith("LB") for k in keys)  # 단가 수요에 듦
+    # 다시 고름 = 새로 안 들여옴 · 같은 호표
+    again = library.import_copy(root, "precombo", "system", None, world["key"])
+    assert again == {"폴더": folder, "만듦": False}
+    assert _block(root, folder)[1]["id"] == block["id"]
+    # 원본을 지워도 굳힌 사본 그대로
+    (world["system"] / "precombo" / f"{world['key']}.json").unlink()
+    assert _block(root, folder)[1]["id"] == block["id"]
+
+
+def test_구조물조합_고름_사본_조합_호표(world):
+    root = world["root"]
+    made = library.import_copy(root, "combo", "system", None, COMBO)
+    copy = library.library_dir(root) / made["폴더"]
+    names = {p.name for p in copy.iterdir()}
+    assert {"집계.json", "일위대가.json", "단가.json", "입력값.json", "manifest.json"} <= names
+    manifest = json.loads((copy / "manifest.json").read_text("utf-8"))
+    assert manifest["종류"] == "combo" and manifest["원본"]["key"] == COMBO
+    assert manifest["원본"]["경로"]  # 가져온 때 경로
+    _, block = _block(root, made["폴더"])
+    assert block["kind"] == "조합" and block["lines"]
+    assert block["origin"] == {"layer": "system", "owner": None, "key": COMBO}
+
+
+def test_없는_것_모양_틀림(world):
+    root = world["root"]
+    with pytest.raises(LookupError):
+        library.import_copy(root, "precombo", "system", None, "SC-999999")
+    with pytest.raises(LookupError):
+        library.import_copy(root, "combo", "system", None, "SS999999")
+    with pytest.raises(ValueError):
+        library.import_copy(root, "precombo", "system", None, "../x")
+    with pytest.raises(ValueError):
+        library.import_copy(root, "other", "system", None, world["key"])
+    assert library.copies(root) == []
+
+
+def test_저장_때_안_잇는_사본_지움_lib_지킴(world):
+    root = world["root"]
+    a = library.import_copy(root, "precombo", "system", None, world["key"])["폴더"]
+    b = library.import_copy(root, "combo", "system", None, COMBO)["폴더"]
+    ref = {"tab": "dg", "key": "DG:x", "lib": a}
+    user = store_b09.clean_user(
+        {"bill": {"v": 2, "rows": [{"key": "hand:1", "name": "줄", "qty": 1, "ref": ref}]}}
+    )
+    assert user["bill"]["rows"][0]["ref"] == ref  # 저장 꼴이 lib 를 지킴
+    assert library.prune(root, user) == [b]
+    assert [f.name for f, _ in library.copies(root)] == [a]
+    assert library.prune(root, {}) == [a] and library.copies(root) == []
+
+
+def _call(monkeypatch, root, session, **body):
+    async def fake_root(_):
+        return root
+
+    async def fake_payload(_, at):
+        return {"inputs": {"daega": daega_inputs(at)}, "sheets": {}}
+
+    monkeypatch.setattr(router, "_project_root", fake_root)
+    monkeypatch.setattr(router, "payload", fake_payload)
+    req = router.LibraryBody(**body)
+    return asyncio.run(router.import_library("00000000-0000-0000-0000-000000000001", req, session))
+
+
+def test_층_권한_길(world, monkeypatch):
+    root = world["root"]
+    mine = {"user_id": 1, "company_id": 7, "role": "USER", "name": "갑"}
+    got = _call(monkeypatch, root, mine, kind="precombo", layer="company", key=world["company"])
+    assert got["만듦"] and got["폴더"] == f"precombo@company@7@{world['company']}"
+    assert got["key"] == got["payload"]["inputs"]["daega"]["libs"][got["폴더"]]
+    assert json.loads((library.library_dir(root) / got["폴더"] / "manifest.json").read_bytes())[
+        "가져온이"
+    ] == {"id": 1, "이름": "갑"}
+    other = {"user_id": 2, "company_id": 8, "role": "USER"}
+    with pytest.raises(HTTPException) as error:
+        _call(monkeypatch, root, other, kind="precombo", layer="company", owner="7",
+              key=world["company"])  # fmt: skip
+    assert error.value.status_code == 403
+    lonely = {"user_id": 3, "company_id": None, "role": "USER"}
+    with pytest.raises(HTTPException) as error:
+        _call(monkeypatch, root, lonely, kind="precombo", layer="personal", key=world["key"])
+    assert error.value.status_code == 409
+    with pytest.raises(HTTPException) as error:
+        _call(monkeypatch, root, lonely, kind="precombo", layer="system", key="SC-999999")
+    assert error.value.status_code == 404
+    got = _call(monkeypatch, root, lonely, kind="precombo", layer="system", key=world["key"])
+    assert got["만듦"] and got["key"]  # 마스터 = 누구나 읽음
+
+
+# ── 화면 ──────────────────────────────────────────────────────────────
+LINK_JS = """
+const toasts = [];
+const sent = [];
+globalThis.showToast = (m, k) => toasts.push([k, m]);
+globalThis.API_BASE_URL = "/api";
+globalThis.CURRENT_PROJECT_ID_KEY = "pid";
+globalThis.localStorage = { getItem: () => "P1" };
+globalThis.openLogicPicker = (done, lib) => { sent.push(["pre", lib.layer, lib.libOnly, lib.title]);
+  lib.pick({ 층: "company", 주인: "7", 키: "SC-000002" }, "회사 조합"); };
+globalThis.openItemPicker = async () => ({ action: "apply",
+  item: { layer: "system", owner: null, key: "SS000011", name: "관매설" } });
+const answer = { 폴더: "precombo@company@7@SC-000002", 만듦: true, key: "DG:new",
+  payload: { user: { bill: "서버 것" }, inputs: { daega: { libs: {} } },
+    sheets: { daega: [{ key: "DG:new", name: "회사 조합", spec: "", unit: "㎡" }] } } };
+globalThis.fetch = async (url, init) => { sent.push([url, JSON.parse(init.body)]);
+  return { ok: true, status: 200, json: async () => answer }; };
+const ctx = { sheets: {}, payload: { inputs: { old: 1 } }, user: { keep: 1 }, setUser() {} };
+const applied = [];
+const apply = (ref, from) => applied.push([ref, from && from.name]);
+const [picks, more] = linkItems(ctx, { tab: "dg", key: "DG:a" }, apply);
+const out = { picks: picks.map((x) => x[0]), more: more.map((x) => x[0]) };
+picks.find((x) => x[0].startsWith("서고 일위대가"))[1]();
+await new Promise((r) => setTimeout(r, 0));
+picks.find((x) => x[0].startsWith("서고 구조물"))[1]();
+await new Promise((r) => setTimeout(r, 0));
+await new Promise((r) => setTimeout(r, 0));
+Object.assign(out, { sent, applied, payload: ctx.payload, toasts });
+console.log(JSON.stringify(out));
+"""
+
+
+def test_화면_출처_다섯_사전조합_창_들여오기_줄_연결_TS():
+    src = IMPORTS.sub(
+        "", (ROOT / "B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts").read_text("utf-8")
+    )
+    result = subprocess.run(
+        ["node", "--experimental-strip-types", "--no-warnings",
+         "--input-type=module-typescript"],
+        input=src + LINK_JS, capture_output=True, text=True, encoding="utf-8", timeout=60,
+    )  # fmt: skip
+    assert result.returncode == 0, result.stderr
+    out = json.loads(result.stdout)
+    assert out["picks"] == [
+        "일위대가 호표",
+        "단가산출 호표",
+        "서고 구조물조합(마스터 · 회사 · 개인)",
+        "서고 일위대가 사전조합(마스터 · 회사 · 개인)",
+        "단가산출 로직(M01 · 새 산근)",
+    ]
+    assert out["more"] == ["연결 풀기"]
+    pre, (url, body) = out["sent"][0], out["sent"][1]
+    assert pre == ["pre", "personal", True, "일위대가 사전조합 고르기"]  # 서고 줄만 · 층 셋
+    assert url == "/api/projects/P1/estimation/library"
+    assert body == {"kind": "precombo", "layer": "company", "owner": "7", "key": "SC-000002"}
+    assert out["sent"][2][1] == {"kind": "combo", "layer": "system", "owner": None,
+                                 "key": "SS000011"}  # fmt: skip
+    ref = {"tab": "dg", "key": "DG:new", "lib": "precombo@company@7@SC-000002"}
+    assert out["applied"][0] == [ref, "회사 조합"]
+    # 원가 자료만 바꿔 끼움 — 사용자 값(서버 user)은 안 받음
+    assert "user" not in out["payload"] and out["payload"]["inputs"] == {"daega": {"libs": {}}}
+    assert out["toasts"][-1][0] == "success"
diff --git a/resources/tester/test_205_1_structure_actions_height.py b/resources/tester/test_205_1_structure_actions_height.py
new file mode 100644
index 000000000..9d3ae79b4
--- /dev/null
+++ b/resources/tester/test_205_1_structure_actions_height.py
@@ -0,0 +1,50 @@
+"""205-1 「구조물 배치」 맨 아래 [추가] · [삭제] · [리셋] 줄 — 단추 높이 = 상자 안 작은 단추 · 늘 보임.
+
+- 높이 = `--b05-control-h`(상자 안 단추 · 입력 칸과 같은 값) · 상자 이름표 [삭제]와 같은 높이 식
+- 줄 = 스크롤 영역 아래 끝에 붙음(sticky · bottom 0) · 단추 · 줄에 hidden · display none · visibility ·
+  호버 조건이 없음
+"""
+
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+CSS = (ROOT / "B05_Profile/B05_Profile_UI_Style_Structures.css").read_text(encoding="utf-8")
+FORM = (ROOT / "B05_Profile/B05_Profile_UI_Structures_Form.ts").read_text(encoding="utf-8")
+SECTION = ".b05-structure-section .b05-route__irregular-actions"
+
+
+def _block(selector: str) -> str:
+    m = re.search(r"(?m)^" + re.escape(selector) + r"\s*\{([^}]*)\}", CSS)
+    assert m, selector
+    return m.group(1)
+
+
+def _decl(block: str, prop: str) -> str:
+    m = re.search(r"(?:^|;|\s)" + re.escape(prop) + r"\s*:\s*([^;]+);", block)
+    assert m, prop
+    return m.group(1).strip()
+
+
+def test_buttons_same_height_as_inner_buttons():
+    outer = _block(SECTION + " > button")
+    inner = re.search(r"\.b05-structure__group > legend > button\s*\{([^}]*)\}", CSS).group(1)
+    assert _decl(outer, "height") == "var(--b05-control-h)"
+    for prop in ("height", "box-sizing", "padding-block", "font-size", "line-height"):
+        assert _decl(outer, prop) == _decl(inner, prop), prop
+    assert re.search(r"--b05-control-h:\s*26px;", CSS)
+
+
+def test_row_always_visible():
+    row = _block(SECTION)
+    assert _decl(row, "position") == "sticky"
+    assert _decl(row, "bottom") == "0"
+    assert "background" in row
+    for text in (_block(SECTION), _block(SECTION + " > button")):
+        assert not re.search(r"display\s*:\s*none|visibility|opacity|overflow", text)
+    assert not re.search(re.escape(SECTION) + r"[^{]*(:hover|:focus-within|\[hidden\])", CSS)
+
+
+def test_form_never_hides_buttons():
+    assert "removeButton.hidden" not in FORM and "resetButton.hidden" not in FORM
+    assert "actions.hidden" not in FORM
diff --git a/resources/tester/test_206_1_both_fill_no_ditch.py b/resources/tester/test_206_1_both_fill_no_ditch.py
new file mode 100644
index 000000000..9e5d603a4
--- /dev/null
+++ b/resources/tester/test_206_1_both_fill_no_ditch.py
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+"""PLAN 206-1 — 양측 성토 측점에 측구가 남는 흠(검증_sub1 No.1+0 사본 재현).
+
+원인 — 측구 판정의 「양측 성토 = 측구 없음」이 **입력** `section_mode` 를 봤다. 입력은 옛 저장값
+(초기값 right_cut)이고, 계획고를 +1.98 m 올려 지형 판정(역할)은 양측 성토가 됐는데 입력이 그대로라
+옛 결과 `ditch_enabled=True` 가 사용자 선택으로 둔갑(ditch_choice=True)해 측구가 섰다.
+좌 · 우를 누르면 카드가 판정값 both_fill 을 입력으로 다시 보내 그때서야 사라졌다.
+고침 — 판정된 역할(양쪽 성토)로 가름 · 파이썬 · TS 짝 같은 규칙 · 옛 저장분은 낡음으로 다시 셈.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from B06_Section.B06_Section_Engine_Design import compute_cross_design  # noqa: E402
+
+# 검증_sub1(7e420ed6) 노선 230 · No.1+0(20 m) 지반선 사본 — -20 ~ +20 m · 0.5 m 간격
+_Z = [
+    885.0166, 884.8327, 884.6401, 884.4294, 884.2270, 883.7564, 883.2482, 882.8840, 882.5737,
+    882.3786, 882.2795, 881.9692, 881.3788, 880.7761, 880.1219, 879.4944, 879.1738, 878.8550,
+    878.6597, 878.4670, 878.1648, 877.8416, 877.5119, 877.1749, 876.8564, 876.5584, 876.2612,
+    875.9646, 875.6791, 875.4169, 875.1405, 874.7286, 874.3079, 874.0026, 873.7065, 873.4074,
+    873.1107, 872.7726, 872.4127, 872.1306, 871.9252, 871.7424, 871.6078, 871.3723, 870.7716,
+    870.1964, 869.8586, 869.5135, 869.2563, 869.0105, 868.5769, 868.0912, 867.7274, 867.4369,
+    867.1615, 866.9033, 866.6590, 866.4489, 866.2281, 865.9711, 865.7139, 865.4391, 865.1650,
+    864.8953, 864.6289, 864.3219, 863.9996, 863.6703, 863.3343, 863.0443, 862.8261, 862.5776,
+    862.2364, 861.9035, 861.6491, 861.3932, 861.1137, 860.8302, 860.6107, 860.4051, 860.2006,
+]  # fmt: skip
+SAMPLES = [{"offset_m": -20.0 + 0.5 * i, "elevation_m": z} for i, z in enumerate(_Z)]
+ELEV = 873.900731  # 지금 계획고(초기값 871.9252 에서 +1.98 m)
+# 그 프로젝트 저장분과 같은 입력 — 옛 단면유형 · 옛 측구 결과
+STORED = {
+    "ground_type": "ripping_rock",
+    "ditch_side": "right",
+    "ditch_type": "standard",
+    "rock_boundary_offset_m": -0.5,
+    "two_stage_slope": True,
+}
+
+
+_GROUP = {
+    "road_width_m": 3,
+    "shoulder_left_m": 0.5,
+    "shoulder_right_m": 0.5,
+    "ditch": {"top_width_m": 0.9, "bottom_width_m": 0.3, "depth_m": 0.3},
+    "fill_slope_ratio": 1.2,
+}
+# 그 프로젝트 종단 options 의 표준 횡단면
+STANDARD = {
+    "soil": {**_GROUP, "cross_slope_pct": {"min": 3, "max": 5}, "cut_slope_ratio": 1},
+    "rock": {
+        **_GROUP,
+        "ditch_l_type": {"width_m": 0.5, "depth_m": 0.1},
+        "cross_slope_pct": {"min": 3, "max": 5},
+        "cut_slope_ratio": 0.4,
+    },
+    "paved": {
+        **_GROUP,
+        "cross_slope_pct": {"min": 1.5, "max": 2},
+        "cut_slope_ratio": 1,
+        "pavement_thickness_m": 0.2,
+    },
+}
+
+
+def _design(section_mode: str, **kwargs):
+    return compute_cross_design(
+        SAMPLES, ELEV, section_mode=section_mode, standard=STANDARD, **STORED, **kwargs
+    )
+
+
+@pytest.mark.parametrize(
+    "stale",
+    [
+        {"ditch_enabled": True},  # 옛 결과만(초기값 → 계획고 변경 재계산)
+        {"ditch_enabled": True, "ditch_choice": True},  # 둔갑한 선택이 저장된 뒤(지금 DB)
+    ],
+)
+@pytest.mark.parametrize("mode", ["right_cut", "both_cut", "left_cut"])
+def test_사본_양측_성토면_옛_입력이어도_측구_없음(mode: str, stale: dict) -> None:
+    design = _design(mode, **stale)
+    assert design["section_mode"] == "both_fill"
+    assert design["ditch_enabled"] is False, "양측 성토인데 측구가 섰다"
+    assert design["ditch_area_m2"] == 0.0
+    assert design["ditch"] == {"type": "none"}
+    assert design["ditch_choice"] is None, "옛 결과가 선택으로 남았다"
+
+
+def test_사본_옛_입력과_바른_입력이_같은_형상() -> None:
+    """좌 · 우를 눌러야만 사라지던 것 — 이제 입력이 옛 값이어도 처음부터 같은 형상 · 면적."""
+    stale = _design("right_cut", ditch_enabled=True, ditch_choice=True)
+    fresh = _design("both_fill")
+    for key in ("design_line", "fill_area_m2", "cut_area_m2", "ditch_area_m2"):
+        assert stale[key] == fresh[key], key
+    assert fresh["fill_area_m2"] == pytest.approx(34.0513, abs=1e-4)
+    # 우 노견 바깥에 측구 꼭짓점(-2.3 · -2.6 · -2.9 m = 상단 0.9 · 저폭 0.3 사다리꼴)이 없다
+    offsets = {p["offset_m"] for p in fresh["design_line"]}
+    assert not offsets & {-2.3, -2.6, -2.9}
+
+
+def test_한쪽이라도_절토면_측구_그대로() -> None:
+    """양측 성토 판정은 역할로만 — 우 절토 지형은 옛 입력 both_fill 이어도 측구 섬."""
+    design = _design("both_fill", ditch_enabled=False)
+    assert design["section_mode"] == "both_fill"  # 이 지형은 양측 성토
+    cut = compute_cross_design(SAMPLES, ELEV - 2.5, section_mode="both_fill", **STORED)
+    assert cut["section_mode"] in ("right_cut", "both_cut")
+    assert cut["ditch_enabled"] is True and cut["ditch_side"] == "right"
+
+
+def test_TS_짝도_같은_값(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """거울 — 같은 사본을 TS `computeCrossDesign` 에 넣어 파이썬과 같은지(측구 없음까지)."""
+    import test_b06_cross_design_mirror as mirror
+
+    cases = [
+        {
+            "name": f"206-1 사본 {mode}",
+            "samples": SAMPLES,
+            "design_elevation_m": ELEV,
+            "options": {
+                "section_mode": mode,
+                **STORED,
+                "ditch_enabled": True,
+                "ditch_choice": True,
+            },
+        }
+        for mode in ("right_cut", "both_fill")
+    ]
+    monkeypatch.setattr(mirror, "CASES", cases)
+    py, ts = mirror._python_results(), mirror._ts_results(tmp_path)
+    problems = []
+    for case, left, right in zip(cases, py, ts):
+        problems.extend(mirror._diff(left, right, case["name"]))
+    assert not problems, "\n".join(problems[:20])
+    assert all(item["ditch_enabled"] is False for item in ts)
+
+
+def _src(rel: str) -> str:
+    return (PROJECT_ROOT / rel).read_text(encoding="utf-8")
+
+
+def test_옛_저장분은_낡음으로_다시_셈() -> None:
+    """DB 에 남은 양측 성토 + 측구 결과 → B05 · B06 진입 때 브라우저가 다시 셈(공용 낡음 판정)."""
+    common = _src("B06_Section/B06_Section_UI_Section_Common.ts")
+    assert 'design.section_mode === "both_fill" && design.ditch_enabled === true' in common
+
+
+def test_측구가_그려져_있으면_단추를_숨기지_않음() -> None:
+    """179-2 숨김은 「막힘 + 그려진 측구 없음」일 때만 — 그려진 측구는 끌 수 있어야 함."""
+    cd = _src("B06_Section/B06_Section_UI_Cross_Design.ts")
+    assert "const ditchDrawn = design?.ditch_enabled === true;" in cd
+    assert 'const hasDitch = state.mode !== "both_fill" || ditchDrawn;' in cd
+    assert '(state.mode !== "both_fill" || ditchDrawn)' in cd  # 측구형식도 같은 규칙
diff --git a/resources/tester/test_207_1_b06_notice_overlay.py b/resources/tester/test_207_1_b06_notice_overlay.py
new file mode 100644
index 000000000..08b45a0f9
--- /dev/null
+++ b/resources/tester/test_207_1_b06_notice_overlay.py
@@ -0,0 +1,115 @@
+"""207-1 B06 알림 칩 다듬기 — 둥근 사각 · 내용 칸 겹쳐 띄움 · 고르면 접힘 · 고른 측점 강조.
+
+동작은 `B06_Section_UI_Cross_Notice_Chips.ts` 를 Node 로 그대로 돌림(196-1 가짜 DOM 재사용).
+모양 · 흐름 밖(겹침) · 줄 높이만 재는 scroll-margin 은 CSS · 부르는 쪽 원문 대조.
+"""
+
+import json
+import subprocess
+
+from test_196_1_b06_notice_chips import B06, PRELUDE
+
+CSS = (B06 / "B06_Section_UI_Style_Cross.css").read_text(encoding="utf-8")
+
+
+def _rule(selector: str) -> str:
+    body = CSS[CSS.index(selector + " {") :]
+    return body[: body.index("}")]
+
+
+def _node(body: str):
+    script = (
+        PRELUDE
+        + """
+const sel = { id: null };
+const picked = [];
+const bar2 = mod.exports.createNoticeChips((id) => { picked.push(id); sel.id = id; }, () => sel.id);
+const [chips2, panel2] = bar2.root.children;
+const chip2 = (key) => chips2.children.find((c) => c.dataset.noticeKey === key);
+const marks = () => panel2.children.map((b) => [b.dataset.stationId, b.classList.contains("is-selected")]);
+"""
+        + body
+        + "\nconsole.log(JSON.stringify(out));"
+    )
+    got = subprocess.run(
+        ["node", "-e", script], capture_output=True, text=True, encoding="utf-8", timeout=60
+    )
+    assert got.returncode == 0, got.stderr
+    return json.loads(got.stdout)
+
+
+def test_칩은_둥근_사각_공용_단추_반경_알약_아님():
+    chip = _rule(".b06-section__notice-chip")
+    assert "border-radius: var(--radius-buttons)" in chip
+    assert "radius-pills" not in chip and "radius-sm" not in chip
+
+
+def test_내용_칸은_흐름_밖_카드_위에_겹침():
+    panel = _rule(".b06-section__notice-list")
+    assert "position: absolute" in panel and "top: 100%" in panel
+    assert "z-index" in panel and "box-shadow: var(--shadow-lg)" in panel
+    assert "background: var(--color-surface-raised)" in panel
+    # 기준 = 고정 줄(sticky 는 absolute 의 기준 상자) · 그 사이에 기준을 바꾸는 position 없음
+    assert "position: sticky" in _rule(".b06-section__notice-bar")
+    assert "position" not in _rule(".b06-section__notice-blocks")
+
+
+def test_열고_닫아도_카드_자리_그대로_scroll_margin은_칩_줄_높이만():
+    view = (B06 / "B06_Section_UI_Section_View.ts").read_text(encoding="utf-8")
+    # 줄 높이 = 고정 줄 offsetHeight — 흐름 밖 내용 칸은 높이에 안 듦
+    assert '"--b06-notice-h", `${fillSlopeNotice.root.offsetHeight}px`' in view
+    assert "scroll-margin-top: calc(var(--b06-notice-h, 0px) + var(--spacing-8))" in CSS
+    # 내용 칸만 흐름 밖 — 칩 줄은 흐름 안
+    assert "position" not in _rule(".b06-section__notice-chips")
+
+
+def test_측점_고르면_그_카드로_가며_내용_칸_접힘():
+    got = _node(
+        """
+bar2.update(items(["a", "b"], ["p"], []));
+chip2("fill").click();
+out.before = panel2.hidden;
+panel2.children[1].click();
+out.picked = picked.slice();
+out.after = panel2.hidden;
+out.rows = panel2.children.length;
+out.expanded = chips2.children.map((c) => c.getAttribute("aria-expanded"));
+"""
+    )
+    assert got["before"] is False
+    assert got["picked"] == ["b"]
+    assert got["after"] is True and got["rows"] == 0
+    assert got["expanded"] == ["false", "false"]
+
+
+def test_고른_측점이_있으면_열_때_그_단추_강조_없으면_강조_없음():
+    got = _node(
+        """
+bar2.update(items(["a", "b", "c"], ["b"], []));
+chip2("fill").click();
+out.none = marks();
+chip2("fill").click();
+sel.id = "b";  // 측점 횡단도를 고른 상태
+chip2("fill").click();
+out.fill = marks();
+chip2("pave").click();
+out.pave = marks();
+sel.id = "zz";  // 목록에 없는 측점
+chip2("fill").click();
+out.absent = marks();
+"""
+    )
+    assert got["none"] == [["a", False], ["b", False], ["c", False]]
+    assert got["fill"] == [["a", False], ["b", True], ["c", False]]
+    assert got["pave"] == [["b", True]]
+    assert got["absent"] == [["a", False], ["b", False], ["c", False]]
+
+
+def test_고른_측점_넘김_부르는_쪽_이음과_강조_색():
+    notice = (B06 / "B06_Section_UI_Cross_FillSlope_Notice.ts").read_text(encoding="utf-8")
+    assert "createNoticeChips(onPick, selected)" in notice
+    view = (B06 / "B06_Section_UI_Section_View.ts").read_text(encoding="utf-8")
+    assert "() => selectedStationId," in view
+    mark = _rule(".b06-section__notice-list > button.is-selected")
+    assert "var(--color-danger)" in mark  # 카드 고름 색과 같음
+    assert "border-color: var(--color-danger)" in _rule(".b06-cross-card--selected")
diff --git a/resources/tester/test_208_1_logic_alias.py b/resources/tester/test_208_1_logic_alias.py
new file mode 100644
index 000000000..bf5ac9e66
--- /dev/null
+++ b/resources/tester/test_208_1_logic_alias.py
@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""PLAN 208-1 — 단가산출 로직 「별칭」 칸 · 로직 찾기는 이름 + 별칭.
+
+① 서버 찾기 맞춤(`M01_MasterData_Store_Find.hit`) ↔ 화면 공용 맞춤(`ui_template_logic_find.ts`) 거울
+② 읽기(없으면 빈칸) · 저장 왕복 — 임시 사본 폴더만(정본 마스터 파일은 안 바뀜)
+③ M01 목록 「별칭」 열(이름 옆) · 쓰는 곳마다 공용 맞춤을 부름
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from M01_MasterData import M01_MasterData_Router as router_module
+from M01_MasterData import M01_MasterData_Store as store
+from M01_MasterData.M01_MasterData_Store_Find import hit
+
+ROOT = Path(__file__).resolve().parents[2]
+REAL = store.FOLDER
+LOGIC_KEY = "GC000091"  # 공통 3-3-1 암발파(미진동굴착 TYPE-Ⅰ)
+LOGIC_FILE = "로직_건설품셈_03장_토공사.json"
+
+ROW = {
+    "키": "GF000001",
+    "원문번호": "9-1-1",
+    "이름": "흙깎기(보통토사)",
+    "별칭": "절토, 터파기 기계",
+}
+# (찾는 글, 맞음, 별칭으로 맞은 것)
+CASES = [
+    ("흙깎기", True, ""),
+    ("흙 깎기", True, ""),  # 띄어쓰기 무시 · 낱말마다
+    ("절토", True, "절토"),
+    ("터파기", True, "터파기 기계"),
+    ("터파기기계", True, "터파기 기계"),  # 별칭 안 띄어쓰기 무시
+    ("절토 기계", True, "절토, 터파기 기계"),  # 낱말이 여러 별칭에 나뉘어 듦
+    ("흙깎기 절토", True, "절토"),  # 이름 + 별칭
+    ("gf000001", True, ""),
+    ("9-1", True, ""),
+    ("성토", False, ""),
+    ("", True, ""),
+]
+
+
+def _node(src: str) -> str:
+    if shutil.which("node") is None:
+        pytest.skip("node 가 없음")
+    done = subprocess.run(
+        ["node", "--experimental-strip-types", "--input-type=module", "-e", src],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+        cwd=ROOT,
+    )
+    assert done.returncode == 0, done.stderr
+    return done.stdout
+
+
+def test_서버_맞춤_이름_별칭_여러_별칭() -> None:
+    for q, ok, _ in CASES:
+        assert hit(ROW, q) is ok, q
+    assert hit({**ROW, "별칭": ""}, "절토") is False  # 별칭 없음 = 빈칸
+    assert hit({k: v for k, v in ROW.items() if k != "별칭"}, "흙깎기") is True
+
+
+def test_화면_맞춤_거울_서버와_같음() -> None:
+    url = (ROOT / "ui_template" / "ui_template_logic_find.ts").as_uri()
+    src = f"""
+import {{ matchLogic, aliasText, aliasesOf, aliasNote }} from "{url}";
+const row = {json.dumps(ROW, ensure_ascii=False)};
+const cases = {json.dumps([c[0] for c in CASES], ensure_ascii=False)};
+console.log(JSON.stringify({{
+  hits: cases.map((q) => matchLogic(q, row)),
+  text: aliasText(" 절토 ,, 터파기 기계,"),
+  none: aliasesOf(undefined),
+  note: [aliasNote("절토"), aliasNote("")],
+  chapter: matchLogic("토공", {{ ...row, 상세구분: "09장 토공" }}).ok,
+}}));
+"""
+    got = json.loads(_node(src))
+    for (q, ok, alias), one in zip(CASES, got["hits"]):
+        assert one == {"ok": ok, "alias": alias}, q
+        assert one["ok"] is hit(ROW, q), q  # 서버와 같은 판정
+    assert got["text"] == "절토, 터파기 기계"
+    assert got["none"] == []
+    assert got["note"] == ["별칭 절토", ""]
+    assert got["chapter"] is True  # 구분 · 상세구분은 화면만 더 봄
+
+
+@pytest.fixture
+def client(tmp_path: Path, monkeypatch) -> TestClient:
+    for path in REAL.glob("*.json"):
+        if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
+            shutil.copy(path, tmp_path / path.name)
+    monkeypatch.setattr(store, "FOLDER", tmp_path)
+    app = FastAPI()
+    app.include_router(router_module.router)
+    return TestClient(app)
+
+
+def _logics(client: TestClient, **params) -> list[dict]:
+    res = client.get("/api/m01/logics", params=params)
+    assert res.status_code == 200, res.text
+    return res.json()["logics"]
+
+
+def _save(client: TestClient, row: dict) -> None:
+    one = client.get("/api/m01/logic", params={"key": LOGIC_KEY}).json()
+    part = {
+        "file": one["file"],
+        "version": one["version"],
+        "changes": [{"op": "edit", "key": LOGIC_KEY, "row": row}],
+    }
+    res = client.post("/api/m01/save", json={"files": [part]})
+    assert res.status_code == 200, res.text
+
+
+def test_읽기_빈칸_저장_왕복_임시_사본만(client: TestClient) -> None:
+    real = (REAL / LOGIC_FILE).read_bytes()
+    listed = _logics(client)
+    assert listed and all(isinstance(x["별칭"], str) for x in listed)  # 없으면 빈칸
+    one = client.get("/api/m01/logic", params={"key": LOGIC_KEY}).json()
+    base = one["logic"]
+    assert "별칭" not in base  # 마스터 파일에 일괄로 쓰지 않음
+
+    _save(client, {**base, "별칭": "미진동 발파, 암깨기"})
+    got = [x for x in _logics(client, q="암깨기") if x["키"] == LOGIC_KEY]
+    assert got and got[0]["별칭"] == "미진동 발파, 암깨기"
+    assert LOGIC_KEY in [x["키"] for x in _logics(client, q="미진동 발파")]
+    found = client.get("/api/m01/elements", params={"group": "로직", "q": "암깨기"}).json()
+    assert [x["별칭"] for x in found["items"] if x["ref"] == LOGIC_KEY] == ["미진동 발파, 암깨기"]
+    saved = json.loads((store.FOLDER / LOGIC_FILE).read_text(encoding="utf-8"))
+    assert next(r for r in saved["줄"] if r["키"] == LOGIC_KEY)["별칭"] == "미진동 발파, 암깨기"
+
+    _save(client, base)  # 지우면 칸째 빠짐 · 찾기에도 안 걸림
+    assert LOGIC_KEY not in [x["키"] for x in _logics(client, q="암깨기")]
+    after = json.loads((store.FOLDER / LOGIC_FILE).read_text(encoding="utf-8"))
+    assert after == json.loads(real.decode("utf-8"))  # 왕복 뒤 내용 그대로
+    assert (REAL / LOGIC_FILE).read_bytes() == real  # 정본은 안 건드림
+
+
+def _src(rel: str) -> str:
+    return (ROOT / rel).read_text(encoding="utf-8")
+
+
+def test_M01_목록_별칭_열은_이름_옆_고치면_캐시() -> None:
+    ts = _src("M01_MasterData/M01_MasterData_UI_Logic_List.ts")
+    cols = ts[ts.index("const COLS") : ts.index("as const")]
+    names = [x.strip().strip('"') for x in cols[cols.index("[") + 1 :].split(",")]
+    assert names[names.index("이름") + 1] == "별칭"  # 이름 바로 옆
+    assert "aliasCell(item" in ts and "onAlias(item, next)" in ts
+    assert "e.stopPropagation()" in ts  # 별칭 칸을 눌러도 로직이 안 열림
+    lab = _src("M01_MasterData/M01_MasterData_UI_LogicLab.ts")
+    assert "const onAlias = async" in lab and "list.setMarks(marks, extra, aliases)" in lab
+    # 자동저장 없음 — 캐시(drafts)에만 · [저장] 이 보냄
+    body = lab[lab.index("const onAlias = async") : lab.index("const onDelete = async")]
+    assert "saveFiles" not in body and "persist()" in body
+
+
+@pytest.mark.parametrize(
+    "rel",
+    [
+        "M01_MasterData/M01_MasterData_UI_Logic_List.ts",  # M01 로직 목록
+        "M01_MasterData/M01_MasterData_UI_Logic_Pick.ts",  # M01 요소 찾기 창 · 로직 그룹
+        "M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Build.ts",  # M02 흐름도 다른 로직 고르기
+        "M02_MasterTemplete/DataFlow/M02_DF_InputPanel_Logic.ts",  # 〃 결과 별칭 표시
+        "M02_MasterTemplete/M02_MasterTemplete_Labor_Pick.ts",  # M02 · B09 [로직 더하기]
+    ],
+)
+def test_쓰는_곳마다_공용_맞춤을_부름(rel: str) -> None:
+    ts = _src(rel)
+    assert 'from "@ui/ui_template_logic_find"' in ts
+    assert "matchLogic(" in ts
+
+
+def test_서버_찾기도_한_벌() -> None:
+    py = _src("M01_MasterData/M01_MasterData_Store.py")
+    assert "import hit as _hit" in py and "def _hit" not in py
diff --git a/resources/tester/test_209_1_detail_select.py b/resources/tester/test_209_1_detail_select.py
new file mode 100644
index 000000000..b695354c9
--- /dev/null
+++ b/resources/tester/test_209_1_detail_select.py
@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""PLAN 209-1 — B06 [상세] 그래프 고르기(교차점 분할 · 여러 고름 · 원지반 포함 · 닫힌 넓이).
+
+정보창(고른 것 길이 · 면적) · 칸 넣기 · 서버 검산 · 옛 꼴 읽기.
+
+못박는 것
+  - 선(설계선 · 원지반선)이 만나는 점에서 조각으로 나뉨 · 화면 px → m · 격자 등은 안 고름.
+  - 여러 고름(Shift/Ctrl 더하기 · 빼기) · 원지반 조각 포함 닫힌 영역 넓이 · 안 닫히면 null.
+  - 정보창 두 줄(하나 = 카드 꼴 길이 · 경사비율 / 여럿 = 길이 합 · 면적 · 「닫히지 않음」).
+  - 칸 넣기 출처(조각 두 끝 목록) → 스키마 → 서버 `cell_value` 거울(① 파이썬 · TS) ·
+    서버 검산(선 밖 · 설계선 바뀜 → 다시 고름 · 구조물 선 = 두 끝 직선) · 옛 두 끝 꼴 그대로.
+
+./venv/Scripts/python.exe -m pytest resources/tester/test_209_1_detail_select.py -q
+"""
+
+import json
+import os
+import subprocess
+from math import hypot
+from pathlib import Path
+
+import pytest
+
+from B06_Section import B06_Section_Router_CrossTable as table_mod
+from B06_Section.B06_Section_Schema import CrossSectionPatch
+from B07_DesignDetail.B07_DesignDetail_Engine_Cross_Table_Edit import (
+    cell_value,
+    ground_runs,
+    ring_area,
+    sub_path,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+HERE = Path(__file__).resolve().parent
+
+LINE = [(-6.0, 104.0), (-2.0, 98.0), (2.0, 98.0), (6.0, 104.0)]
+DESIGN = {
+    "design_elevation_m": 98.0,
+    "road_edges": {
+        "left": {"offset_m": 2.0, "elevation_m": 98.0},
+        "right": {"offset_m": -2.0, "elevation_m": 98.0},
+    },
+    "design_line": [{"offset_m": x, "elevation_m": y} for x, y in LINE],
+}
+SAMPLES = [{"offset_m": x, "elevation_m": 100.0, "valid": True} for x in (-10, -5, 0, 5, 10)] + [
+    {"offset_m": 12.0, "elevation_m": None, "valid": False},
+    {"offset_m": 14.0, "elevation_m": 101.0, "valid": True},
+]
+AXES = {
+    "widthPx": 600,
+    "heightPx": 300,
+    "pixelsPerMeter": 10,
+    "maxOffset": 14,
+    "displayMax": 110,
+    "elevationMid": 100,
+    "exaggeration": 2,
+}
+CROSS_X = 2 + 4 / 3  # 경사(1:0.667)가 원지반 100 m 와 만나는 offset
+AREA = (2 * CROSS_X + 4) / 2 * 2  # 사다리꼴(윗변 2·CROSS_X · 아랫변 4 · 높이 2)
+
+pytestmark = pytest.mark.skipif(
+    not (ROOT / "config" / "node_modules").is_dir(), reason="프론트엔드 의존성 미설치"
+)
+
+
+@pytest.fixture(scope="module")
+def out() -> dict:
+    proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", str(HERE / "helper_209_1_detail_select.cjs")],
+        input=json.dumps({"design": DESIGN, "samples": SAMPLES, "axes": AXES}),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+        cwd=os.fspath(ROOT),
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def _ends(piece: dict) -> list[tuple[float, float]]:
+    pts = piece["points"]
+    return [tuple(round(v, 4) for v in pts[0]), tuple(round(v, 4) for v in pts[-1])]
+
+
+# ── 분할 · 여러 고름 ─────────────────────────────────────────────────────
+
+
+def test_교차점에서_조각으로_나뉨(out):
+    pieces = out["pieces"]
+    ground = [p for p in pieces if p["line"] == "ground"]
+    design = [p for p in pieces if p["line"] == "design"]
+    assert len(ground) == 3 and len(design) == 5  # 원지반 = 두 교점에서 셋 · 설계 경사 둘이 둘씩
+    c = round(CROSS_X, 4)
+    assert sorted(_ends(p)[0][0] for p in ground) == pytest.approx([-10.0, -c, c])
+    # 원지반 가운데 조각은 사이 샘플 꼭짓점(0 m)을 지남 — 꺾은선 그대로
+    middle = next(p for p in ground if abs(p["points"][0][0]) < 4)
+    assert [0.0, 100.0] in [[round(v, 6) for v in q] for q in middle["points"]]
+    # 경사 조각 끝 = 교점(설계선 위 · 원지반 위)
+    assert any(_ends(p)[1] == (c, 100.0) or _ends(p)[0] == (c, 100.0) for p in design)
+
+
+def test_여러_고름_더하기_빼기(out):
+    toggle = out["toggle"]
+    assert toggle == {"single": [3], "again": [], "add": [1, 3], "remove": [1]}
+
+
+# ── 닫힌 넓이 · 정보창 ──────────────────────────────────────────────────
+
+
+def test_원지반_포함_닫힌_영역_넓이(out):
+    assert out["ringCount"] == 4  # 경사 둘 · 바닥 · 원지반 가운데
+    assert out["area"] == pytest.approx(AREA)
+    assert out["open"] is None  # 원지반 빼면 안 닫힘
+
+
+def test_정보창_값(out):
+    label = out["label"]
+    length = 2 * hypot(4 / 3, 2) + 4 + 2 * CROSS_X
+    assert label["ring"] == f"4개 · 길이 합 {length:.2f}m\n면적 {AREA:.2f}㎡"
+    assert label["open"].endswith("면적 닫히지 않음")
+    assert label["single"] == "길이 4.00m · 경사비율 0.0%\n수평 4.00m · 높이 0.00m"  # 카드 꼴
+    assert label["ground"] == (
+        f"원지반선 길이 {2 * CROSS_X:.2f}m\n수평 {2 * CROSS_X:.2f}m · 높이 0.00m"
+    )
+
+
+# ── 칸 넣기 · 짝 · 서버 검산 ─────────────────────────────────────────────
+
+
+def test_칸_넣기_출처_저장_꼴(out):
+    area = out["sourceArea"]
+    assert area["src"] == "area" and len(area["pieces"]) == 4
+    assert {p["line"] for p in area["pieces"]} == {"design", "ground"}
+    assert out["sourceOpen"] is None  # 안 닫힌 면적은 칸에 못 넣음
+    assert out["sourceLength"]["src"] == "length"
+    patch = CrossSectionPatch(
+        chainage_m=40.0,
+        detail_table={"cells": {"cut_soil": area, "fence": out["sourceLength"]}},
+    ).model_dump()
+    assert patch["detail_table"]["cells"]["cut_soil"]["pieces"][0]["line"] in ("design", "ground")
+
+
+def test_칸_값_파이썬_TS_거울(out):
+    for source, local in zip(out["sources"], out["local"], strict=True):
+        number, _text, again = cell_value(source, DESIGN, SAMPLES)
+        if number is None:
+            assert local is None and again is True, source
+        else:
+            assert local == pytest.approx(number, abs=1e-6), source
+    assert out["local"][0] == pytest.approx(AREA, abs=1e-3)
+    assert out["local"][1] == pytest.approx(out["lengthSum"], abs=1e-3)
+    assert out["local"][2] == pytest.approx(out["lengthSum"] + 5.0, abs=1e-3)  # 구조물 = 두 끝 직선
+    assert out["local"][3] is None  # 원지반 밖 끝
+
+
+def test_서버_검산_선_밖이나_설계선_바뀌면_다시_고름(out):
+    cells = {"cut_soil": out["sourceArea"], "fence": out["sourceLength"]}
+    stored = CrossSectionPatch(chainage_m=40.0, detail_table={"cells": cells}).model_dump()
+    design = {**DESIGN, "detail_table": stored["detail_table"]}
+    source = {"chainage_m": 40.0, "center_z": 100.0, "samples": SAMPLES}
+    sheet = table_mod.cross_quantity_sheet(source, design)
+    assert sheet["quantity_table"]["cut_soil"] == pytest.approx(AREA, abs=1e-3)
+    assert sheet["quantity_table"]["fence"] == pytest.approx(out["lengthSum"], abs=1e-3)
+    assert sheet["repick"] == []
+    # 원지반 샘플이 없으면(검산 못 함) 다시 고름 — 브라우저 값 안 받음
+    blind = table_mod.cross_quantity_sheet({"chainage_m": 40.0}, design)
+    assert sorted(blind["repick"]) == ["cut_soil", "fence"]
+    # 설계선이 내려가면 조각 끝이 선 밖 → 다시 고름
+    moved = {**design, "design_line": [{"offset_m": x, "elevation_m": y - 1} for x, y in LINE]}
+    again = table_mod.cross_quantity_sheet(source, moved)
+    assert again["quantity_table"]["cut_soil"] is None
+    assert sorted(again["repick"]) == ["cut_soil", "fence"]
+
+
+def test_옛_두_끝_꼴_그대로_읽음():
+    old = {"src": "length", "start": [2.0, 98.0], "end": [6.0, 104.0]}
+    assert cell_value(old, DESIGN, SAMPLES)[0] == pytest.approx(hypot(4.0, 6.0))
+    assert cell_value({"src": "area", "key": "cut_soil"}, {"cut_soil_area_m2": 1.5}) == (
+        1.5,
+        None,
+        False,
+    )
+
+
+def test_서버_조각_길_넓이_기본():
+    assert ground_runs(SAMPLES) == [
+        [(-10, 100.0), (-5, 100.0), (0, 100.0), (5, 100.0), (10, 100.0)]
+    ]
+    run = [(0.0, 0.0), (2.0, 0.0), (2.0, 2.0)]
+    assert sub_path(run, 3.0, 1.0) == [(2.0, 1.0), (2.0, 0.0), (1.0, 0.0)]
+    square = [
+        [(0.0, 0.0), (1.0, 0.0)],
+        [(1.0, 1.0), (1.0, 0.0)],
+        [(1.0, 1.0), (0.0, 1.0), (0.0, 0.0)],
+    ]
+    assert ring_area(square) == pytest.approx(1.0)
+    assert ring_area(square[:2]) is None
+    assert ring_area([*square, [(5.0, 5.0), (6.0, 6.0)]]) is None  # 남는 조각
diff --git a/resources/tester/test_211_1_inlet_revet_height.py b/resources/tester/test_211_1_inlet_revet_height.py
new file mode 100644
index 000000000..50fb28551
--- /dev/null
+++ b/resources/tester/test_211_1_inlet_revet_height.py
@@ -0,0 +1,219 @@
+"""211-1 관 보호공 **유입** 흙막이 빈 칸 기본 높이 = 관경(0.1 올림) + 0.7 — 유출 · 집수정은 + 0.5 그대로.
+
+못박는 것
+  - 파이썬 `pipe_wall_min_height_m(d, "inlet")` · 새 관 기본값(`_apply_new_defaults`) · 관 세트 스펙 · B08 집계 빈 높이.
+  - TS 짝 `buildCulvertSets` ↔ 파이썬 `_culvert_set`(유입 · 유출 스펙 같은 값) · 횡단도 `revetWallSpec`.
+  - 저장된 높이는 그대로 · 유출 · 집수정 무변 · 흙막이 아닌 시설(숨은 관)은 본체 높이 그대로.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from B04_PreProcess import B04_PreProcess_Router_Basins as basins
+from B05_Profile.B05_Profile_Structures_Schema import structure_type_map
+from B06_Section import B06_Section_Engine_Culvert as culvert
+from B08_Quantity import B08_Quantity_Router_Summary as summary
+from common_util.common_util_drainage_pipes import PipePoint
+from M02_MasterTemplete import M02_Item_Snapshot as snapshots
+from M02_MasterTemplete.StructOptions import M02_SO_Definition as definition
+
+ROOT = Path(__file__).resolve().parents[2]
+TSC = ROOT / "config" / "node_modules" / "typescript" / "bin" / "tsc"
+
+
+def _revet(side: str, height: float | None = None) -> dict:
+    found = {
+        f"{side}_type": "기슭막이",
+        f"{side}_revet_form": "돌쌓기(메)",
+        f"{side}_revet_before_m": 5,
+        f"{side}_revet_after_m": 5,
+    }
+    if height is not None:
+        found[f"{side}_revet_height_m"] = height
+    return found
+
+
+def test_파이썬_기본_높이_유입만_0_7():
+    h = culvert.pipe_wall_min_height_m
+    assert h(0.8, "inlet") == 1.5 and h(0.8, "outlet") == 1.3
+    assert h(1.2, "inlet") == 1.9 and h(1.2) == 1.7  # 쪽 안 줌 = 옛 값(집수정)
+    assert h(1.0, "inlet") == 1.7 and h(1.0, "outlet") == 1.5
+    assert h(0.45, "inlet") == 1.2  # 0.5 로 올림 + 0.7
+
+
+def test_새_관_기본값_유입_흙막이만_0_7():
+    fresh = PipePoint(chainage_m=10.0, source="stream", options={"pipe_diameter_mm": 1200})
+    basins._apply_new_defaults([fresh])
+    assert fresh.options["inlet_revet_height_m"] == pytest.approx(1.9)
+    assert fresh.options["outlet_revet_height_m"] == pytest.approx(1.7)
+    assert fresh.options["inlet_basin_height_m"] == pytest.approx(1.7)
+    # 이미 적은 높이(추천 · 손 값)는 그대로 · 나머지 칸만 채움
+    kept = PipePoint(
+        chainage_m=20.0,
+        source="stream",
+        options={"pipe_diameter_mm": 1200, "inlet_revet_height_m": 1.2},
+    )
+    basins._apply_new_defaults([kept])
+    assert kept.options["inlet_revet_height_m"] == 1.2
+    assert kept.options["outlet_revet_height_m"] == pytest.approx(1.7)
+
+
+def test_관_세트_빈_높이_유입_0_7_저장값_그대로():
+    blank = culvert._culvert_set({"pipe_diameter_mm": 1200, **_revet("inlet"), **_revet("outlet")})
+    assert blank["inlet"]["revet_height_m"] == pytest.approx(1.9)
+    assert blank["outlet"]["revet_height_m"] == pytest.approx(1.7)
+    stored = culvert._culvert_set(
+        {"pipe_diameter_mm": 1200, **_revet("inlet", 1.2), **_revet("outlet", 2.4)}
+    )
+    assert stored["inlet"]["revet_height_m"] == 1.2 and stored["outlet"]["revet_height_m"] == 2.4
+    # 옛 기본 1.5 · 관경 > 1.0 = 저장 값 해석(139-1) — 관경 + 0.5 그대로
+    legacy = culvert._culvert_set({"pipe_diameter_mm": 1200, **_revet("inlet", 1.5)})
+    assert legacy["inlet"]["revet_height_m"] == pytest.approx(1.7)
+
+
+_RUNNER = """
+import { readFileSync, writeFileSync } from "node:fs";
+import { buildCulvertSets } from "./common_util_culvert_sets.js";
+const input = JSON.parse(readFileSync(process.argv[2], "utf8"));
+const sets = buildCulvertSets(input.points, input.registry);
+writeFileSync(process.argv[3], JSON.stringify([...sets.entries()]));
+"""
+
+_WALL_RUNNER = """
+import { writeFileSync } from "node:fs";
+import { revetWallSpec } from "./B06_Section_UI_Cross_Culvert_Const.js";
+const pick = (spec, hidden, auto) => revetWallSpec(spec, {}, hidden, 1.2, auto).pureHeight;
+const base = { structure: "기슭막이" };
+writeFileSync(process.argv[2], JSON.stringify({
+  inlet: pick({ ...base, role: "inlet" }, false),
+  outlet: pick({ ...base, role: "outlet" }, false),
+  stored: pick({ ...base, role: "inlet", revet_height_m: 1.2 }, false),
+  hidden: pick({ ...base, role: "inlet" }, true, 2.0),
+}));
+"""
+
+
+def _tsc(source: Path, out: Path) -> None:
+    subprocess.run(  # noqa: S603 — 고정 실행 파일 · 타입 오류가 있어도 JS 는 나옴
+        [
+            "node",
+            str(TSC),
+            str(source),
+            "--outDir",
+            str(out),
+            "--module",
+            "esnext",
+            "--target",
+            "es2022",
+            "--moduleResolution",
+            "bundler",
+            "--skipLibCheck",
+            "--ignoreConfig",
+        ],
+        cwd=str(ROOT),
+        capture_output=True,
+    )
+
+
+@pytest.mark.skipif(not TSC.is_file(), reason="프론트엔드 의존성 미설치")
+def test_TS_세트_거울(tmp_path: Path) -> None:
+    points = [
+        {
+            "chainage_m": 20.0,
+            "facility": "pipe",
+            "options": {"pipe_diameter_mm": 1200, **_revet("inlet"), **_revet("outlet")},
+        },
+        {
+            "chainage_m": 40.0,
+            "facility": "pipe",
+            "options": {"pipe_diameter_mm": "800", **_revet("inlet", 1.2), **_revet("outlet")},
+        },
+        {
+            "chainage_m": 60.0,
+            "facility": "pipe",
+            "options": {"pipe_diameter_mm": 1200, **_revet("inlet", 1.5)},  # 옛 1.5
+        },
+    ]
+    registry = {
+        type_id: {o.key: o.default for o in entry.options}
+        for type_id, entry in structure_type_map().items()
+        if type_id in ("pipe", "ford_bridge", "ford_pavement", "box_culvert")
+    }
+    out = tmp_path / "js"
+    _tsc(ROOT / "common_util" / "common_util_culvert_sets.ts", out)
+    (out / "runner.mjs").write_text(_RUNNER, encoding="utf-8")
+    payload, result = tmp_path / "in.json", tmp_path / "out.json"
+    payload.write_text(json.dumps({"points": points, "registry": registry}), encoding="utf-8")
+    run = subprocess.run(  # noqa: S603
+        ["node", str(out / "runner.mjs"), str(payload), str(result)],
+        capture_output=True,
+        text=True,
+    )
+    assert run.returncode == 0, run.stderr[-2000:]
+    got = {at: spec for at, spec in json.loads(result.read_text(encoding="utf-8"))}
+    for point in points:
+        want = culvert._culvert_set(point["options"])
+        spec = got[point["chainage_m"]]
+        for side in ("inlet", "outlet"):
+            assert spec[side].get("revet_height_m") == want[side].get("revet_height_m"), point
+    assert got[20.0]["inlet"]["revet_height_m"] == pytest.approx(1.9)
+    assert got[20.0]["outlet"]["revet_height_m"] == pytest.approx(1.7)
+    assert got[40.0]["inlet"]["revet_height_m"] == 1.2  # 저장 값 그대로
+    assert got[40.0]["outlet"]["revet_height_m"] == pytest.approx(1.3)
+    assert got[60.0]["inlet"]["revet_height_m"] == pytest.approx(1.7)  # 옛 1.5 → 관경 + 0.5
+
+
+@pytest.mark.skipif(not TSC.is_file(), reason="프론트엔드 의존성 미설치")
+def test_횡단도_벽_기본_높이(tmp_path: Path) -> None:
+    out = tmp_path / "js"
+    _tsc(ROOT / "B06_Section" / "B06_Section_UI_Cross_Culvert_Const.ts", out)
+    built = next(
+        out.rglob("B06_Section_UI_Cross_Culvert_Const.js")
+    )  # 가져온 파일 따라 경로가 깊어짐
+    runner = built.parent / "runner.mjs"
+    runner.write_text(_WALL_RUNNER, encoding="utf-8")
+    result = tmp_path / "out.json"
+    run = subprocess.run(  # noqa: S603
+        ["node", str(runner), str(result)], capture_output=True, text=True
+    )
+    assert run.returncode == 0, run.stderr[-2000:]
+    got = json.loads(result.read_text(encoding="utf-8"))
+    assert got["inlet"] == pytest.approx(1.9)  # Φ1200 + 0.7
+    assert got["outlet"] == pytest.approx(1.7)  # 무변
+    assert got["stored"] == 1.2  # 칸 값 그대로
+    assert got["hidden"] == 2.0  # 숨은 관(세월교 · 박스) = 본체 높이 그대로
+
+
+def test_B08_집계_빈_높이_유입만_0_7(tmp_path: Path) -> None:
+    combo = {"layer": "system", "owner": None, "key": "SS000011", "name": "횡단배수 배관"}
+    root = tmp_path / "proj"
+    edits = root / "B04_PreProcess/drainage/edits"
+    edits.mkdir(parents=True)
+    point = {
+        "chainage_m": 1433.0,
+        "source": "user",
+        "options": {"pipe_diameter_mm": 800, **_revet("inlet"), **_revet("outlet")},
+        "summary_item": combo,
+        "group_items": {"gnbf9m9": combo, "g9lq9uk": combo},
+    }
+    (edits / "pipe_points.json").write_text(
+        json.dumps({"points": [point]}, ensure_ascii=False), encoding="utf-8"
+    )
+    designs = [
+        {
+            "chainage_m": 1433.0,
+            "design": {"pipe_length_m": 18, "inlet_basin": None, "extra_walls": []},
+        }
+    ]
+    names = definition.read()["종류"]["pipe"]["이름"]
+    linked = {owner: {} for owner in snapshots.assignments(root)}
+    out = summary.pipe_summary(root, designs, names, 6.0, linked=linked)
+    ids = [c["id"] for c in out["columns"] if c["id"].startswith("pipe:revet")]
+    assert ids == ["pipe:revet|돌쌓기(메)|1.3", "pipe:revet|돌쌓기(메)|1.5"], (
+        ids
+    )  # 유출 1.3 · 유입 1.5
diff --git a/resources/tester/test_212_3_b07_cross_layout_buttons.py b/resources/tester/test_212_3_b07_cross_layout_buttons.py
new file mode 100644
index 000000000..3b51c0f18
--- /dev/null
+++ b/resources/tester/test_212_3_b07_cross_layout_buttons.py
@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""212-3 B07 좌측 「횡단도」 배치 칸 — 단추 · 숫자 칸 한 규격 · 한 줄에 한 일 · 남는 검은 선 판정.
+
+못박는 것
+  - 줄 = 「배치 열 · 행」 · 「[이 장] [모든 장]」 · 「표 배율 [배율 적용]」
+    · [안내선 숨기기](부르는 쪽).
+  - 단추 · 숫자 칸 · 이름 = 줄 위 작은 단추 토큰(187 `--btn-bar-*` · 높이 16) · 한 줄 안 같은 너비.
+  - 옛 한 줄 감기(flex-wrap) · 숫자 칸 48px 고정 없음.
+  - [안내선 숨기기] 뒤 남는 검은 선 = 인쇄 칸선(도각 층 도면 개체 · 회청 `#8ea0b5`
+    · 밝은 바탕에서 짙게 그려짐) — 안내선(겹판)과 다른 것이라 지우지 않음 · 단추는 겹판만 끔.
+"""
+
+import re
+from pathlib import Path
+
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad import FRAME_LAYER_ID, TABLE_LINE_COLOR
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import _grid_lines
+from B07_DesignDetail.B07_DesignDetail_Engine_Template import use_project_templates
+
+ROOT = Path(__file__).resolve().parents[2]
+CSS = (ROOT / "B07_DesignDetail/B07_DesignDetail_UI_Style.css").read_text(encoding="utf-8")
+PANELS = (ROOT / "B07_DesignDetail/B07_DesignDetail_UI_Panels.ts").read_text(encoding="utf-8")
+PAGE = (ROOT / "B07_DesignDetail/B07_DesignDetail_UI_Page.ts").read_text(encoding="utf-8")
+GUIDE = (ROOT / "B07_DesignDetail/openwebcad/src/integration/guide-area.ts").read_text(
+    encoding="utf-8"
+)
+THEME = (ROOT / "ui_template/ui_template_theme.css").read_text(encoding="utf-8")
+
+
+def _block(selector: str) -> str:
+    m = re.search(r"(?:^|\n)" + re.escape(selector) + r"\s*\{([^}]*)\}", CSS)
+    assert m, selector
+    return m.group(1)
+
+
+def _decl(block: str, prop: str) -> str:
+    m = re.search(r"(?:^|;|\s)" + re.escape(prop) + r"\s*:\s*([^;]+);", block)
+    assert m, prop
+    return m.group(1).strip()
+
+
+def test_단추_숫자_칸_한_규격_토큰():
+    shared = _block(".b07-cross-layout .ui-btn,\n.b07-cross-layout .ui-field .ui-input")
+    assert _decl(shared, "padding") == "var(--btn-bar-padding)"
+    assert _decl(shared, "font-size") == "var(--btn-bar-font-size)"
+    assert _decl(shared, "line-height") == "1"
+    assert _decl(shared, "height") == "auto"  # 공용 작은 칸 30px 를 풀어 단추 높이에 맞춤
+    label = _block(".b07-cross-layout .ui-field__label")
+    assert _decl(label, "font-size") == "var(--btn-bar-font-size)"
+    # 토큰은 theme 한 곳(187)
+    assert "--btn-bar-padding: 1px var(--spacing-8);" in THEME
+    assert "--btn-bar-font-size: var(--text-caption);" in THEME
+
+
+def test_한_줄에_한_일_같은_너비():
+    box = _block(".b07-cross-layout")
+    assert _decl(box, "flex-direction") == "column"
+    assert "flex-wrap" not in box
+    assert _decl(_block(".b07-cross-layout__row > *"), "flex") == "1 1 0"
+    assert "width: 48px" not in CSS
+    assert 'line.className = "b07-cross-layout__row"' in PANELS
+    assert "row(cols.root, rows.root)" in PANELS
+    assert re.search(r"row\(\s*action\(\"이 장\"[^;]*action\(\"모든 장\"", PANELS, re.S)
+    assert "box.append(row(scale.root, button));" in PANELS
+    # 안내선 단추 = 배치 칸 맨 아래 한 줄(전체 폭)
+    assert "controls.append(guideToggle);" in PAGE
+
+
+def test_남는_검은_선은_인쇄_칸선_지우지_않음():
+    use_project_templates(None)
+    lines = _grid_lines("cross_s00000m", 4, 4)
+    assert len(lines) == 10  # 세로 5 · 가로 5 그대로
+    assert all(e["layerId"] == FRAME_LAYER_ID for e in lines)
+    assert all(e["lineColor"] == TABLE_LINE_COLOR == "#8ea0b5" for e in lines)
+    # 안내선 단추는 겹판(점선 영역 + 붉은 틀)만 — 도면 개체를 안 건드림
+    draw = GUIDE[GUIDE.index("export function drawGuide") :]
+    draw = draw[: draw.index("\n}\n")]
+    assert "if (!guide || !guideVisible) return;" in draw
+    assert "getEntities" not in draw and "setEntities" not in draw
diff --git a/resources/tester/test_212_b07_cross_station_layers.py b/resources/tester/test_212_b07_cross_station_layers.py
new file mode 100644
index 000000000..baa293a31
--- /dev/null
+++ b/resources/tester/test_212_b07_cross_station_layers.py
@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""212-1 · 212-2 B07 횡단 장 — 원지반 고르기 · 측점별 도면층.
+
+못박는 것
+  - 212-1 옛 확정 장(원지반 층 잠금째 저장)도 열 때 원지반 잠금 풂 · 측점 층 없으면 stale_layers.
+  - 212-2 장의 측점마다 층 하나(`b08-station-{측점}` · 이름 「횡단 {제목}」) = 원지반 · 계획선 ·
+    암 그림(자식 선까지) · 표 · 글은 수량표 층 · 격자선 · 도각은 도각 층 · 종류 층 없음.
+  - 개체 id 는 그대로(층만 바뀜) · placement 에 layer_id · design_ids(화면 덧그림 갈아 끼우기).
+  - DXF 층 이름 = 측점 층 id 그대로(금지 문자 없음).
+  - 화면 덧그림도 측점 층 · design_ids 로 서버 설계선 걷음(소스 확인 · typecheck 는 따로).
+"""
+
+import json
+from pathlib import Path
+from uuid import uuid5
+
+import ezdxf
+
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad import (
+    _POLY_NS,
+    CROSS_TABLE_LAYER_ID,
+    DESIGN_COLOR,
+    DESIGN_LAYER_ID,
+    DRAWING_FORMAT,
+    FRAME_LAYER_ID,
+    GROUND_COLOR,
+    GROUND_LAYER_ID,
+    ROCK_LAYER_ID,
+    STRUCTURE_LAYER_ID,
+)
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import (
+    STATION_LAYER_PREFIX,
+    build_cross_sheet,
+    plan_cross_sheets,
+)
+from B07_DesignDetail.B07_DesignDetail_Engine_Frame_Export import _layer_name, drawing_to_dxf
+from B07_DesignDetail.B07_DesignDetail_Engine_Template import use_project_templates
+from B07_DesignDetail.B07_DesignDetail_Router_Support import CROSS_SHEET_LAYOUT, _read_drawing
+
+ROOT = Path(__file__).resolve().parents[2]
+KIND_LAYERS = {GROUND_LAYER_ID, DESIGN_LAYER_ID, STRUCTURE_LAYER_ID, ROCK_LAYER_ID}
+
+
+def _source(chainage: float) -> dict:
+    return {
+        "chainage_m": chainage,
+        "samples": [
+            {"valid": True, "offset_m": float(x), "elevation_m": 100.0 + 0.1 * x}
+            for x in range(-5, 6)
+        ],
+    }
+
+
+def _sheet() -> tuple[dict, dict]:
+    use_project_templates(None)
+    chainages = [0.0, 20.0, 40.0, 60.0]
+    sheet = plan_cross_sheets(chainages, {"default": [2, 2]})[0]
+    sections = [
+        {
+            "chainage": c,
+            "source": _source(c),
+            # 암 지반 = 암 경계선도 측점 층으로
+            "design": {"rock_boundary_offset_m": -1.0} if c == 20.0 else None,
+            "design_line": [{"offset_m": x, "elevation_m": 100.0} for x in (-3.0, 0.0, 3.0)],
+            "quantity_table": {"ground": 1.0, "planned": 0.5},
+            "title": f"No.{int(c // 20)}",
+        }
+        for c in chainages
+    ]
+    return sheet, build_cross_sheet(sheet, sections)
+
+
+def _flat(entities: list[dict]) -> list[dict]:
+    out = []
+    for entity in entities:
+        out.append(entity)
+        out.extend(_flat(entity.get("children") or []))
+    return out
+
+
+def test_측점마다_층_하나_이름_횡단_No():
+    _sheet_, drawing = _sheet()
+    layers = drawing["layers"]
+    ids = [layer["id"] for layer in layers]
+    assert ids[:4] == [f"{STATION_LAYER_PREFIX}{c}" for c in (0.0, 20.0, 40.0, 60.0)]
+    assert [layer["name"] for layer in layers[:4]] == [
+        "횡단 No.0",
+        "횡단 No.1",
+        "횡단 No.2",
+        "횡단 No.3",
+    ]
+    assert ids[4:] == [CROSS_TABLE_LAYER_ID, FRAME_LAYER_ID]
+    assert not KIND_LAYERS & set(ids)  # 종류 층 없음 — 빈 층이 안 남음
+    assert all(layer["isVisible"] and not layer["isLocked"] for layer in layers[:4])
+
+
+def test_그림은_측점_층_표_글은_수량표_층_격자는_도각():
+    _sheet_, drawing = _sheet()
+    flat = _flat(drawing["entities"])
+    assert not any(e["layerId"] in KIND_LAYERS for e in flat)  # 자식 선까지
+    by_layer: dict[str, list[dict]] = {}
+    for entity in drawing["entities"]:
+        by_layer.setdefault(entity["layerId"], []).append(entity)
+    for chainage in (0.0, 20.0, 40.0, 60.0):
+        members = by_layer[f"{STATION_LAYER_PREFIX}{chainage}"]
+        colors = {e["lineColor"] for e in members}
+        assert GROUND_COLOR in colors and DESIGN_COLOR in colors
+        assert all(e["type"] == "PolyLine" for e in members)
+        assert len({e["groupId"] for e in members}) == 1  # 180-1 groupId 그대로
+    # 암 지반 측점만 점선 암 경계선(종류 = 선 꼴)
+    rock = [e for e in by_layer[f"{STATION_LAYER_PREFIX}20.0"] if e.get("lineDash")]
+    assert len(rock) == 1
+    assert not any(e.get("lineDash") for e in by_layer[f"{STATION_LAYER_PREFIX}0.0"])
+    assert {e["type"] for e in by_layer[CROSS_TABLE_LAYER_ID]} <= {"Table", "Text"}
+    assert all("groupId" not in e for e in by_layer[FRAME_LAYER_ID])
+
+
+def test_id_그대로_placement_layer_id_design_ids():
+    sheet, drawing = _sheet()
+    by_id = {e["id"]: e for e in drawing["entities"]}
+    for placement in drawing["cross_placements"]:
+        chainage = placement["chainage_m"]
+        layer_id = f"{STATION_LAYER_PREFIX}{chainage}"
+        assert placement["layer_id"] == layer_id
+        seed = f"{sheet['id']}:{chainage}"
+        # 개체 id 는 종류 층 씨앗 그대로 — 저장본 · 덧그림 짝이 안 흔들림
+        ground = by_id[str(uuid5(_POLY_NS, f"{seed}:{GROUND_LAYER_ID}"))]
+        assert ground["layerId"] == layer_id and ground["lineColor"] == GROUND_COLOR
+        design_ids = placement["design_ids"]
+        assert design_ids == [str(uuid5(_POLY_NS, f"{seed}:{DESIGN_LAYER_ID}"))]
+        assert all(by_id[i]["lineColor"] == DESIGN_COLOR for i in design_ids)
+
+
+def test_DXF_층_이름_측점_층_id(tmp_path: Path):
+    _sheet_, drawing = _sheet()
+    for layer in drawing["layers"]:
+        assert _layer_name(layer["id"]) == layer["id"]
+    data, _skipped = drawing_to_dxf(drawing)
+    (tmp_path / "sheet.dxf").write_bytes(data)
+    names = {layer.dxf.name for layer in ezdxf.readfile(tmp_path / "sheet.dxf").layers}
+    assert {f"{STATION_LAYER_PREFIX}{c}" for c in (0.0, 20.0, 40.0, 60.0)} <= names
+    assert not KIND_LAYERS & names
+
+
+def test_옛_확정_장_원지반_잠금_풂_측점_층_안내(tmp_path: Path):
+    stage = tmp_path / "B07_DesignDetail"
+    (stage / "drawings").mkdir(parents=True)
+    layers = [
+        {"id": GROUND_LAYER_ID, "name": "원지반", "isVisible": True, "isLocked": True},
+        {"id": FRAME_LAYER_ID, "name": "도각", "isVisible": True, "isLocked": True},
+    ]
+    saved = {"format": DRAWING_FORMAT, "entities": [], "layers": layers}
+    path = stage / "drawings" / "cross_s00000m.json"
+    path.write_text(json.dumps(saved), encoding="utf-8")
+    entry = {"kind": "cross", "label": "1장", "confirmed": True, "layout": CROSS_SHEET_LAYOUT}
+    (stage / "manifest.json").write_text(
+        json.dumps({"drawings": {"cross_s00000m": entry}}), encoding="utf-8"
+    )
+
+    def read() -> dict:
+        _k, _l, drawing, confirmed, _t = _read_drawing(
+            tmp_path, tmp_path / "x.json", "cross_s00000m"
+        )
+        assert confirmed
+        return drawing
+
+    drawing = read()
+    locked = {layer["id"]: layer["isLocked"] for layer in drawing["layers"]}
+    assert locked == {GROUND_LAYER_ID: False, FRAME_LAYER_ID: True}  # 도각은 그대로 잠금
+    assert drawing.get("stale_layers") is True
+    # 측점 층으로 확정한 장은 안내 없음
+    saved["layers"] = [{"id": f"{STATION_LAYER_PREFIX}0", "name": "횡단 No.0"}, layers[1]]
+    path.write_text(json.dumps(saved), encoding="utf-8")
+    assert "stale_layers" not in read()
+
+
+def test_화면_덧그림_측점_층_design_ids():
+    struct = (ROOT / "B07_DesignDetail/B07_DesignDetail_UI_Cad_Structures.ts").read_text(
+        encoding="utf-8"
+    )
+    assert "layer_id?: string;" in struct and "design_ids?: string[];" in struct
+    assert "moveToLayer(entity, placement.layer_id)" in struct
+    assert "!designIds.has(entity.id as string)" in struct
+    page = (ROOT / "B07_DesignDetail/B07_DesignDetail_UI_Page.ts").read_text(encoding="utf-8")
+    assert "response.drawing.stale_layers" in page
diff --git a/resources/tester/test_213_1_hidden_station_pvi.py b/resources/tester/test_213_1_hidden_station_pvi.py
new file mode 100644
index 000000000..4e5480c8c
--- /dev/null
+++ b/resources/tester/test_213_1_hidden_station_pvi.py
@@ -0,0 +1,214 @@
+"""213-1 — 한 자리에 측점 둘이 숨는 흠(엄상준_검증 d2245e3b · No.13+3).
+
+까닭: 자동설계 관 측점 263.206(0.001m) → 화면 저장이 관을 0.01m 로 반올림(263.21) → 측점은
+263.21 로 다시 섰는데 계획선 꼭짓점(base_pvi) · 편집 키는 옛 글자 「263.206」 그대로 → 새 측점
+편집 「263.210」과 0.004m 사이 두 꼭짓점(−15003% 계단).
+고침: 계획선 공용 함수(파이썬 `snap_to_stations` ↔ TS `snapToStations`)가 측점 0.006m 안의
+꼭짓점 · 편집 키를 그 측점으로 모음(측점 위 것이 이김 · 측점 계획고 그대로) · 192 병합도
+옛 글자를 같은 측점으로 봄. 사용자 storage 는 읽기만 — 사본(tmp_path).
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from B05_Profile.B05_Profile_Engine_Grade_Alignment import (  # noqa: E402
+    AlignmentPolicy,
+    build_alignment,
+)
+from B05_Profile.B05_Profile_Engine_Grade_Profile import rebuild_alignment_profile  # noqa: E402
+from B05_Profile.B05_Profile_Router_Confirm import _merge_irregular_into_longitudinal  # noqa: E402
+
+TSC = PROJECT_ROOT / "config" / "node_modules" / "typescript" / "bin" / "tsc"
+SOURCE = (
+    PROJECT_ROOT
+    / "storage/1/3/d2245e3b-0468-4a90-ac5c-50b2adcb56e7/B06_Section/longitudinal/longitudinal.json"
+)
+REL = "B06_Section/longitudinal/longitudinal.json"
+needs_copy = pytest.mark.skipif(not SOURCE.is_file(), reason="엄상준_검증 storage 없음")
+
+# 합성 — 격자 20m · 관 측점 263.206 → 263.21 반올림 · 끝 꼭짓점 1000.0(끝 측점 999.998)
+STATIONS = [0.0, 20.0, 40.0, 263.21, 280.0, 300.0, 999.998]
+BASE = [
+    (0.0, 100.0),
+    (20.0, 99.0),
+    (40.0, 98.5),
+    (263.206, 90.0),
+    (280.0, 89.0),
+    (300.0, 88.0),
+    (1000.0, 60.0),
+]
+EDITS = {
+    "station_offsets": {"263.206": 1.5, "263.210": 0.9, "40.000": 0.2, "500.000": 0.3},
+    "curve_radii": {"263.206": 300.0},
+}
+
+
+def _synthetic() -> dict:
+    chainage = np.arange(0.0, 1000.0, 1.0)
+    return {
+        "base_s": np.array([s for s, _ in BASE]),
+        "base_z": np.array([z for _, z in BASE]),
+        "chainage": np.r_[chainage, 1000.0],
+        "ground": np.r_[100.0 - chainage * 0.04, 60.0],
+        "stations": [
+            {"station_id": f"st{index}", "chainage_m": value}
+            for index, value in enumerate(STATIONS)
+        ],
+    }
+
+
+def _python(edits: dict) -> dict:
+    data = _synthetic()
+    return build_alignment(**data, policy=AlignmentPolicy.from_dict({}), edits=copy.deepcopy(edits))
+
+
+def _close_pairs(alignment: dict, limit: float = 0.006) -> list[tuple[float, float]]:
+    pvi = [node["chainage_m"] for node in alignment["pvi"]]
+    return [(a, b) for a, b in zip(pvi, pvi[1:], strict=False) if b - a < limit]
+
+
+def test_rounded_station_keys_collapse_onto_station():
+    alignment = _python(EDITS)
+    pvi = {round(node["chainage_m"], 3): node for node in alignment["pvi"]}
+    assert _close_pairs(alignment) == []
+    assert 263.206 not in pvi and 263.21 in pvi
+    # 측점 위 편집(263.210 = 0.9)이 이김 · 반경도 측점으로 옮김 · 측점에서 먼 키(500)는 그대로
+    assert alignment["edits"]["station_offsets"] == {"263.210": 0.9, "40.000": 0.2, "500.000": 0.3}
+    assert alignment["edits"]["curve_radii"] == {"263.210": 300.0}
+    # 양 끝 꼭짓점은 그대로(끝 1000.0 을 측점 999.998 로 당기지 않음)
+    assert [node["chainage_m"] for node in alignment["base_pvi"]][-1] == 1000.0
+    assert max(abs(segment["grade_percent"]) for segment in alignment["segments"]) < 100
+
+
+def test_snapped_base_keeps_station_elevation():
+    """편집 없는 측점 — 꼭짓점을 측점으로 옮겨도 그 측점 계획고(탄젠트)는 그대로."""
+    alignment = _python({"station_offsets": {}, "curve_radii": {}})
+    node = next(n for n in alignment["base_pvi"] if abs(n["chainage_m"] - 263.21) < 1e-9)
+    expected = float(np.interp(263.21, [s for s, _ in BASE], [z for _, z in BASE]))
+    assert node["elevation_m"] == pytest.approx(expected, abs=1e-6)
+
+
+_RUNNER = """
+import { readFileSync, writeFileSync } from "node:fs";
+import { buildAlignment } from "./B05_Profile_UI_Profile_Alignment.js";
+const input = JSON.parse(readFileSync(process.argv[2], "utf8"));
+const result = buildAlignment(input.base, input.edits);
+writeFileSync(process.argv[3], JSON.stringify(result));
+"""
+
+
+@pytest.fixture(scope="module")
+def ts_alignment(tmp_path_factory):
+    if not TSC.is_file():
+        pytest.skip("프론트엔드 의존성 미설치")
+    tmp = tmp_path_factory.mktemp("align213")
+    out = tmp / "js"
+    subprocess.run(  # noqa: S603 — 고정 실행 파일
+        [
+            "node",
+            str(TSC),
+            str(PROJECT_ROOT / "B05_Profile" / "B05_Profile_UI_Profile_Alignment.ts"),
+            "--outDir",
+            str(out),
+            "--module",
+            "esnext",
+            "--target",
+            "es2022",
+            "--moduleResolution",
+            "bundler",
+            "--ignoreConfig",
+        ],
+        cwd=str(PROJECT_ROOT),
+        check=True,
+        capture_output=True,
+    )
+    (out / "runner.mjs").write_text(_RUNNER, encoding="utf-8")
+    data = _synthetic()
+    base = {
+        "policy": AlignmentPolicy.from_dict({}).as_dict(),
+        "onlyExplicitCurves": False,
+        "basePvi": [{"chainage_m": s, "elevation_m": z} for s, z in BASE],
+        "chainage": data["chainage"].tolist(),
+        "ground": data["ground"].tolist(),
+        "stations": data["stations"],
+    }
+    src, dst = tmp / "in.json", tmp / "out.json"
+    src.write_text(json.dumps({"base": base, "edits": EDITS}), encoding="utf-8")
+    subprocess.run(  # noqa: S603
+        ["node", str(out / "runner.mjs"), str(src), str(dst)], check=True, capture_output=True
+    )
+    return json.loads(dst.read_text(encoding="utf-8"))
+
+
+def test_mirror_python_ts(ts_alignment):
+    py = _python(EDITS)
+    ts = ts_alignment
+    assert ts["edits"] == py["edits"]
+    assert len(ts["base_pvi"]) == len(py["base_pvi"])
+    for a, b in zip(ts["base_pvi"], py["base_pvi"], strict=True):
+        assert a["chainage_m"] == pytest.approx(b["chainage_m"], abs=1e-6)
+        assert a["elevation_m"] == pytest.approx(b["elevation_m"], abs=1e-6)
+    assert [n["chainage_m"] for n in ts["pvi"]] == pytest.approx(
+        [n["chainage_m"] for n in py["pvi"]], abs=1e-6
+    )
+    assert [n["elevation_m"] for n in ts["pvi"]] == pytest.approx(
+        [n["elevation_m"] for n in py["pvi"]], abs=1e-6
+    )
+    for a, b in zip(ts["stations"], py["stations"], strict=True):
+        assert a["plan_elevation_m"] == pytest.approx(b["plan_elevation_m"], abs=1e-6)
+
+
+def _copy(tmp_path: Path) -> Path:
+    target = tmp_path / REL
+    target.parent.mkdir(parents=True)
+    shutil.copyfile(SOURCE, target)
+    return target
+
+
+@needs_copy
+def test_d2245e3b_no13_3_spike_gone(tmp_path):
+    data = json.loads(_copy(tmp_path).read_text(encoding="utf-8"))
+    edits = data["profile_alignment"]["edits"]
+    assert {"263.206", "263.210"} <= set(edits["station_offsets"])  # 재현 조건
+    alignment, _ = rebuild_alignment_profile(data, edits)
+    assert _close_pairs(alignment) == []
+    assert "263.206" not in alignment["edits"]["station_offsets"]
+    assert max(abs(segment["grade_percent"]) for segment in alignment["segments"]) < 100
+
+
+@needs_copy
+def test_d2245e3b_station_regen_drops_rounded_key(tmp_path):
+    """[측점 만들기] 로 관 측점 263.21 → 263.31 — 옛 글자 263.206 꼭짓점 · 편집도 함께 지워짐."""
+    path = _copy(tmp_path)
+    data = json.loads(path.read_text(encoding="utf-8"))
+    irregular = []
+    for station in data["stations"]:
+        if station.get("kind") != "irregular":
+            continue
+        item = copy.deepcopy(station)
+        if abs(item["chainage_m"] - 263.21) < 1e-6:
+            item["chainage_m"] = 263.31
+        irregular.append(item)
+    _merge_irregular_into_longitudinal(tmp_path, REL, irregular)
+    saved = json.loads(path.read_text(encoding="utf-8"))["profile_alignment"]
+    leftovers = [
+        value
+        for value in [n["chainage_m"] for n in saved["base_pvi"]]
+        + [float(key) for key in saved["edits"]["station_offsets"]]
+        if 263.2 < value < 263.22
+    ]
+    assert leftovers == []
+    assert _close_pairs(saved, 0.05) == []
diff --git a/resources/tester/test_213_2_ghost_edit_drop.py b/resources/tester/test_213_2_ghost_edit_drop.py
new file mode 100644
index 000000000..71f63b77f
--- /dev/null
+++ b/resources/tester/test_213_2_ghost_edit_drop.py
@@ -0,0 +1,183 @@
+"""213-2 — 유령 계획고 편집 근본 막음.
+
+① 관을 옮기면 편집 키가 새 자리로 따라감 — 화면 `followedStation`
+   (B05_Profile_UI_Profile_Alignment.ts · B05 applyIrregularStations) ·
+   B06 movePipeTo 는 resetStationEdit(옛, 새).
+② [저장] 때 서버가 측점 · 관 · 구조물 자리 어디에도 없는 편집 키를 버리고 자리 목록을 돌려줌
+   (`drop_unplaced_edits` · `_apply_alignment_edits(marks=...)`).
+자료 = 고정 사본(fixtures/b05_192_1_moved_pipe_longitudinal.json · 226fc805 종단 460~840m).
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from B05_Profile.B05_Profile_Engine_Grade_Alignment import drop_unplaced_edits  # noqa: E402
+from B05_Profile.B05_Profile_Router import _apply_alignment_edits  # noqa: E402
+
+TSC = PROJECT_ROOT / "config" / "node_modules" / "typescript" / "bin" / "tsc"
+FIXTURE = PROJECT_ROOT / "resources/tester/fixtures/b05_192_1_moved_pipe_longitudinal.json"
+REL = "B06_Section/longitudinal/longitudinal.json"
+GHOST = {"station_offsets": {"769.280": 0.506058, "769.380": 0.051428}, "curve_radii": {}}
+
+
+def test_drop_keeps_station_and_marks_only():
+    edits = {
+        "station_offsets": {"20.000": 1.0, "263.206": 0.5, "263.310": 0.9, "400.000": 0.2},
+        "curve_radii": {"263.206": 300.0, "500.000": 80.0},
+    }
+    kept, dropped = drop_unplaced_edits(edits, np.array([0.0, 20.0, 263.21, 263.31]))
+    # 263.206 = 측점 263.21 의 0.006m 안(반올림) · 263.31 = 관 자리 → 남음
+    assert kept["station_offsets"] == {"20.000": 1.0, "263.206": 0.5, "263.310": 0.9}
+    assert kept["curve_radii"] == {"263.206": 300.0}
+    assert dropped == [400.0, 500.0]
+
+
+def _project(tmp_path: Path, station_m: float) -> Path:
+    """고정 사본 — 측점 769.28(옮긴 관, 측점 안 다시 뜸) 또는 769.38(다시 뜸 · 옛 꼭짓점 없음)."""
+    data = json.loads(FIXTURE.read_text(encoding="utf-8"))
+    if station_m != 769.28:
+        for station in data["stations"]:
+            if abs(station["chainage_m"] - 769.28) < 1e-6:
+                station.update(chainage_m=station_m, station_id="station_000000769380")
+        base = data["profile_alignment"]["base_pvi"]
+        data["profile_alignment"]["base_pvi"] = [
+            node for node in base if abs(node["chainage_m"] - 769.28) > 1e-6
+        ]
+    target = tmp_path / REL
+    target.parent.mkdir(parents=True)
+    target.write_text(json.dumps(data), encoding="utf-8")
+    return target
+
+
+def test_save_drops_ghost_after_station_regenerated(tmp_path):
+    """226fc805 꼴 — 측점 769.38 로 다시 섰는데 세션 초안이 옛 키 769.280 을 다시 보냄."""
+    path = _project(tmp_path, 769.38)
+    alignment, summary, dropped = _apply_alignment_edits(tmp_path, REL, GHOST, [769.38])
+    assert dropped == [769.28]
+    assert alignment["edits"]["station_offsets"] == {"769.380": 0.051428}
+    near = [p["chainage_m"] for p in alignment["pvi"] if 760 < p["chainage_m"] < 780]
+    assert near == [769.38]
+    assert summary["max_grade_pct"] < 100
+    saved = json.loads(path.read_text(encoding="utf-8"))["profile_alignment"]
+    assert "769.280" not in saved["edits"]["station_offsets"]
+
+
+def test_save_keeps_moved_pipe_edit_before_regeneration(tmp_path):
+    """관만 옮기고 측점은 옛 자리(769.28) — 옛 측점 편집 · 새 관 자리 편집 둘 다 지킴."""
+    _project(tmp_path, 769.28)
+    alignment, _, dropped = _apply_alignment_edits(tmp_path, REL, GHOST, [769.38])
+    assert dropped == []
+    assert set(alignment["edits"]["station_offsets"]) == {"769.280", "769.380"}
+
+
+def test_save_without_marks_drops_nothing(tmp_path):
+    """노선이 안 맞아 관 · 구조물 자리를 못 읽으면 버리지 않음(잃는 쪽보다 남는 쪽)."""
+    _project(tmp_path, 769.38)
+    _, _, dropped = _apply_alignment_edits(tmp_path, REL, GHOST, None)
+    assert dropped == []
+
+
+_RUNNER = """
+import { readFileSync, writeFileSync } from "node:fs";
+import { followedStation } from "./B05_Profile_UI_Profile_Alignment.js";
+const cases = JSON.parse(readFileSync(process.argv[2], "utf8"));
+const out = cases.map((c) => followedStation(c.station, c.gone, c.born)?.chainage_m ?? null);
+writeFileSync(process.argv[3], JSON.stringify(out));
+"""
+
+ST = lambda sid, m: {"id": sid, "chainage_m": m}  # noqa: E731
+CASES = [
+    # 옮긴 관 하나(키 한 번 +0.1) → 따라감
+    (
+        {
+            "station": ST("pipe-263.21", 263.21),
+            "gone": [ST("pipe-263.21", 263.21)],
+            "born": [ST("pipe-263.31", 263.31)],
+        },
+        263.31,
+    ),
+    # 반올림(263.206 → 263.21) → 따라감
+    (
+        {
+            "station": ST("pipe-263.21", 263.206),
+            "gone": [ST("pipe-263.21", 263.206)],
+            "born": [ST("pipe-263.21", 263.21)],
+        },
+        263.21,
+    ),
+    # A군 구조물 = 같은 id 로
+    (
+        {
+            "station": ST("s1", 100.0),
+            "gone": [ST("s1", 100.0), ST("pipe-5.00", 5.0)],
+            "born": [ST("pipe-9.00", 9.0), ST("s1", 130.0)],
+        },
+        130.0,
+    ),
+    # 둘이 한꺼번에 바뀜(지움 + 새로 놓음 둘) → 안 따라감(지움)
+    (
+        {
+            "station": ST("pipe-5.00", 5.0),
+            "gone": [ST("pipe-5.00", 5.0), ST("pipe-7.00", 7.0)],
+            "born": [ST("pipe-50.00", 50.0), ST("pipe-70.00", 70.0)],
+        },
+        None,
+    ),
+    # 지우기만 → 지움
+    ({"station": ST("pipe-5.00", 5.0), "gone": [ST("pipe-5.00", 5.0)], "born": []}, None),
+]
+
+
+def test_followed_station_ts(tmp_path):
+    if not TSC.is_file():
+        pytest.skip("프론트엔드 의존성 미설치")
+    out = tmp_path / "js"
+    subprocess.run(  # noqa: S603 — 고정 실행 파일
+        [
+            "node",
+            str(TSC),
+            str(PROJECT_ROOT / "B05_Profile" / "B05_Profile_UI_Profile_Alignment.ts"),
+            "--outDir",
+            str(out),
+            "--module",
+            "esnext",
+            "--target",
+            "es2022",
+            "--moduleResolution",
+            "bundler",
+            "--ignoreConfig",
+        ],
+        cwd=str(PROJECT_ROOT),
+        check=True,
+        capture_output=True,
+    )
+    (out / "runner.mjs").write_text(_RUNNER, encoding="utf-8")
+    src, dst = tmp_path / "in.json", tmp_path / "out.json"
+    src.write_text(json.dumps([case for case, _ in CASES]), encoding="utf-8")
+    subprocess.run(  # noqa: S603
+        ["node", str(out / "runner.mjs"), str(src), str(dst)], check=True, capture_output=True
+    )
+    assert json.loads(dst.read_text(encoding="utf-8")) == [want for _, want in CASES]
+
+
+def test_move_sites_follow_edits():
+    """옮김 자리 둘이 편집을 따라 옮김 — B06 movePipeTo · B05 측점 갱신(문자열 짝 확인)."""
+    b06 = (PROJECT_ROOT / "B06_Section/B06_Section_UI_Page_Structures_Panel.ts").read_text(
+        encoding="utf-8"
+    )
+    b05 = (PROJECT_ROOT / "B05_Profile/B05_Profile_UI_Page_Structures.ts").read_text(
+        encoding="utf-8"
+    )
+    assert "deps.shared.profile?.resetStationEdit(hit.chainage_m, to)" in b06
+    assert "followedStation(station, gone, born)" in b05
diff --git a/resources/tester/test_215_1_free_profile.py b/resources/tester/test_215_1_free_profile.py
new file mode 100644
index 000000000..2a4133378
--- /dev/null
+++ b/resources/tester/test_215_1_free_profile.py
@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""215-1 B05 종단 [자유지정] — 범위 고르고 클릭으로 계획선 잇기.
+
+계산 · 상태(`A00_Common/design/design_profile_free.ts`)는 Node 헬퍼
+(`helper_215_1_free_profile.cjs`)가 트랜스파일해 돌리고, 화면 배선(도구줄 단추 · 오버레이 ·
+키 · 적용 길)은 소스로 본다.
+"""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent.parent
+
+
+def _read(relative: str) -> str:
+    return (ROOT / relative).read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="module")
+def out():
+    proc = subprocess.run(
+        ["node", os.path.join(HERE, "helper_215_1_free_profile.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["yAt103_2"] == pytest.approx(121.6)
+    assert out["zBack"] == pytest.approx(103.2)
+    assert out["parsed"] == {"scale": 1.2, "offset": -20}
+    assert out["parsedNone"] == {"scale": 1, "offset": 0}
+
+
+def test_세로선_붙음_범위_안만(out):
+    assert out["snap79"] == 80
+    assert out["snapOutside"] == 160
+
+
+def test_범위_고르기_강조(out):
+    assert out["pendingEdges"] == [40]
+    assert out["rangePhase"] == "armed"
+    assert out["band"] == [40, 160]
+    assert out["stillArmed"] == "armed"  # 가운데 클릭은 시작이 아님
+
+
+def test_시작_이음_지금_계획고(out):
+    assert out["startPhase"] == "drawing"
+    assert out["startDot"] == {"chainage_m": 40, "elevation_m": pytest.approx(100.6)}
+
+
+def test_클릭_점_세로선_붙음_높이(out):
+    assert out["point1"] == {"chainage_m": 80, "elevation_m": pytest.approx(103.46)}
+    assert out["dotsAfterBack"] == 2  # 뒤로 가는 클릭은 무시
+
+
+def test_점선_미리_보기_기울기_글(out):
+    first, last = out["preview"]
+    assert (first["preview"], last["preview"]) == (False, True)
+    assert last["to"] == {"chainage_m": 120, "elevation_m": pytest.approx(101.2)}
+    assert first["grade"] == pytest.approx(7.15)
+    assert last["grade"] == pytest.approx(-5.65)
+    assert not first["over"] and not last["over"]
+
+
+def test_기준_넘음_빨강(out):
+    assert out["steep"]["over"] is True
+    assert abs(out["steep"]["grade"]) > 14
+
+
+def test_끝_이음과_적용_편집(out):
+    assert out["finishPreview"] == {"chainage_m": 160, "elevation_m": pytest.approx(102.4)}
+    assert out["appliedCount"] == 1 and out["closed"] == 1 and out["afterPhase"] == "range"
+    assert out["offsetKeys"] == ["100.000", "120.000", "140.000", "60.000", "80.000"]
+    pvi = out["pvi"]
+    assert pvi["40"] == pytest.approx(out["ground"]["40"])  # 양 끝 그대로
+    assert pvi["160"] == pytest.approx(out["ground"]["160"])
+    assert pvi["80"] == pytest.approx(103.46)
+    assert pvi["120"] == pytest.approx(101.2)
+    assert pvi["60"] == pytest.approx((100.6 + 103.46) / 2)  # 점 사이 = 직선
+    assert pvi["140"] == pytest.approx((101.2 + 102.4) / 2)
+    assert out["outsideUntouched"] is True
+
+
+def test_종단곡선_자동(out):
+    assert out["radiiKeys"] == ["120.000", "80.000"]
+    assert out["r80"] == pytest.approx(out["expectR80"])
+    assert out["curve80L"] == pytest.approx(20)  # 정책 기본 길이 L
+
+
+def test_Enter_끝_거꾸로_시작(out):
+    assert out["reverseAnchor"] == 160
+    assert out["enter"] is True and out["enterApplied"] == 1
+    pvi = out["enterPvi"]
+    assert pvi["40"] == pytest.approx(100.6) and pvi["160"] == pytest.approx(102.4)
+    assert pvi["100"] == pytest.approx(104)
+    assert pvi["60"] == pytest.approx(100.6 + (104 - 100.6) / 3, abs=1e-5)
+
+
+def test_Backspace_와_Esc_취소(out):
+    assert out["afterBackspace"] == [40, 80]
+    assert out["backspaceToArmed"] == "armed"
+    assert out["escape"] is True
+    assert out["escApplied"] == 0 and out["escClosed"] == 1
+    assert out["escPhase"] == "range" and out["escDots"] == 0
+    assert out["enterOutsideDrawing"] is False
+
+
+def test_도구줄_직선화_오른쪽_자유지정():
+    tools = _read("B05_Profile/B05_Profile_UI_Profile_Tools.ts")
+    assert '"자유지정"' in tools
+    assert "wrap.append(reset, undo, redo, straighten, free, shift, up, down)" in tools
+    assert 'className = "b05-route-profile__tool"' in tools  # 같은 단추 양식
+
+
+def test_적용은_직선화와_같은_길_키_배선():
+    panel = _read("B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts")
+    assert "apply: (next) => ctx.applyEdits(next)" in panel
+    assert 'tools.mode() === "free" && free.key(key)' in panel
+    profile = _read("A00_Common/design/design_profile.ts")
+    # applyEdits = 캐시(store.replace) + 되돌리기 기록 — 자동저장 없음
+    assert "store.replace(next);\n    history.record();" in profile
+    render = _read("B05_Profile/B05_Profile_UI_Profile_Render.ts")
+    assert "ctx.tools.mountOverlay(" in render
+
+
+def test_오버레이_점선_빨강_글():
+    view = _read("A00_Common/design/design_profile_free_view.ts")
+    assert "is-preview" in view and "is-over" in view
+    assert "grade_pct.toFixed(1)}%" in view
+    css = _read("B05_Profile/B05_Profile_UI_Style_Table.css")
+    assert ".b05-profile-freemark__line {" in css and "stroke-dasharray: 6 4" in css
+    assert ".b05-profile-freemark__line.is-over" in css
+
+
+def test_줄_수_늘리지_않음():
+    for relative in (
+        "A00_Common/design/design_profile.ts",
+        "A00_Common/design/design_profile_free.ts",
+        "A00_Common/design/design_profile_free_view.ts",
+        "A00_Common/design/design_profile_overlays.ts",
+        "A00_Common/design/design_profile_viewport.ts",
+    ):
+        assert len(_read(relative).splitlines()) <= 700  # 소스 700줄 초과 금지(213-3)
diff --git a/resources/tester/test_216_1_b05_station_panel.py b/resources/tester/test_216_1_b05_station_panel.py
new file mode 100644
index 000000000..189766527
--- /dev/null
+++ b/resources/tester/test_216_1_b05_station_panel.py
@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+"""PLAN 216-1 — B05 종단 측점선 고름 → 좌측 구조물 폼이 B06 카드 고름과 같게.
+
+까닭: `syncIrregularSelection` 이 일반 측점이면 폼을 안 건드리고 끝났고(옛 폼이 남음 · 덮는 옹벽도
+안 열림), 비정규 측점도 관 전용 `selectPipeByChainage` 만 불러 A군 수동 구조물은 안 열렸음.
+B06 카드 고름은 `showAtChainage` = `resolveSelection`(관 → 덮는 구조물 · 노면공 뺌 → 없으면 비움).
+고침: B05 측점 고름도 같은 `resolveSelection` + 같은 `coversAtStation` 으로 폼을 엶(`openAtStation`).
+실제 TS 를 `helper_216_1_b05_station_panel.cjs` 가 Node 로 돌린다.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+
+import pytest
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", ".."))
+
+pytestmark = pytest.mark.skipif(
+    not os.path.isdir(os.path.join(ROOT, "config", "node_modules")),
+    reason="프론트엔드 의존성 미설치",
+)
+
+
+@pytest.fixture(scope="module")
+def out() -> dict:
+    proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", os.path.join(HERE, "helper_216_1_b05_station_panel.cjs")],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def _read(*parts: str) -> str:
+    with open(os.path.join(ROOT, *parts), encoding="utf-8") as handle:
+        return handle.read()
+
+
+def _forms(steps: list) -> list:
+    return [(step["b05"], step["b06"]) for step in steps]
+
+
+def test_관_지점_측점선은_그_관_폼(out) -> None:
+    assert _forms(out["pipe"]) == [("pipe-33.40", "pipe-33.40")]
+
+
+def test_관_폼이_열린_채_빈_일반_측점이면_폼을_비움(out) -> None:
+    assert _forms(out["pipeThenPlain"])[-1] == (None, None)
+
+
+def test_일반_측점은_그_측점을_덮는_구조물_폼(out) -> None:
+    assert _forms(out["wallStation"]) == [(None, None), ("wall", "wall")]
+    assert _forms(out["wallMiddle"]) == [("wall", "wall")]
+    assert _forms(out["channel"]) == [("chan", "chan")]  # A군 수동 구조물 측점
+
+
+def test_노면공은_측점_고름으로_안_엶(out) -> None:
+    assert _forms(out["pave"]) == [("wall", "wall"), (None, None)]
+    assert out["covers"] == {"G": False, "C": True, "none": True}
+
+
+def test_다시_누름_풂과_모르는_측점(out) -> None:
+    assert _forms(out["release"])[-1] == (None, None)
+    assert out["release"][-1]["pick"] is None
+    assert out["unknown"][-1]["b05"] == "wall"  # 모르는 측점은 폼 그대로
+    assert out["unknown"][-1]["pick"] == {"chainageM": 60, "structureId": None}
+
+
+def test_고름_한_칸은_측점_구조물_id_없음(out) -> None:
+    # 폼이 옹벽을 열어도(목록 고름 알림이 구조물을 적어도) 마지막은 그 측점(188-1 · B06 카드와 같음)
+    for key in ("wallStation", "wallMiddle", "channel", "pave", "pipeThenPlain"):
+        for step in out[key]:
+            assert step["pick"]["structureId"] is None, key
+            assert step["pick"]["chainageM"] in (20, 33.4, 60, 80, 100, 140, 160), key
+
+
+def test_배선() -> None:
+    sync = _read("B05_Profile", "B05_Profile_UI_Selection.ts")
+    assert "(ports.openAtStation ?? ports.selectSidebar)(at);" in sync
+    assert "if (stationId !== null && !stationId.startsWith(prefix)) return;" not in sync
+    # 고름 한 칸은 폼 동기화 뒤에 적음
+    assert sync.index("ports.remember?.(at);") > sync.index("ports.setSyncing(false);")
+    view = _read("A00_Common", "design", "design_view_profile.ts")
+    assert "openAtStation: (chainageM) =>" in view
+    assert "panel.structures.selectAt({ chainageM, structureId: null }, (entry) =>" in view
+    assert "coversAtStation(bridge.typeGroup(entry.type_id))" in view
+    b06 = _read("B06_Section", "B06_Section_UI_Page_Structures_Panel.ts")
+    assert "coversAtStation(markTypes.find((type) => type.type_id === entry.type_id)?.group)" in b06
+    assert "resolveSelection(selection, pipeFacilities, structures, coverable)" in b06
+    panel = _read("B05_Profile", "B05_Profile_UI_Structures_Panel.ts")
+    assert "resolveSelection(selection, pipeFacilities, structures, coverable)" in panel
diff --git a/resources/tester/test_217_1_b06_notice_spacing.py b/resources/tester/test_217_1_b06_notice_spacing.py
new file mode 100644
index 000000000..e15d8ef74
--- /dev/null
+++ b/resources/tester/test_217_1_b06_notice_spacing.py
@@ -0,0 +1,30 @@
+"""217-1 B06 알림 칩 줄 여백 줄임 — 줄 위 여백 16→8 · 칩 줄 ↔ 첫 카드 28→16 (CSS 값 고정)."""
+
+from test_196_1_b06_notice_chips import B06
+
+CSS = (B06 / "B06_Section_UI_Style_Cross.css").read_text(encoding="utf-8")
+
+
+def _rule(selector: str) -> str:
+    body = CSS[CSS.index(selector + " {") :]
+    return body[: body.index("}")]
+
+
+def test_칩_줄_위_여백은_8_아래_여백은_0():
+    bar = _rule(".b06-section__notice-bar")
+    assert "padding-block: var(--spacing-8) 0;" in bar
+    assert "spacing-16) var(--spacing-4)" not in bar
+
+
+def test_첫_카드와의_간격은_카드_칸_gap_24에서_8을_당겨_16():
+    bar = _rule(".b06-section__notice-bar")
+    # 위 = 카드 칸 padding(16) 상쇄 · 아래 = gap(24) 중 8 당김
+    assert "margin-block: calc(-1 * var(--spacing-16)) calc(-1 * var(--spacing-8));" in bar
+    assert "gap: var(--spacing-24)" in _rule(".b06-section__cards")
+
+
+def test_sticky_top_과_scroll_margin_그대로():
+    bar = _rule(".b06-section__notice-bar")
+    assert "position: sticky" in bar
+    assert "top: calc(-1 * var(--spacing-16))" in bar
+    assert "scroll-margin-top: calc(var(--b06-notice-h, 0px) + var(--spacing-8))" in CSS
diff --git a/resources/tester/test_218_1_loupe.py b/resources/tester/test_218_1_loupe.py
new file mode 100644
index 000000000..8cf99dd14
--- /dev/null
+++ b/resources/tester/test_218_1_loupe.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+"""B05~B09 돋보기(계획서 218-1) 회귀검증 — 오른쪽 길게 누름 · Z 누름 동안 켬 · 크기 · 배율 · 복제 지움 · 페이지 다섯.
+
+Node 헬퍼(`helper_218_1_loupe.cjs`)가 `ui_template/ui_template_loupe.ts` 를 트랜스파일해
+가짜 창 · 가짜 시계 · 가짜 요소로 돌리고, 여기서 값을 판정함.
+"""
+
+import json
+import os
+import re
+import subprocess
+
+import pytest
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(os.path.dirname(HERE))
+
+
+@pytest.fixture(scope="module")
+def r():
+    proc = subprocess.run(
+        ["node", os.path.join(HERE, "helper_218_1_loupe.cjs")],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def _read(rel):
+    with open(os.path.join(ROOT, rel), encoding="utf-8") as f:
+        return f.read()
+
+
+def test_크기_배율_상수(r):
+    assert r["consts"] == {"d": 240, "zoom": 2, "hold": 400, "refresh": 500}
+    assert r["capture"]["rootSize"] == ["240px", "240px"]
+    # 커서(500,400)가 원 가운데(120,120)에 2배로 옴
+    assert r["capture"]["stageTransform"] == "translate(-880px, -680px) scale(2)"
+
+
+def test_창_캡처_단계로_들음(r):
+    assert r["listeners"] == [
+        [t, True]
+        for t in ("mousemove", "mousedown", "mouseup", "contextmenu", "keydown", "keyup", "blur")
+    ]
+
+
+def test_길게_누름_0_4초_넘어야_켜고_떼면_끔_메뉴는_안_뜸(r):
+    lg = r["long"]
+    assert lg["before"] == 0  # 0.399 초 = 아직
+    assert lg["on"] == "show" and lg["show"] == ["show", 300, 200]
+    assert lg["moved"] == ["move", 310, 205]  # 커서 따라감
+    assert lg["off"] == "hide"
+    assert lg["menuPrevented"] and lg["menuStopped"]  # 브라우저 · 우리 메뉴 둘 다 안 뜸
+    assert lg["nextStopped"] is False  # 한 번만 먹음
+
+
+def test_짧게_누르면_지금_우클릭_그대로(r):
+    assert r["short"] == {"log": 0, "menuPrevented": False, "menuStopped": False}
+
+
+def test_왼쪽_단추_무시_창_밖에서_떼면_끔(r):
+    mm = r["mouseMisc"]
+    assert mm["left"] == 0
+    assert mm["lostBeforeHold"] == 0  # 0.4 초 전에 뗌 — 안 켬
+    assert mm["lostAfterHold"] == "hide"
+
+
+def test_Z_누름_켬_뗌_끔(r):
+    k = r["key"]
+    assert k["on"] == "show"  # 한글 자판(ㅋ)도 code KeyZ
+    assert k["repeatLen"] == 1  # 누르고 있는 동안 다시 안 그림
+    assert k["off"] == "hide"
+    assert k["noCombo"]  # Ctrl · Alt · Meta 조합 · 다른 키는 안 켬
+    assert k["shift"] == "show"
+    assert k["fieldBlur"] == "show"  # 칸 초점 빠짐으론 안 끔
+    assert k["blur"] == "hide"  # 창이 초점을 잃으면 끔
+
+
+def test_입력_칸에선_안_켬(r):
+    t = r["key"]["typing"]
+    for name in ("input", "inputNoType", "number", "textarea", "select", "editable"):
+        assert t[name] is False, name
+    assert t["checkbox"] and t["button"]
+
+
+def test_B05_B09_밖이면_안_켬(r):
+    assert r["off"] == {"log": 0, "menuStopped": False}
+
+
+def test_페이지_다섯_붙음(r):
+    on = [k for k, v in r["routes"].items() if v]
+    assert on == [
+        "b05-profile",
+        "b06-section",
+        "b07-design-detail",
+        "b08-quantity",
+        "b09-estimation",
+    ]
+    main = _read("A00_Common/main.ts")
+    assert 'from "@ui/ui_template_loupe"' in main
+    assert re.search(r"initLoupe\(window, \(\) => LOUPE_ROUTE\.test\(currentRoute\(\)\)\)", main)
+
+
+def test_화면_끝에서_안_잘림(r):
+    o = r["origin"]
+    assert o["mid"] == {"left": 380, "top": 280}
+    assert o["topLeft"] == {"left": 4, "top": 4}
+    assert o["bottomRight"] == {"left": 1000 - 240 - 4, "top": 800 - 240 - 4}
+
+
+def test_화면_뜨기(r):
+    c = r["capture"]
+    assert (
+        c["rootClass"] == "ui-loupe"
+        and c["inert"]
+        and c["ariaHidden"] == "true"
+        and not c["hidden"]
+    )
+    assert c["pageBox"] == ["0px", "0px", "1000px", "800px"]
+    assert c["isClone"]
+    assert c["canvasDrawn"] == ["canvas2d"] and c["blankDrawn"] == 0
+    assert c["inputValue"] == "12.5" and c["checkChecked"]
+    assert c["scrollTop"] == 120
+    assert c["offscreenChildren"] == 0 and c["offscreenSize"] == ["100px", "100px"]  # 보이는 영역만
+    assert c["rowKept"] == 1  # 표 줄은 칸 너비 때문에 그대로
+    assert c["svgKept"] == 1
+    assert c["frameTag"] == "CANVAS" and c["frameDrawn"] == [["cad", 5, 6, 300, 200]]
+    assert c["frameSize"] == [320, 240]
+    assert c["watching"] and c["observeOpts"]["subtree"] and c["scrollListen"]
+
+
+def test_바뀌면_0_5초_뒤_다시_뜸_끄면_복제_지움(r):
+    h = r["hide"]
+    assert h["sameBefore"] and h["recaptured"]
+    assert h["nearEdge"] == "translate(4px, 4px)"
+    assert h["stageChildren"] == 0  # 복제 지움
+    assert h["hidden"] and h["disconnected"] and h["scrollListen"] is False
+    assert h["noRecaptureAfterHide"] == 0
+    assert h["reuseRoot"] == 1  # 원은 하나를 다시 씀
+
+
+def test_테두리_그림자_토큰():
+    css = _read("ui_template/ui_template_loupe.css")
+    assert "--loupe-border: var(--color-accent)" in css
+    assert "--loupe-shadow: var(--shadow-lg)" in css
+    assert "border-radius: 50%" in css and "pointer-events: none" in css
+    assert ".ui-loupe__cross" in css
+    theme = _read("ui_template/ui_template_theme.css")
+    dark = theme[theme.index(':root[data-theme="dark"]') :]
+    assert "--color-accent" in dark and "--shadow-lg" in dark  # 어두움에서도 토큰이 바뀜
diff --git a/resources/tester/test_219_1_arrow_owner.py b/resources/tester/test_219_1_arrow_owner.py
new file mode 100644
index 000000000..f9884020d
--- /dev/null
+++ b/resources/tester/test_219_1_arrow_owner.py
@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""PLAN 219-1 — 횡단 보기 방향키가 관을 몰래 옮기던 흠 · 측점 없는 구조물 판정 폭.
+
+까닭: 횡단 보기에서 관 · 도수로/돌붙임 띠를 고르면 조정창이 없어 방향키를 받는 쪽이 없고,
+종단도 창 듣개(`_Profile_Panel_Tools`)가 받아 고른 관 측점을 0.1 m 씩 옮김 → [저장] 때
+pipe_points +0.1(엄상준 263.21 → 263.31 · 226fc805 769.28 → 769.38) → 192 · 213 숨은 측점 씨앗.
+고침: ① 좌우 이동은 마지막 누름이 종단도 안일 때만(`arrowsBelongToProfile` 한 벌) ② 관 · 도수로
+띠 고름 동안 방향키 삼킴(`swallowsArrows`) ③ 판정 폭 = 같은 측점 폭 0.006 · 노선 밖 뺌.
+TS 는 `helper_219_1_arrow_owner.cjs` 가 Node 로 돌린다.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.abspath(os.path.join(HERE, "..", ".."))
+if ROOT not in sys.path:
+    sys.path.insert(0, ROOT)
+
+import B05_Profile.B05_Profile_Engine_Sections as sections  # noqa: E402
+from B05_Profile.B05_Profile_Engine_Grade_Alignment import SAME_STATION_SNAP_M  # noqa: E402
+from B06_Section.B06_Section_Router_Stations import (  # noqa: E402
+    STATION_MATCH_TOLERANCE_M,
+    _missing_marks,
+)
+
+needs_node = pytest.mark.skipif(
+    not os.path.isdir(os.path.join(ROOT, "config", "node_modules")),
+    reason="프론트엔드 의존성 미설치",
+)
+
+
+@pytest.fixture(scope="module")
+def out() -> dict:
+    proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", os.path.join(HERE, "helper_219_1_arrow_owner.cjs")],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def _read(*parts: str) -> str:
+    with open(os.path.join(ROOT, *parts), encoding="utf-8") as handle:
+        return handle.read()
+
+
+# ── ① · ② 방향키 소속 ─────────────────────────────────────────────────
+@needs_node
+def test_횡단_카드를_누른_뒤_좌우키는_관을_안_옮김(out) -> None:
+    assert out["cardThenArrows"] == {"move": [], "edits": 0}
+
+
+@needs_node
+def test_종단도를_누른_뒤_좌우키는_지금처럼_이동(out) -> None:
+    assert out["profileThenArrows"]["move"] == [[263.21, 263.31]]
+    assert out["popoutThenArrows"]["move"] == [[263.21, 263.11]]  # 새 창 종단도도
+    assert out["chuteThenProfile"]["move"] == [[263.21, 263.31]]
+
+
+@needs_node
+def test_도수로_관_고름_동안_방향키는_아무것도_안_옮김(out) -> None:
+    assert out["chute"] == {"move": [], "edits": 0}  # 계획고(▲▼)도
+    assert out["pipeSide"] == {"move": [], "edits": 0}
+    assert out["swallow"] == {"wall": False, "none": False, "letter": False}
+    assert out["cardUpArrow"] == {"move": [], "edits": 1}  # 고름 없는 카드 ▲ = 계획고 그대로
+
+
+def test_배선() -> None:
+    tools = _read("B05_Profile", "B05_Profile_UI_Profile_Panel_Tools.ts")
+    assert "if (!arrowsBelongToProfile()) return false;" in tools
+    assert 'from "../B06_Section/B06_Section_UI_Cross_Panel_Base"' in tools
+    panel = _read("B06_Section", "B06_Section_UI_Cross_Structure_Panel.ts")
+    assert "swallowsArrows(root.dataset.side, event.key)" in panel
+    assert (
+        'if (!opts?.dock && root.dataset.side) document.addEventListener("keydown", onArrowKey);'
+        in panel
+    )
+    base = _read("B06_Section", "B06_Section_UI_Cross_Panel_Base.ts")
+    assert 'typeof target?.closest === "function"' in base
+
+
+# ── ③ 측점 없는 구조물 판정 ───────────────────────────────────────────
+def test_판정_폭은_같은_측점_폭_한_벌() -> None:
+    assert STATION_MATCH_TOLERANCE_M == SAME_STATION_SNAP_M == 0.006
+
+
+def test_판정_폭과_노선_밖(tmp_path: Path, monkeypatch) -> None:
+    target = tmp_path / "B06_Section" / "longitudinal" / "longitudinal.json"
+    target.parent.mkdir(parents=True)
+    target.write_text(
+        json.dumps(
+            {"stations": [{"chainage_m": 0.0}, {"chainage_m": 50.0}, {"chainage_m": 100.0}]}
+        ),
+        encoding="utf-8",
+    )
+    # 노선 = 수평 길이 100m
+    monkeypatch.setattr(
+        sections, "_load_route_polyline", lambda *_: [[0, 0, 5], [60, 0, 9], [100, 0, 7]]
+    )
+    monkeypatch.setattr(sections, "_load_pipe_points", lambda *_: [])
+    extras = [
+        (-0.5, "시작 앞"),
+        (50.0055, "반올림 차이"),  # 옛 0.005 폭은 「측점 없음」으로 셌음
+        (70.0, "관"),
+        (100.004, "끝 반올림"),
+        (100.3, "끝 넘음"),
+    ]
+    monkeypatch.setattr(sections, "resolve_extra_stations", lambda *_: extras)
+    assert _missing_marks(tmp_path, "route.csv") == [{"chainage_m": 70.0, "label": "관"}]
+
+
+def test_노선_길이를_모르면_끝은_안_봄(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(sections, "_load_route_polyline", lambda *_: [])
+    monkeypatch.setattr(sections, "_load_pipe_points", lambda *_: [])
+    monkeypatch.setattr(
+        sections, "resolve_extra_stations", lambda *_: [(500.0, "관"), (-1.0, "앞")]
+    )
+    assert _missing_marks(tmp_path, "route.csv") == [{"chainage_m": 500.0, "label": "관"}]
diff --git a/resources/tester/test_b05_new_structure_defaults.py b/resources/tester/test_b05_new_structure_defaults.py
index b85ce87ae..d6a60d202 100644
--- a/resources/tester/test_b05_new_structure_defaults.py
+++ b/resources/tester/test_b05_new_structure_defaults.py
@@ -34,8 +34,8 @@ def test_새_관만_기본값_빈_키에만():
     fresh = PipePoint(chainage_m=10.0, source="stream", options={"pipe_diameter_mm": 800})
     basins._apply_new_defaults([fresh])
     # 추천(먼저 들어간 값)이 이김 · 집수정 모양 L 도 실제 값(54-39)
-    # 관 보호공 · 유입 집수정 높이 = 관경 + 0.5(139-1 · Φ800 → 1.3)
-    heights = dict.fromkeys(basins.PIPE_HEIGHT_KEYS, 1.3)
+    # 관 보호공 · 유입 집수정 높이 = 관경 + 0.5(139-1 · Φ800 → 1.3) · 유입 흙막이만 + 0.7(211-1 → 1.5)
+    heights = {**dict.fromkeys(basins.PIPE_HEIGHT_KEYS, 1.3), "inlet_revet_height_m": 1.5}
     expected = {**_defaults("pipe"), "pipe_diameter_mm": 800, "inlet_structure": "L", **heights}
     assert fresh.options == expected
     assert fresh.options["pipe_kind"] == "파형강관" and fresh.options["inlet_type"] == "집수정"
@@ -66,7 +66,8 @@ def test_원본에_있던_관은_빈칸_그대로(monkeypatch):
     by = {p.chainage_m: p for p in points}
     assert by[100.0].options is None  # 옛 빈칸 그대로
     # 새로 보충된 관 = 기본값 + 집수정 모양 L(54-39)
-    heights = dict.fromkeys(basins.PIPE_HEIGHT_KEYS, 1.5)  # 기본 관경 1000 → 1.5(139-1)
+    # 기본 관경 1000 → 1.5(139-1) · 유입 흙막이 1.7(211-1)
+    heights = {**dict.fromkeys(basins.PIPE_HEIGHT_KEYS, 1.5), "inlet_revet_height_m": 1.7}
     assert by[300.0].options == {**_defaults("pipe"), "inlet_structure": "L", **heights}
 
 
diff --git a/resources/tester/test_b06_cross_design_mirror.py b/resources/tester/test_b06_cross_design_mirror.py
index 151858314..d5169229f 100644
--- a/resources/tester/test_b06_cross_design_mirror.py
+++ b/resources/tester/test_b06_cross_design_mirror.py
@@ -234,6 +234,7 @@ const camel = {
   two_stage_slope: "twoStageSlope",
   cut_slope_ratio: "cutSlopeRatio",
   ditch_enabled: "ditchEnabled",
+  ditch_choice: "ditchChoice",
   surface_drop_m: "surfaceDropM",
   plan_radius_m: "planRadiusM",
   curve_outer_side: "curveOuterSide",
diff --git a/resources/tester/test_b06_missing_stations.py b/resources/tester/test_b06_missing_stations.py
index 81a01534b..48d0ac4f0 100644
--- a/resources/tester/test_b06_missing_stations.py
+++ b/resources/tester/test_b06_missing_stations.py
@@ -48,8 +48,8 @@ def test_측점이_없으면_빈_목록(tmp_path: Path) -> None:
 
 
 def test_같은_자리_판정은_측점_스냅_폭() -> None:
-    """측점 생성 스냅 폭(0.005m · 같은 횡단 이름)과 같음 — 0.5m 면 0.1m 옮긴 관을 놓침(192-1)."""
-    assert STATION_MATCH_TOLERANCE_M == 0.005
+    """같은 측점 폭(213-1 · 0.006m) 한 벌(219-1) — 0.5m 면 0.1m 옮긴 관을 놓침(192-1)."""
+    assert STATION_MATCH_TOLERANCE_M == 0.006
 
 
 def test_샘플링_조건이_없으면_None(tmp_path: Path) -> None:
diff --git a/resources/tester/test_b06_pipe_wall_height_mirror.py b/resources/tester/test_b06_pipe_wall_height_mirror.py
index 75707760c..ad8b2b0fa 100644
--- a/resources/tester/test_b06_pipe_wall_height_mirror.py
+++ b/resources/tester/test_b06_pipe_wall_height_mirror.py
@@ -26,7 +26,7 @@ def _ts_const(source: str, name: str) -> float:
 
 
 def test_상수_셋이_TS_와_같다() -> None:
-    for name in ("REVET_HEIGHT_STEP_M", "REVET_EMBED_DEPTH_M"):
+    for name in ("REVET_HEIGHT_STEP_M", "REVET_EMBED_DEPTH_M", "INLET_REVET_ADD_M"):
         assert getattr(culvert, name) == _ts_const(TS, name) == _ts_const(SETS, name), name
     assert culvert.OLD_PIPE_WALL_DEFAULT_M == _ts_const(SETS, "OLD_PIPE_WALL_DEFAULT_M")
 
@@ -35,9 +35,16 @@ def test_TS_식_모양이_그대로다() -> None:
     """식을 바꾸면 여기서 잡힘 — 파이썬 식도 함께 고칠 것."""
     assert "const raw = diameterM;" in TS and "const raw = diameterM;" in SETS
     assert "Math.ceil(raw / REVET_HEIGHT_STEP_M - 1e-9) * REVET_HEIGHT_STEP_M" in TS
-    assert "return revetTargetHeight(diameterM) + REVET_EMBED_DEPTH_M;" in TS
-    # 그림이 칸 값을 읽음(139-1) — 배관 기본 = 칸 → 관경 기준
-    assert "(spec.revet_height_m ?? pipeWallMinPureHeight(diameterM))" in TS
+    assert (
+        'revetTargetHeight(diameterM) + (side === "inlet" ? INLET_REVET_ADD_M : REVET_EMBED_DEPTH_M)'
+        in (
+            " ".join(TS.split())  # 줄바꿈 · 들여쓰기 무시(포맷터가 접음)
+        )
+        .replace("( ", "(")
+        .replace(" )", ")")
+    )
+    # 그림이 칸 값을 읽음(139-1) — 배관 기본 = 칸 → 관경 기준(유입 + 0.7 · 211-1)
+    assert "(spec.revet_height_m ?? pipeWallMinPureHeight(diameterM, spec.role))" in TS
     # 옛 1.5 옮김 — TS 세트 짝 식
     assert "Math.abs(stored - OLD_PIPE_WALL_DEFAULT_M) < 1e-9 &&" in SETS
     assert "diameterM > 1.0 + 1e-9" in SETS
diff --git a/resources/tester/test_m02_card_sheet_edit.py b/resources/tester/test_m02_card_sheet_edit.py
index 5553e17e8..6a4abdaac 100644
--- a/resources/tester/test_m02_card_sheet_edit.py
+++ b/resources/tester/test_m02_card_sheet_edit.py
@@ -23,7 +23,11 @@ def test_스프레드시트_미리보기_수정_옵션():
     src = _text(ROOT / "A00_Common" / "spreadsheet" / "spreadsheet.ts")
     assert "preview?: boolean;" in src
     assert "const bare = readOnly || !!opts.preview;" in src
-    assert "bare ? null : mountToolbar(ctx)" in src and "bare ? null : attachMenu(ctx)" in src
+    assert "bare ? null : mountToolbar(ctx)" in src
+    # 미리보기 우클릭 = 「복사」 한 줄 — 메뉴 쪽이 ss--preview 로 가름
+    assert "attachMenu(ctx)" in src and '" ss--preview"' in src
+    menu = _text(ROOT / "A00_Common" / "spreadsheet" / "spreadsheet_menu.ts")
+    assert 'classList.contains("ss--preview")' in menu and "copyOnlyItems(ctx)" in menu
     # 편집 · 수식 입력 줄은 readOnly 만 막음 — preview 는 고칠 수 있음
     assert "const readOnly = !!opts.readOnly;" in src
     assert re.search(r"for \(const node of \[toolbar\?\.root, ed\.bar, grid\.root", src)
diff --git a/resources/tester/test_m02_df_input_logic.py b/resources/tester/test_m02_df_input_logic.py
index bbe4d9bb9..e0c659a65 100644
--- a/resources/tester/test_m02_df_input_logic.py
+++ b/resources/tester/test_m02_df_input_logic.py
@@ -18,12 +18,17 @@ const fs = require("fs");
 const path = require("path");
 const [root, file] = process.argv.slice(1);
 const ts = require(path.join(root, "config", "node_modules", "typescript"));
-const js = ts.transpileModule(fs.readFileSync(file, "utf8"), {
-  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
-}).outputText;
-const box = { exports: {} };
-new Function("exports", "module", "require", js)(box.exports, box, () => ({}));
-const m = box.exports;
+const load = (src, req) => {
+  const js = ts.transpileModule(fs.readFileSync(src, "utf8"), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
+  }).outputText;
+  const box = { exports: {} };
+  new Function("exports", "module", "require", js)(box.exports, box, req);
+  return box.exports;
+};
+// 로직 찾기는 공용 맞춤(208-1) — 그것만 실제로 싣고 나머지 import 는 빈 것
+const find = load(path.join(root, "ui_template", "ui_template_logic_find.ts"), () => ({}));
+const m = load(file, (p) => (p.endsWith("ui_template_logic_find") ? find : {}));
 (async () => {
   const jobs = JSON.parse(fs.readFileSync(0, "utf8"));
   const out = [];
diff --git a/ui_template/cad_host/cad_host.ts b/ui_template/cad_host/cad_host.ts
index 51ea8b6f3..27cfaf37d 100644
--- a/ui_template/cad_host/cad_host.ts
+++ b/ui_template/cad_host/cad_host.ts
@@ -148,6 +148,12 @@ export function createCadHost<D extends CadHostDrawing, M = unknown, Q = unknown
   frame.addEventListener("load", () => {
     if (frame.contentWindow) blockNativeMenu(frame.contentWindow, () => true);
   });
+  // 포인터가 CAD 위에 오면 키(Ctrl+Z · Ctrl+Y …)가 CAD 로 가게 초점을 넘김 — 부모 입력 칸에서 치는 중이면 안 뺏음
+  frame.addEventListener("mouseenter", () => {
+    const active = document.activeElement;
+    if (active === frame || active?.closest("input, textarea, select, [contenteditable]")) return;
+    frame.contentWindow?.focus();
+  });
   const license = document.createElement("a");
   license.className = "cad-host__license";
   license.href = "/b07-cad/THIRD_PARTY_LICENSES.txt";
diff --git a/ui_template/ui_template_data_table.css b/ui_template/ui_template_data_table.css
index af0a5e26d..787d9e90f 100644
--- a/ui_template/ui_template_data_table.css
+++ b/ui_template/ui_template_data_table.css
@@ -172,3 +172,24 @@
   outline: 2px solid var(--color-focus-ring);
   outline-offset: -2px;
 }
+
+/* 레벨(PLAN 201-1 · level 옵션 · 보기 전용) — 레벨 열 왼쪽 맞춤 · 레벨마다 1em 들여쓰기(글 상자도) */
+.ui-data-table__table td.ui-data-table__lv {
+  padding-left: calc(var(--spacing-8) + var(--dt-lv, 0) * 1em);
+  text-align: left;
+}
+
+.ui-data-table__table td.ui-data-table__lv.is-edit {
+  padding-left: 0;
+}
+
+.ui-data-table__table td.ui-data-table__lv .ui-data-table__input {
+  padding-left: calc(var(--spacing-8) + var(--dt-lv, 0) * 1em);
+  text-align: left;
+}
+
+/* 같은 값 세로 병합(PLAN 201-1 · mergeSame) — 한 칸 글은 위에 */
+.ui-data-table__table td.is-merged {
+  vertical-align: top;
+  padding-top: calc((var(--dt-row-h) - 1.3em) / 2);
+}
diff --git a/ui_template/ui_template_data_table.ts b/ui_template/ui_template_data_table.ts
index 33656ca10..7f0b93d82 100644
--- a/ui_template/ui_template_data_table.ts
+++ b/ui_template/ui_template_data_table.ts
@@ -11,6 +11,9 @@
  *   칸 누름(PLAN 144) = onCellClick(줄, 열) · 줄로 이동 = t.focusRow(줄)(스크롤 + 강조)
  *   줄 꼴(PLAN 155-2) = rowClass(줄) → 줄 class(예 is-title 굵게) · 안 주면 글 그대로
  *   창 끝까지(PLAN 199) = fillViewport → 표 칸 최대 높이를 창 아래 끝까지(줄이 늘어도 페이지 스크롤 0)
+ *   레벨(PLAN 201-1 · 보기 전용) = level { key, of(줄) } → 그 열 왼쪽 맞춤 + 레벨마다 1em 들여쓰기(글 상자도)
+ *   같은 값 세로 병합(PLAN 201-1) = mergeSame [열] → 위아래로 같은 값이 이어지면 한 칸(rowSpan) · 본문만
+ *     앞 병합 열이 갈리면 뒤 병합 열도 갈림 · 빈 값 · 고칠 칸은 안 합침 · 칸 → 열 = `cellColumn`(병합 표는 data-c)
  * ========================================================================== */
 
 import "./ui_template_data_table.css";
@@ -65,6 +68,10 @@ export interface DataTableOptions {
   cellClass?: (index: number, key: string) => string | null | undefined;
   /** 참이면 표 칸 최대 높이 = 창 아래 끝까지(창 크기 바뀌면 다시 셈) — 안 주면 CSS 고정값 */
   fillViewport?: boolean;
+  /** 레벨(보기 전용) — key 열을 레벨마다 1em 들여씀 · of = 줄 레벨(1 = 맨 위 · 빈 값 = 1) */
+  level?: { key: string; of: (index: number) => number | null | undefined };
+  /** 같은 값 세로 병합할 열 키(표마다 지정) — 위아래로 같은 글이 이어지면 rowSpan 한 칸 */
+  mergeSame?: string[];
 }
 
 export interface DataTable {
@@ -145,15 +152,21 @@ function rowHtml(
   focus = false,
   extra: string | null | undefined = null,
   cellClass?: (key: string) => string | null | undefined,
+  more: RowMore = {},
 ): string {
   let tr = "";
+  const { lv, spans } = more;
   for (let j = 0; j < cols.length; j++) {
     const key = cols[j].key;
+    const span = spans?.[j] ?? 1;
+    if (!span) continue; // 위 칸에 합쳐짐
+    const lvc = lv?.key === key ? " ui-data-table__lv" : "";
+    const c = spans ? ` data-c="${j}"` : "";
     if (edit !== null && editable?.(edit, key)) {
       const v = r[key];
       const raw = v === null || v === undefined ? "" : String(v);
       const tip = esc(cols[j].title ?? cols[j].label);
-      tr += `<td class="is-edit" data-num=""><input class="ui-data-table__input" data-i="${edit}" data-k="${esc(key)}" value="${esc(raw)}" inputmode="decimal" aria-label="${tip}"></td>`;
+      tr += `<td class="is-edit${lvc}" data-num=""${c}><input class="ui-data-table__input" data-i="${edit}" data-k="${esc(key)}" value="${esc(raw)}" inputmode="decimal" aria-label="${tip}"></td>`;
       continue;
     }
     const [txt, empty] = formatCell(r[key], fmts[j], blank);
@@ -163,24 +176,68 @@ function rowHtml(
       frz && left[j + 1] == null && "is-edge",
       empty && "is-empty",
       cellClass?.(key),
+      lvc.trim(),
+      span > 1 && "is-merged",
     ]
       .filter(Boolean)
       .join(" ");
     const attrs =
       (cls ? ` class="${cls}"` : "") +
       (frz ? ` style="left:${left[j]}px"` : "") +
-      (fmts[j] ? ' data-num=""' : "");
+      (fmts[j] ? ' data-num=""' : "") +
+      (span > 1 ? ` rowspan="${span}"` : "") +
+      c;
     tr += `<td${attrs}>${esc(txt)}</td>`;
   }
   const cls = [alt && "is-alt", index !== null && "is-clickable", focus && "is-focus", extra]
     .filter(Boolean)
     .join(" ");
-  const data = index !== null ? ` data-i="${index}"` : "";
+  const data =
+    (index !== null ? ` data-i="${index}"` : "") + (lv ? ` style="--dt-lv:${lv.n}"` : "");
   return cls || data
     ? `<tr${cls ? ` class="${esc(cls)}"` : ""}${data}>${tr}</tr>`
     : `<tr>${tr}</tr>`;
 }
 
+/** 줄 곁값 — lv = 레벨 열 · 들여쓸 칸 수 · spans = 열마다 rowSpan(0 = 위 칸에 합쳐짐) */
+interface RowMore {
+  lv?: { key: string; n: number };
+  spans?: number[];
+}
+
+/** 칸 → 열 번호 — 병합 표는 칸이 빠져 cellIndex 가 밀리므로 data-c */
+export function cellColumn(cell: HTMLTableCellElement): number {
+  return cell.dataset.c !== undefined ? Number(cell.dataset.c) : cell.cellIndex;
+}
+
+/** 병합 구간(from ~ to 줄) — [줄][열] rowSpan · 0 = 위 칸에 합쳐짐 · 병합 안 하는 열 = 1 */
+export function mergeSpans(o: DataTableOptions, from: number, to: number): number[][] {
+  const cols = o.columns;
+  const keys = new Set(o.mergeSame ?? []);
+  const out = Array.from({ length: to - from }, () => cols.map(() => 1));
+  // 이음 = 이 열까지 앞 병합 열이 모두 위 줄과 같은 글(빈 값 · 고칠 칸 빼고)
+  const shown = (i: number, j: number): string | null => {
+    const key = cols[j].key;
+    if (o.editable?.(i, key)) return null;
+    const [txt] = formatCell(o.rows[i][key], null, "");
+    return txt.trim() ? txt : null; // 빈 값 · 빈칸 글(" ")은 안 합침
+  };
+  for (let i = from + 1; i < to; i++) {
+    let joined = true;
+    for (let j = 0; j < cols.length; j++) {
+      if (!keys.has(cols[j].key)) continue;
+      const v = shown(i, j);
+      joined = joined && v !== null && v === shown(i - 1, j);
+      if (!joined) continue;
+      let top = i - 1;
+      while (!out[top - from][j]) top--;
+      out[top - from][j]++;
+      out[i - from][j] = 0;
+    }
+  }
+  return out;
+}
+
 /** 그릴 줄 구간 — 밖의 줄은 빈 줄 높이(rowH px)로만 채움 */
 export interface RowWindow {
   from: number;
@@ -216,7 +273,9 @@ export function renderDataTableHtml(o: DataTableOptions, win?: RowWindow): strin
   let body = win ? pad(from * win.rowH, cols.length) : "";
   const blank = o.empty ?? EMPTY;
   const pick = o.onRowClick !== undefined || o.onCellClick !== undefined;
-  for (let i = from; i < to; i++)
+  const spans = o.mergeSame?.length ? mergeSpans(o, from, to) : null;
+  for (let i = from; i < to; i++) {
+    const lvN = o.level ? Math.max(0, (o.level.of(i) ?? 1) - 1) : 0;
     body += rowHtml(
       cols,
       fmts,
@@ -230,7 +289,12 @@ export function renderDataTableHtml(o: DataTableOptions, win?: RowWindow): strin
       o.focus === i,
       o.rowClass?.(i),
       o.cellClass ? (key) => o.cellClass?.(i, key) : undefined,
+      {
+        ...(o.level ? { lv: { key: o.level.key, n: lvN } } : {}),
+        ...(spans ? { spans: spans[i - from] } : {}),
+      },
     );
+  }
   if (win) body += pad((n - to) * win.rowH, cols.length);
   const foot = o.total ? `<tfoot>${rowHtml(cols, fmts, left, o.total, false, blank)}</tfoot>` : "";
   const cap = o.caption ? `<caption>${esc(o.caption)}</caption>` : "";
@@ -342,7 +406,7 @@ export function createDataTable(opts: DataTableOptions): DataTable {
     const row = (event.target as Element).closest<HTMLElement>("tr[data-i]");
     if (!row || !root.contains(row)) return;
     const cell = (event.target as Element).closest<HTMLTableCellElement>("td");
-    const column = cell ? state.columns[cell.cellIndex] : undefined;
+    const column = cell ? state.columns[cellColumn(cell)] : undefined;
     if (column) state.onCellClick?.(Number(row.dataset.i), column.key);
     state.onRowClick?.(Number(row.dataset.i));
   });
diff --git a/ui_template/ui_template_group_cards.css b/ui_template/ui_template_group_cards.css
index 58499235f..677c99a50 100644
--- a/ui_template/ui_template_group_cards.css
+++ b/ui_template/ui_template_group_cards.css
@@ -1,6 +1,9 @@
 /* 묶음 카드 공용 양식(171-2) — 글자 14px 한 벌 · 줄 간격 좁게 · 숫자 오른쪽. 색은 테마 변수만. */
 
 .ui-group-cards {
+  /* 200-3 제목 줄 = 표 머리색 계열(옅게) · 합계 줄 = 강조색 더 짙게 — 둘 다 테마 변수에서 섞음(밝음 · 어두움 같이) */
+  --group-head-bg: color-mix(in srgb, var(--color-accent) 6%, var(--color-surface-raised));
+  --group-foot-bg: color-mix(in srgb, var(--color-accent) 15%, var(--color-surface-raised));
   display: flex;
   flex-direction: column;
   gap: var(--spacing-8);
@@ -43,11 +46,13 @@
 .ui-group-cards__grid {
   display: grid;
   grid-template-columns: repeat(var(--group-cols, 2), minmax(0, 1fr));
-  align-items: start;
+  align-items: stretch; /* 200-1 같은 가로 줄 = 높이 같음 */
   gap: var(--spacing-8);
 }
 
 .ui-group-card {
+  display: flex;
+  flex-direction: column;
   min-width: 0;
   padding: var(--spacing-4) var(--spacing-8);
   background-color: var(--color-surface-raised);
@@ -66,7 +71,8 @@
   flex-wrap: wrap;
   align-items: baseline;
   column-gap: var(--spacing-8);
-  padding: 2px 0;
+  padding: 2px var(--spacing-4);
+  background-color: var(--group-head-bg);
   border-bottom: 1px solid var(--color-border);
   font-weight: var(--font-weight-bold);
 }
@@ -87,6 +93,7 @@
 }
 
 .ui-group-card__body {
+  flex: 1 1 auto; /* 내용 적은 카드도 몸통이 늘어 합계 줄이 아래에 */
   overflow-x: auto;
 }
 
@@ -145,6 +152,7 @@
   justify-content: flex-end;
   column-gap: var(--spacing-8);
   padding: 2px var(--spacing-4);
+  background-color: var(--group-foot-bg);
   border-top: 1px solid var(--color-border);
   font-variant-numeric: tabular-nums;
 }
diff --git a/ui_template/ui_template_group_cards.ts b/ui_template/ui_template_group_cards.ts
index 65923f767..976100317 100644
--- a/ui_template/ui_template_group_cards.ts
+++ b/ui_template/ui_template_group_cards.ts
@@ -5,7 +5,7 @@
  *   머리 = 호표 · 명칭 · 규격 · 단위 · 합계 / 몸 = 줄(이름 · 규격 · 수량 · 단위 · 합계 · 비고) /
  *   합계 줄 = 노무 · 재료 · 경비 · 계 · 줄 금액 = 합계만(비목 셋 = 풍선)
  *   글자 14px 한 벌 · 줄 간격 좁게 · 숫자 오른쪽 · 가로 열 수 1~4(기억은 부르는 쪽)
- *   접기 없음 — 묶음 모두 펼친 박스
+ *   접기 없음 — 묶음 모두 펼친 박스 · 같은 가로 줄 카드 = 높이 같음(200-1 · 합계 줄은 아래 붙음)
  *   줄 번호(`at`) = 부르는 쪽 표 줄 번호 — 누름 = `onPick(at)` · 이동해 온 줄 = 그 박스 붉은 외곽선
  *   (`is-pick`) + 스크롤 + 그 줄 강조(`is-focus`)
  * ========================================================================== */
@@ -67,6 +67,8 @@ export interface GroupCardsOptions {
   qty?: (value: number | null | undefined) => string;
   /** 머리 띠 끝 단추(예 [표로 보기]) */
   actions?: HTMLElement[];
+  /** 주면 가로 열 수 · `actions` 를 머리 띠에 안 넣고 이 함수로 넘김(202-1 부르는 쪽 보조 탭 줄 오른쪽) */
+  placeTools?: (tools: HTMLElement[]) => void;
 }
 
 export const GROUP_COLUMNS = [1, 2, 3, 4] as const;
@@ -208,11 +210,16 @@ export function createGroupCards(opts: GroupCardsOptions): HTMLElement {
     return b;
   });
   pick.append(...colButtons);
-  bar.append(pick, span("ui-group-cards__count", `묶음 ${opts.groups.length}`));
-  const tail = document.createElement("div");
-  tail.className = "ui-group-cards__actions";
-  tail.append(...(opts.actions ?? []));
-  bar.append(tail);
+  const count = span("ui-group-cards__count", `묶음 ${opts.groups.length}`);
+  if (opts.placeTools) {
+    bar.append(count);
+    opts.placeTools([pick, ...(opts.actions ?? [])]);
+  } else {
+    const tail = document.createElement("div");
+    tail.className = "ui-group-cards__actions";
+    tail.append(...(opts.actions ?? []));
+    bar.append(pick, count, tail);
+  }
   root.append(bar, grid);
 
   grid.addEventListener("click", (event) => {
diff --git a/ui_template/ui_template_logic_find.ts b/ui_template/ui_template_logic_find.ts
new file mode 100644
index 000000000..f67516f63
--- /dev/null
+++ b/ui_template/ui_template_logic_find.ts
@@ -0,0 +1,53 @@
+/* =============================================================================
+ * ui_template_logic_find.ts
+ * 단가산출 로직 찾기 맞춤(208-1) — 로직을 찾는 화면은 모두 이것 하나를 부름.
+ * 낱말(띄어 나눔)마다 키 · 원문번호 · 이름 · 구분 · 상세구분 · 별칭(쉼표로 여럿) 가운데 하나에 들면 맞음 ·
+ * 띄어쓰기 · 대소문자 무시. 별칭으로 맞았으면 그 별칭을 돌려줌(결과에 작게).
+ * 짝: `M01_MasterData_Store_Find.hit`(서버 찾기 — 키 · 원문번호 · 이름 · 별칭 · 낱말 규칙이 같음 ·
+ * 구분 · 상세구분은 화면만) · 거울 시험 `test_208_1_logic_alias.py`.
+ * ========================================================================== */
+
+export interface LogicFindRow {
+  키?: string;
+  원문번호?: string;
+  이름?: string;
+  구분?: string;
+  상세구분?: string;
+  /** 쉼표로 여럿 · 없으면 빈칸 */
+  별칭?: string | null;
+}
+
+export interface LogicFindHit {
+  ok: boolean;
+  /** 별칭으로 맞았으면 맞은 별칭(쉼표로 이음) · 아니면 빈 글 */
+  alias: string;
+}
+
+const squash = (v: unknown): string =>
+  String(v ?? "")
+    .replace(/\s+/g, "")
+    .toLowerCase();
+
+/** 별칭 칸 → 낱낱 별칭(쉼표로 나눔 · 빈 것 뺌) */
+export const aliasesOf = (v: unknown): string[] =>
+  String(v ?? "")
+    .split(",")
+    .map((x) => x.trim())
+    .filter(Boolean);
+
+/** 고친 별칭 글을 저장 꼴로 — 「a ,b,, c」 → 「a, b, c」 */
+export const aliasText = (v: unknown): string => aliasesOf(v).join(", ");
+
+/** 결과에 작게 붙이는 글 — 별칭으로 안 맞았으면 빈 글 */
+export const aliasNote = (alias: string): string => (alias ? `별칭 ${alias}` : "");
+
+export function matchLogic(q: string, row: LogicFindRow): LogicFindHit {
+  const words = q.split(/\s+/).map(squash).filter(Boolean);
+  const fields = [row.키, row.원문번호, row.이름, row.구분, row.상세구분].map(squash);
+  const missed = words.filter((w) => !fields.some((f) => f.includes(w)));
+  if (!missed.length) return { ok: true, alias: "" };
+  const aliases = aliasesOf(row.별칭);
+  const has = (a: string, w: string): boolean => squash(a).includes(w);
+  if (!missed.every((w) => aliases.some((a) => has(a, w)))) return { ok: false, alias: "" };
+  return { ok: true, alias: aliases.filter((a) => missed.some((w) => has(a, w))).join(", ") };
+}
diff --git a/ui_template/ui_template_loupe.css b/ui_template/ui_template_loupe.css
new file mode 100644
index 000000000..bfc3cf912
--- /dev/null
+++ b/ui_template/ui_template_loupe.css
@@ -0,0 +1,68 @@
+/* =============================================================================
+ * 돋보기 공용 모양(`ui_template_loupe.ts` · 계획서 218-1) — 화면에 하나 · fixed · 원 ·
+ * 테두리 · 그림자 = 테마 토큰(밝음 · 어두움 같이) · 마우스를 안 막음 · 크기 · 배율은 TS 상수
+ * ========================================================================== */
+
+.ui-loupe {
+  --loupe-border: var(--color-accent);
+  --loupe-shadow: var(--shadow-lg);
+  position: fixed;
+  left: 0;
+  top: 0;
+  z-index: calc(var(--z-toast) + 10);
+  border-radius: 50%;
+  overflow: hidden;
+  background: var(--color-bg);
+  box-shadow:
+    0 0 0 2px var(--loupe-border),
+    var(--loupe-shadow);
+  pointer-events: none;
+  will-change: transform;
+}
+
+.ui-loupe[hidden] {
+  display: none;
+}
+
+/* 복제를 놓는 판 — 화면(뷰포트) 크기 · fixed 자식의 기준 상자 */
+.ui-loupe__stage {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100vw;
+  height: 100vh;
+  transform-origin: 0 0;
+}
+
+.ui-loupe__stage *,
+.ui-loupe__stage *::before,
+.ui-loupe__stage *::after {
+  animation: none !important;
+  transition: none !important;
+}
+
+.ui-loupe__page {
+  position: absolute;
+}
+
+/* 가운데 십자 — 작게 */
+.ui-loupe__cross::before,
+.ui-loupe__cross::after {
+  content: "";
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  background: var(--loupe-border);
+}
+
+.ui-loupe__cross::before {
+  width: 12px;
+  height: 1px;
+  transform: translate(-50%, -50%);
+}
+
+.ui-loupe__cross::after {
+  width: 1px;
+  height: 12px;
+  transform: translate(-50%, -50%);
+}
diff --git a/ui_template/ui_template_loupe.ts b/ui_template/ui_template_loupe.ts
new file mode 100644
index 000000000..e4c40b572
--- /dev/null
+++ b/ui_template/ui_template_loupe.ts
@@ -0,0 +1,342 @@
+/* =============================================================================
+ * ui_template_loupe.ts
+ * 돋보기 — 커서를 따라가는 원 안에 지금 화면을 크게 보여 줌(계획서 218-1) · 공용 진입(`A00_Common/main.ts`)이 B05~B09 에 붙임.
+ *
+ * 켜는 법 둘 — 오른쪽 단추를 0.4 초 넘게 누르고 있는 동안 · Z 키를 누르고 있는 동안 · 떼면 꺼짐.
+ * 길게 누른 우클릭은 뗀 뒤 메뉴(우리 메뉴 · 브라우저 메뉴)를 안 띄움 · 짧게 누르면 지금 우클릭 그대로.
+ * 그리기 — 켤 때 `#app` 을 한 번 떠서(DOM 복제 + 2D canvas 그림 복사 · SVG 그대로) 원 안에 놓고, 움직일 때 transform 만 바꿈.
+ * 화면 밖 상자는 속을 비우고 크기만 남김 · 켜 있는 동안 화면이 바뀌면 0.5 초 뒤 다시 뜸 · 끄면 복제를 지움.
+ * WebGL canvas 는 그림이 남아 있을 때만 옮겨짐 · 같은 출처 iframe(CAD)은 안의 canvas 만 옮김 — 못 옮기면 그 자리 빈칸.
+ * ========================================================================== */
+
+import "./ui_template_loupe.css";
+import { keyLetter } from "../A00_Common/key_shortcut";
+
+/** 원 지름(px) */
+export const LOUPE_DIAMETER = 240;
+/** 배율 */
+export const LOUPE_ZOOM = 2;
+/** 오른쪽 단추를 이만큼(ms) 넘게 누르면 켬 */
+export const LOUPE_HOLD_MS = 400;
+/** 켜 있는 동안 화면이 바뀌면 이만큼(ms) 뒤 다시 뜸 */
+export const LOUPE_REFRESH_MS = 500;
+/** 화면 끝과 원 사이 여백(px) — 테두리가 안 잘리게 */
+export const LOUPE_EDGE = 4;
+/** 붙일 주소 — B05~B09 */
+export const LOUPE_ROUTE = /^b0[5-9]/;
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+const NON_TEXT_INPUT = new Set([
+  "checkbox",
+  "radio",
+  "button",
+  "submit",
+  "reset",
+  "range",
+  "color",
+  "file",
+  "image",
+  "hidden",
+]);
+/** 화면 밖이어도 속을 안 비움 — 표 칸 너비가 다른 줄 내용에 따라 정해짐 */
+const KEEP_INSIDE = new Set([
+  "TABLE",
+  "THEAD",
+  "TBODY",
+  "TFOOT",
+  "TR",
+  "TD",
+  "TH",
+  "COLGROUP",
+  "COL",
+  "CAPTION",
+]);
+
+/** Z 키 판정 — 공용 `keyLetter`(214-2 · 한글 자판 「ㅋ」 = 자판 자리 KeyZ) · Ctrl/Alt/Meta 조합은 아님 */
+export function isLoupeKey(
+  evt: Pick<KeyboardEvent, "code" | "ctrlKey" | "altKey" | "metaKey"> &
+    Partial<Pick<KeyboardEvent, "key">>,
+): boolean {
+  return keyLetter(evt) === "z" && !evt.ctrlKey && !evt.altKey && !evt.metaKey;
+}
+
+/** 글을 치는 자리 — 글 칸 · 고르기 칸 · contenteditable */
+export function isTypingTarget(target: unknown): boolean {
+  const el = target as { tagName?: string; type?: string; isContentEditable?: boolean } | null;
+  if (!el?.tagName) return false;
+  if (el.isContentEditable) return true;
+  const tag = el.tagName.toUpperCase();
+  if (tag === "TEXTAREA" || tag === "SELECT") return true;
+  return tag === "INPUT" && !NON_TEXT_INPUT.has((el.type || "text").toLowerCase());
+}
+
+/** 원 왼 위 자리 — 커서 가운데 · 화면 밖으로 안 나감 */
+export function loupeOrigin(
+  x: number,
+  y: number,
+  vw: number,
+  vh: number,
+): { left: number; top: number } {
+  const clamp = (v: number, max: number): number => Math.max(LOUPE_EDGE, Math.min(v, max));
+  const r = LOUPE_DIAMETER / 2;
+  return {
+    left: clamp(x - r, vw - LOUPE_DIAMETER - LOUPE_EDGE),
+    top: clamp(y - r, vh - LOUPE_DIAMETER - LOUPE_EDGE),
+  };
+}
+
+export interface LoupeView {
+  show(x: number, y: number): void;
+  move(x: number, y: number): void;
+  hide(): void;
+}
+
+/** `win` 에 두 켜는 법을 붙임 — `isOn()` 이 거짓이면(B05~B09 밖) 안 켬 */
+export function initLoupe(
+  win: Window,
+  isOn: () => boolean,
+  view: LoupeView = createLoupeView(win),
+): void {
+  let x = win.innerWidth / 2;
+  let y = win.innerHeight / 2;
+  let press = false; // 오른쪽 길게 누름
+  let key = false; // Z 누름
+  let shown = false;
+  let holdTimer = 0;
+  let swallowMenu = false; // 길게 누른 뒤 따라오는 우클릭 메뉴 한 번을 먹음
+
+  const update = (): void => {
+    const want = (press || key) && isOn();
+    if (want && !shown) view.show(x, y);
+    else if (!want && shown) view.hide();
+    shown = want;
+  };
+  const stopHold = (): void => {
+    win.clearTimeout(holdTimer);
+    holdTimer = 0;
+  };
+  const on = <K extends keyof WindowEventMap>(type: K, fn: (e: WindowEventMap[K]) => void): void =>
+    win.addEventListener(type, fn, true);
+
+  on("mousemove", (e) => {
+    x = e.clientX;
+    y = e.clientY;
+    if (!(e.buttons & 2) && (holdTimer || press)) {
+      stopHold(); // 창 밖에서 뗌 — mouseup 이 안 옴
+      press = false;
+      update();
+    }
+    if (shown) view.move(x, y);
+  });
+  on("mousedown", (e) => {
+    if (e.button !== 2) return;
+    swallowMenu = false;
+    stopHold();
+    if (!isOn()) return;
+    x = e.clientX;
+    y = e.clientY;
+    holdTimer = win.setTimeout(() => {
+      holdTimer = 0;
+      press = true;
+      swallowMenu = true;
+      update();
+    }, LOUPE_HOLD_MS);
+  });
+  on("mouseup", (e) => {
+    if (e.button !== 2) return;
+    stopHold();
+    if (!press) return;
+    press = false;
+    update();
+  });
+  on("contextmenu", (e) => {
+    if (!swallowMenu) return;
+    swallowMenu = false;
+    e.preventDefault();
+    e.stopImmediatePropagation(); // 우리 메뉴도 안 뜸
+  });
+  on("keydown", (e) => {
+    if (!isLoupeKey(e) || isTypingTarget(e.target)) return;
+    key = true;
+    update();
+  });
+  on("keyup", (e) => {
+    if (keyLetter(e) !== "z" || !key) return;
+    key = false;
+    update();
+  });
+  on("blur", (e) => {
+    if (e.target !== win) return; // 칸 초점 빠짐은 무시 — 창이 초점을 잃을 때만(CAD iframe 으로 넘어감 포함)
+    stopHold();
+    press = key = false;
+    update();
+  });
+}
+
+/** 원 · 복제 · 다시 뜨기를 맡음 — `sourceOf()` 가 뜰 영역 */
+export function createLoupeView(
+  win: Window,
+  sourceOf: () => Element | null = () => win.document.getElementById("app"),
+): LoupeView {
+  const doc = win.document;
+  let root: HTMLElement | null = null;
+  let stage: HTMLElement | null = null;
+  let observer: MutationObserver | null = null;
+  let refreshTimer = 0;
+
+  const build = (): void => {
+    root = doc.createElement("div");
+    root.className = "ui-loupe";
+    root.setAttribute("aria-hidden", "true");
+    root.inert = true;
+    root.style.width = root.style.height = `${LOUPE_DIAMETER}px`;
+    stage = doc.createElement("div");
+    stage.className = "ui-loupe__stage";
+    const cross = doc.createElement("div");
+    cross.className = "ui-loupe__cross";
+    root.append(stage, cross);
+    doc.body.append(root);
+  };
+  const capture = (): void => {
+    const source = sourceOf();
+    const t0 = win.performance?.now() ?? 0;
+    stage!.replaceChildren();
+    if (source) captureInto(source, stage!, win);
+    root!.dataset.captureMs = String(Math.round((win.performance?.now() ?? 0) - t0));
+  };
+  const refresh = (): void => {
+    if (refreshTimer) return;
+    refreshTimer = win.setTimeout(() => {
+      refreshTimer = 0;
+      if (observer) capture();
+    }, LOUPE_REFRESH_MS);
+  };
+  const view: LoupeView = {
+    show(x, y) {
+      if (!root) build();
+      capture();
+      root!.hidden = false;
+      view.move(x, y);
+      const source = sourceOf();
+      const Observer = (win as Window & typeof globalThis).MutationObserver;
+      const watch = new Observer(refresh);
+      if (source)
+        watch.observe(source, {
+          subtree: true,
+          childList: true,
+          attributes: true,
+          characterData: true,
+        });
+      observer = watch;
+      win.addEventListener("scroll", refresh, true);
+    },
+    move(x, y) {
+      if (!root || !stage) return;
+      const { left, top } = loupeOrigin(x, y, win.innerWidth, win.innerHeight);
+      const r = LOUPE_DIAMETER / 2;
+      root.style.transform = `translate(${left}px, ${top}px)`;
+      stage.style.transform = `translate(${r - LOUPE_ZOOM * x}px, ${r - LOUPE_ZOOM * y}px) scale(${LOUPE_ZOOM})`;
+    },
+    hide() {
+      observer?.disconnect();
+      observer = null;
+      win.clearTimeout(refreshTimer);
+      refreshTimer = 0;
+      win.removeEventListener("scroll", refresh, true);
+      stage?.replaceChildren(); // 복제를 지움
+      if (root) root.hidden = true;
+    },
+  };
+  return view;
+}
+
+/** `source` 를 떠서 `stage` 에 화면 자리 그대로 놓음 */
+export function captureInto(source: Element, stage: HTMLElement, win: Window): void {
+  const doc = win.document;
+  const rect = source.getBoundingClientRect();
+  const page = doc.createElement("div");
+  page.className = "ui-loupe__page";
+  Object.assign(page.style, {
+    left: `${rect.left}px`,
+    top: `${rect.top}px`,
+    width: `${rect.width}px`,
+    height: `${rect.height}px`,
+  });
+  const copy = source.cloneNode(true) as Element;
+  const scrolls: [Element, number, number][] = [];
+  walk(source, copy, doc, win.innerWidth, win.innerHeight, scrolls);
+  page.append(copy);
+  stage.append(page);
+  for (const [el, top, left] of scrolls) {
+    el.scrollTop = top; // 복제는 스크롤이 0 으로 돌아감 — 붙인 뒤 되돌림
+    el.scrollLeft = left;
+  }
+}
+
+function walk(
+  o: Element,
+  c: Element,
+  doc: Document,
+  vw: number,
+  vh: number,
+  scrolls: [Element, number, number][],
+): void {
+  if (o.namespaceURI === SVG_NS) return; // SVG 는 복제 그대로
+  const tag = o.tagName.toUpperCase();
+  if (tag === "CANVAS") return drawCanvas(o as HTMLCanvasElement, c as HTMLCanvasElement);
+  if (tag === "IFRAME") return void c.replaceWith(frameShot(o as HTMLIFrameElement, doc));
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return copyValue(o, c);
+  const r = o.getBoundingClientRect();
+  if (!KEEP_INSIDE.has(tag) && (r.bottom < 0 || r.right < 0 || r.top > vh || r.left > vw)) {
+    c.replaceChildren(); // 화면 밖 — 속을 비우고 크기만
+    Object.assign((c as HTMLElement).style, {
+      boxSizing: "border-box",
+      width: `${r.width}px`,
+      height: `${r.height}px`,
+    });
+    return;
+  }
+  if (o.scrollTop || o.scrollLeft) scrolls.push([c, o.scrollTop, o.scrollLeft]);
+  for (let i = 0; i < o.children.length; i++)
+    walk(o.children[i], c.children[i], doc, vw, vh, scrolls);
+}
+
+function drawCanvas(o: HTMLCanvasElement, c: HTMLCanvasElement): void {
+  try {
+    if (o.width && o.height) c.getContext("2d")?.drawImage(o, 0, 0);
+  } catch {
+    // 못 옮기면 빈칸
+  }
+}
+
+function copyValue(o: Element, c: Element): void {
+  const from = o as HTMLInputElement;
+  const to = c as HTMLInputElement;
+  try {
+    if (from.type !== "file") to.value = from.value;
+    to.checked = from.checked;
+  } catch {
+    // 값을 못 옮겨도 모양은 그대로
+  }
+}
+
+/** iframe 자리 — 같은 출처면 안의 canvas 를 한 장에 모아 그림 · 아니면 빈칸 */
+function frameShot(frame: HTMLIFrameElement, doc: Document): HTMLCanvasElement {
+  const r = frame.getBoundingClientRect();
+  const shot = doc.createElement("canvas");
+  shot.className = frame.className;
+  shot.width = Math.max(1, Math.round(r.width));
+  shot.height = Math.max(1, Math.round(r.height));
+  Object.assign(shot.style, { display: "block", width: `${r.width}px`, height: `${r.height}px` });
+  try {
+    const ctx = shot.getContext("2d");
+    for (const canvas of Array.from(frame.contentDocument?.querySelectorAll("canvas") ?? [])) {
+      const cr = canvas.getBoundingClientRect();
+      if (canvas.width && canvas.height)
+        ctx?.drawImage(canvas, cr.left, cr.top, cr.width, cr.height);
+    }
+  } catch {
+    // 다른 출처 · 그림 없음 — 빈칸
+  }
+  return shot;
+}