diff --git a/A00_Common/b_page_state.ts b/A00_Common/b_page_state.ts
index d2d6d8187..60ee6b9dd 100644
--- a/A00_Common/b_page_state.ts
+++ b/A00_Common/b_page_state.ts
@@ -89,7 +89,7 @@ export const STATE_REGISTRY = {
   "masshaul-visible": {
     bucket: "pref",
     scope: "global",
-    version: 5,
+    version: 6,
     legacy: () => "b06:masshaul-visible-v4",
   },
   "table-open": { bucket: "pref", scope: "global", legacy: () => "b05:profile:table:open" },
diff --git a/A00_Common/design/design_page.ts b/A00_Common/design/design_page.ts
index 63fc84c16..2a466c75f 100644
--- a/A00_Common/design/design_page.ts
+++ b/A00_Common/design/design_page.ts
@@ -32,6 +32,7 @@ import { saveSharedDesign, type DesignPageShared } from "./design_shared";
 import { guardDesignLeave } from "./design_leave";
 import { usePipeIds } from "./design_pipe_ids";
 import { setRouteShiftOpener } from "../../B06_Section/B06_Section_UI_Cross_Center";
+import { reconcilePagePipeline } from "./design_pipeline_page";
 import "./design_page.css";
 
 export type { DesignPageShared } from "./design_shared";
@@ -244,6 +245,7 @@ export function renderDesignPage(root: HTMLElement): MountedPage {
     if (slot) {
       slot.show();
       applyView(view);
+      void reconcilePagePipeline(projectId); // 들어올 때 입력(세션 · 가게) 대 묶음 맞춤(365-2)
     } else mountView(view, true);
     // 검증용 — 보기 전환에 든 시간(ms)과 횟수를 화면 밖에서 수치로 본다.
     const probe = window as unknown as { __designPage?: { view: string; switchMs: number[] } };
diff --git a/A00_Common/design/design_pipeline_cross.ts b/A00_Common/design/design_pipeline_cross.ts
index 4ef809138..866b66758 100644
--- a/A00_Common/design/design_pipeline_cross.ts
+++ b/A00_Common/design/design_pipeline_cross.ts
@@ -8,9 +8,11 @@
  * 넘기는 칸 = 서버 노선 저장(`CARRY_INPUT_KEYS`)과 같은 일곱(지반 유형 · 측구 종류 · 측구 선택 · 2단 경사 ·
  * 암 경계 · 암 경사 · 소단) + 얹힌 시설 맥락(포장 · 물넘이 기울임 · 세월교 노면 하강). 단면 유형 · 측구
  * 방향은 새 지형이 정함(`logic/B05_Profile_Pipeline_Detail.ts` `crossWithUphill`) · 노견 확장 · 소단
- * 깊이는 안 넘김. 값 = 상세에 얹힌 설계(세션 고침은 종단도 · 횡단 보기가 다시 셈하며 이미 얹음).
+ * 깊이는 안 넘김. 값 = 상세에 얹힌 설계 위에 세션 고침(측점 열쇠 칸 · 지반 유형 · 측구 · 2단 경사 · 암 경계 ·
+ * 암 경사) — 노선 초안 동안 B06 고침은 저장 상세에 안 얹혀도 입력에 들어감(365-2). 부를 때마다 모음.
  * ========================================================================== */
 
+import { readState } from "../b_page_state";
 import type { CrossSection, SectionDetailResponse } from "../../B06_Section/B06_Section_Api_Fetch";
 import {
   effectiveStandardCross,
@@ -66,16 +68,50 @@ function carried(section: CrossSection): Record<string, unknown> {
       : null,
     paved: Boolean(section.pavement?.length) || Boolean(section.ford_pavement),
     tilted: Boolean(section.ford_pavement || section.underdrain),
-    tiltPct: section.ford_pavement?.slope_pct ?? section.underdrain?.slope_pct ?? null,
+    tiltPct: section.ford_pavement?.slope_pct ?? null, // 맹암거 = 표준 경사(371-3)
     surfaceDropM: drop > 0 ? drop : 0,
   };
 }
 
-/** 저장 상세 + 저장 노선 측점(열쇠) → cross 입력 · 시설 제원 — 표준단면 · 상세가 없으면 null. */
+/** 세션 칸 하나를 측점 열쇠마다 — 옛 열쇠(누가거리 · `at:`)는 읽는 쪽이 옮긴 뒤에 들어옴(빼고 봄). */
+function sessionCells(
+  name: "crossdesign" | "rockb" | "cutslope",
+  projectId: string,
+  routeId: number,
+): Array<[string, unknown]> {
+  const raw = readState<Record<string, unknown>>(name, projectId, routeId);
+  if (!raw || typeof raw !== "object") return [];
+  return Object.entries(raw).filter(([key]) => key.includes(":") && !key.startsWith("at:"));
+}
+
+/** 세션 횡단 고침 → 측점 열쇠마다 넘기는 입력 조각(`carried` 와 같은 칸 이름). */
+function sessionCarried(projectId: string, routeId: number): CrossInput["byKey"] {
+  const out: CrossInput["byKey"] = {};
+  for (const [key, value] of sessionCells("crossdesign", projectId, routeId)) {
+    const choice = (value ?? {}) as Record<string, unknown>;
+    const entry = (out[key] ??= {});
+    if (typeof choice.ground_type === "string") entry.groundType = choice.ground_type;
+    if (typeof choice.ditch_type === "string") entry.ditchType = choice.ditch_type;
+    if ("ditch_choice" in choice)
+      entry.ditchChoice = typeof choice.ditch_choice === "boolean" ? choice.ditch_choice : null;
+    if ("two_stage_slope" in choice) entry.twoStageSlope = Boolean(choice.two_stage_slope);
+  }
+  for (const [key, value] of sessionCells("rockb", projectId, routeId))
+    if (finite(value) !== null) (out[key] ??= {}).rockBoundaryOffsetM = value;
+  for (const [key, value] of sessionCells("cutslope", projectId, routeId)) {
+    const ratio = finite(value);
+    if (ratio !== null) (out[key] ??= {}).cutSlopeRatio = ratio > 0 ? ratio : null;
+  }
+  return out;
+}
+
+/** 저장 상세 + 저장 노선 측점(열쇠) + 세션 고침(`routeId` 칸) → cross 입력 · 시설 제원 — 표준단면 ·
+ *  상세가 없으면 null. */
 export function pipelineCrossSource(
   projectId: string,
   detail: SectionDetailResponse | null,
   savedStations: ReadonlyArray<PipelineStation>,
+  routeId: number | null = null,
 ): PipelineCrossSource | null {
   const standard = detail && effectiveStandardCross(projectId);
   if (!detail || !standard) return null;
@@ -94,6 +130,9 @@ export function pipelineCrossSource(
     for (const name of SPEC_KEYS) if (section[name] !== undefined) own[name] = section[name];
     specs.set(best.key, own as SectionSpecs);
   }
+  if (routeId !== null)
+    for (const [key, entry] of Object.entries(sessionCarried(projectId, routeId)))
+      byKey[key] = { ...byKey[key], ...entry };
   return {
     // 암 경계 기본값 = 서버 config(화면이 문맥에서 기억) — 입력 없는 측점(초안 새 측점)도 서버처럼(349-0p)
     input: { standard, byKey, rockBoundaryDefaultM: readRockBoundaryDefault(projectId) },
diff --git a/A00_Common/design/design_pipeline_page.ts b/A00_Common/design/design_pipeline_page.ts
index 3ec3d51f0..895ecb64e 100644
--- a/A00_Common/design/design_pipeline_page.ts
+++ b/A00_Common/design/design_pipeline_page.ts
@@ -12,7 +12,10 @@
  *
  * 입력 — 노선 = 편집기 다리(`RouteDraftBridge` · 캐시 칸 route-draft) · 계획고 = 종단도 편집
  *   (`pipelineGrade` · 노선 초안 동안은 alignment-draft 노선 `DRAFT_ROUTE_ID`) · 횡단 = 저장 상세의 측점
- *   입력(`design_pipeline_cross.ts`) · 관 = 가게 초안 → 저장 관 목록(좌표 · id) · 구조물 = 가게 초안 → 저장분.
+ *   입력 + 세션 고침(`design_pipeline_cross.ts` · 부를 때마다 모음 · 횡단 고침 뒤 `pipelineCross` · 365-2) ·
+ *   관 = 가게 초안 → 저장 관 목록(좌표 · id) · 구조물 = 가게 초안 → 저장분.
+ * 고리(365-2) — 열 때 · 페이지 들어올 때(`reconcilePagePipeline`) 입력(세션 · 가게)을 묶음이 쥔 입력과 견줌 →
+ *   다르면 한 바퀴 → 끝난 뒤 다시 견줌 · 최대 `RECONCILE_ROUNDS` · 넘으면 `onUnstable`(「계산 불안정」 한 줄).
  * 출력 — 가게 stations · profile · footprint · generation · 노선 초안이 있으면 종단도가 새 첫 계획선 ·
  *   옮긴 계획고 · 새 노선 상세(`pipelineDetail` — 지반 · 측점 · 횡단 면적 → 유토곡선)를 그림.
  * 첫 계산 = 열 때 한 번(저장 노선 · 발자국 · 저장 안 한 노선 초안이 있으면 그 노선).
@@ -22,15 +25,19 @@
  * ========================================================================== */
 
 import { createDesignPipeline, publishToStore, type DesignPipeline } from "./logic/design_pipeline";
+import { SOURCE_INPUT } from "./logic/design_pipeline_types";
 export { pipelineWork } from "./logic/design_pipeline";
 import { pipelineCrossSource, type PipelineCrossSource } from "./design_pipeline_cross";
-import { createStationsStage } from "./logic/design_pipeline_stations";
+import { createStationsStage, stationDiff } from "./logic/design_pipeline_stations";
 import type {
+  ChangeSource,
+  CrossOutput,
   FollowPatch,
   PipelineInputs,
   PipelineOutputs,
   PipelineRunRecord,
   PipelineStation,
+  RangePart,
   RouteDraft,
   StageFn,
   Vertex,
@@ -102,6 +109,8 @@ import type {
 
 /** 노선 초안 동안의 계획고 초안 칸 — alignment-draft 의 노선 0(노선 번호는 [저장] 때 남). */
 export const DRAFT_ROUTE_ID = 0;
+/** 입력 ↔ 묶음 입력 맞춤 상한(바퀴) — 넘으면 「계산 불안정」(365-2). */
+export const RECONCILE_ROUNDS = 3;
 
 /** 종단도(`design_profile`)가 묶음에 내주는 것. */
 export interface ProfileLink {
@@ -137,6 +146,15 @@ export interface PagePipelineOptions {
     routeId: number,
     saved: SectionDetailResponse | null,
   ) => (stations: PipelineStation[]) => Promise<string>;
+  /** 고리가 `RECONCILE_ROUNDS` 바퀴 안에 안 맞음 — 「계산 불안정」 한 줄(365-2). */
+  onUnstable?: () => void;
+  /** 저장 노선 cross = 다시 셈 창구 한 벌(365-4) — 상세 설계를 고치고 그 값을 냄 · 측점이 상세와 다르면 null
+   *  (묶음 엔진). 주면 종단도가 계획고 편집 뒤 따로 다시 셈 안 함(`pipelineOwnsCross`). */
+  savedCross?: (
+    detail: SectionDetailResponse,
+    routeId: number,
+    stations: ReadonlyArray<PipelineStation>,
+  ) => Promise<CrossOutput | null>;
 }
 
 interface PagePipeline {
@@ -145,6 +163,9 @@ interface PagePipeline {
   grade(edits: AlignmentEdits): void;
   restart(): void;
   earthwork(context: MassHaulStageContext | null): void;
+  cross(): void;
+  reconcile(): Promise<number>;
+  ownsCross: boolean;
   detail(): SectionDetailResponse | null;
   dispose(): void;
 }
@@ -155,22 +176,6 @@ type Facilities = Pick<DesignStoreValues, "pipes" | "structures">;
 const pages = new Map<string, PagePipeline>();
 const same = (a: unknown, b: unknown): boolean => JSON.stringify(a) === JSON.stringify(b);
 
-/** 상세 측점 대 묶음 측점(1 mm) — 같으면 null · 다르면 첫 다른 자리 · 개수(묶음 기록 `restoreDiff`). */
-function stationDiff(
-  detail: SectionDetailResponse,
-  stations: ReadonlyArray<PipelineStation>,
-): NonNullable<PipelineRunRecord["restoreDiff"]> | null {
-  const saved = detail.cross_sections.map((section) => section.chainage_m);
-  const n = Math.max(saved.length, stations.length);
-  for (let i = 0; i < n; i += 1) {
-    const pipelineM = stations[i]?.chainageM ?? null;
-    if (saved[i] !== undefined && pipelineM !== null && Math.abs(saved[i] - pipelineM) < 1e-3)
-      continue;
-    return { savedM: saved[i] ?? null, pipelineM, saved: saved.length, pipeline: stations.length };
-  }
-  return null;
-}
-
 /** 편집기에 넘길 다리 — 그 프로젝트 묶음을 처음 부를 때 세움. */
 export function routeDraftBridge(
   projectId: string,
@@ -193,6 +198,17 @@ export const restartPagePipeline = (projectId: string): void => pages.get(projec
 export const pipelineEarthwork = (projectId: string, context: MassHaulStageContext | null): void =>
   pages.get(projectId)?.earthwork(context);
 
+/** 횡단 고침(지반 유형 · 측구 · 암 · 소단 · 표준 — B06 · 365-2) — 세션 횡단 입력을 다시 모아 cross 부터. */
+export const pipelineCross = (projectId: string): void => pages.get(projectId)?.cross();
+
+/** 저장 노선 횡단 다시 셈을 묶음 cross 가 맡는가(365-4) — 종단도는 계획고 편집 뒤 따로 안 셈. */
+export const pipelineOwnsCross = (projectId: string): boolean =>
+  pages.get(projectId)?.ownsCross ?? false;
+
+/** 입력(세션 · 가게) 대 묶음 입력을 견줘 맞춤(365-2) — 돈 바퀴 수(0 = 같음 · -1 = 넘음 · 묶음 없음 = 0). */
+export const reconcilePagePipeline = (projectId: string): Promise<number> =>
+  pages.get(projectId)?.reconcile() ?? Promise.resolve(0);
+
 /** 노선 초안 동안 종단도가 그릴 새 노선 상세 — 초안이 없으면 null(저장 상세). */
 export const pipelineDetail = (projectId: string): SectionDetailResponse | null =>
   pages.get(projectId)?.detail() ?? null;
@@ -219,10 +235,9 @@ function createPagePipeline(
   let savedStructures: PlanStructure[] = [];
   let savedPipes: PlanPipe[] = [];
   let earthwork: MassHaulStageContext | null = null;
-  /** 저장 노선 측점(열쇠) · 그것으로 모은 횡단 입력 — 저장 상세가 바뀌면 다시. */
+  /** 저장 노선 측점(열쇠) · 마지막으로 모은 횡단 입력(시설 제원 — 새 노선 상세가 씀). */
   let savedStations: PipelineStation[] = [];
-  let crossSource: { detail: SectionDetailResponse; source: PipelineCrossSource | null } | null =
-    null;
+  let crossSource: PipelineCrossSource | null = null;
   /** 저장 정본(서버가 준 상세 · 노선 번호) — 측점 갈아끼움(swap)이 만든 새 상세는 지반 표본 배열을
    *  그대로 둠 → 정본 아님(묶음 출력 → 상세 → 다시 묶음 고리를 끊음). */
   let canon: { routeId: unknown; samples: unknown; detail: SectionDetailResponse | null } | null =
@@ -286,12 +301,17 @@ function createPagePipeline(
       emptyEdits()
     );
   };
+  /** 횡단 입력 — 부를 때마다 저장 상세 + 세션 고침 · 표준을 모음(상세 객체마다 기억하면 고침이 안 감 · 365-2). */
   const crossNow = (): PipelineCrossSource | null => {
-    const detail = canon?.detail ?? null;
-    if (!detail) return null;
-    if (crossSource?.detail !== detail || !crossSource.source)
-      crossSource = { detail, source: pipelineCrossSource(projectId, detail, savedStations) };
-    return crossSource.source;
+    const routeId = canon?.routeId;
+    const source = pipelineCrossSource(
+      projectId,
+      canon?.detail ?? null,
+      savedStations,
+      typeof routeId === "number" ? routeId : null,
+    );
+    if (source) crossSource = source;
+    return source;
   };
   const groundDeps = groundStageDeps(projectId);
   const crossStage = createCrossStage({ grid: groundDeps.grid }); // 미교차 넓힘 = 같은 지형 격자(349-0j)
@@ -340,18 +360,27 @@ function createPagePipeline(
       ground: createGroundStage(groundDeps),
       planline: createPlanlineStage({ savedBase: () => savedSource().base, savedLine }),
       profile: profileStage,
-      // 단면 유형 기본값 = 새 지형 상단측(서버 노선 저장 규칙) — 단계 본문은 그대로 부름
-      cross: (ctx) =>
-        crossStage.stage({
-          ...ctx,
-          inputs: {
-            ...ctx.inputs,
-            cross: crossWithUphill(
-              ctx.inputs.cross as CrossInput | null,
-              ctx.out.ground?.stations ?? [],
-            ),
-          },
-        }),
+      // 단면 유형 기본값 = 새 지형 상단측(서버 노선 저장 규칙) — 단계 본문은 그대로 부름 · 저장 노선 = 다시 셈
+      // 창구 한 벌(카드 · 유토곡선이 보는 상세 설계 · 365-4)
+      cross: (ctx) => {
+        const engine = () =>
+          crossStage.stage({
+            ...ctx,
+            inputs: {
+              ...ctx.inputs,
+              cross: crossWithUphill(
+                ctx.inputs.cross as CrossInput | null,
+                ctx.out.ground?.stations ?? [],
+              ),
+            },
+          });
+        const { detail = null, routeId } = savedSource();
+        const saved =
+          !ctx.inputs.route && detail && typeof routeId === "number"
+            ? options.savedCross?.(detail, routeId, ctx.out.ground?.stations ?? [])
+            : null;
+        return saved ? saved.then((out) => out ?? engine()) : engine();
+      },
       footprint: footprintStage,
       masshaul: createMassHaulStage(() => earthwork),
       haul: (ctx) => (ctx.inputs.route ? haulStage(ctx) : (ctx.prev ?? null)),
@@ -460,7 +489,7 @@ function createPagePipeline(
             ground,
             profile,
             pipe.output("cross"),
-            crossSource?.source?.specs ?? new Map(),
+            crossSource?.specs ?? new Map(),
             options.stationIntervalM ?? profile.policy.station_interval_m,
           )
         : null;
@@ -513,12 +542,52 @@ function createPagePipeline(
     if (disposed || !ready || !savedSource().base) return;
     canonChanged();
     started = true;
-    held = null;
+    const inputs = inputsNow();
+    // 초안 둔 채 열기(새로고침 · B06 바로 열기 · 365-1) — 초안 전 = 지금 저장 상세(세션 그대로) · 측점은 가게에 냄
+    held = inputs.route ? (held ?? holdNow()) : null;
     dropping = null;
-    void pipe.start(inputsNow());
-    openGeneration = quietGeneration = pipe.generation;
+    Object.assign(given, inputs);
+    const run = (lastRun = pipe.start(inputs));
+    openGeneration = pipe.generation;
+    quietGeneration = inputs.route ? -1 : pipe.generation;
+    void run.then(() => reconcile()); // 열 때 셈하는 사이 바뀐 입력(세션 · 가게)도 맞춤
   };
 
+  /** 묶음에 넘긴 입력(follow 가 고치기 전) · 마지막으로 띄운 차례 — 고리가 견줌 · 기다림. */
+  const given: Partial<PipelineInputs> = {};
+  let lastRun: Promise<unknown> = Promise.resolve();
+  const feed = (source: ChangeSource, value: unknown, part: RangePart | null = null) => {
+    given[SOURCE_INPUT[source]] = value as never;
+    const run = pipe.update(source, value, part);
+    if (run) lastRun = run;
+    return run;
+  };
+  let reconciling: Promise<number> | null = null;
+  /** 입력 지문 대 묶음 입력 — 넘긴 값 · follow 뒤 값 둘 다와 다르면 한 바퀴(노선 = 다리 길) · 끝난 뒤 다시 견줌. */
+  function reconcile(): Promise<number> {
+    if (!started || disposed) return Promise.resolve(0);
+    return (reconciling ??= (async () => {
+      for (let round = 0; ; round += 1) {
+        let seen: Promise<unknown> | null = null;
+        while (seen !== lastRun) await (seen = lastRun); // 기다리는 사이 뜬 차례까지
+        await pipe.settled();
+        if (disposed || canon?.routeId !== savedSource().routeId) return round; // 정본 바뀜 = restart 몫
+        const now = inputsNow();
+        const stale = (Object.entries(SOURCE_INPUT) as Array<[ChangeSource, keyof PipelineInputs]>)
+          .filter(([, key]) => !same(now[key], pipe.input(key)) && !same(now[key], given[key]))
+          .map(([source, key]): [ChangeSource, unknown] => [source, now[key]]);
+        if (!stale.length) return round;
+        if (round >= RECONCILE_ROUNDS) {
+          options.onUnstable?.();
+          return -1;
+        }
+        for (const [source, value] of stale)
+          if (source === "route") bridge.edited(value as RouteDraft | null);
+          else feed(source, value);
+      }
+    })().finally(() => (reconciling = null)));
+  }
+
   /** 저장 노선(그린 선 · 곡선표 · 기본 반경) · 그 측점 열쇠 — [저장] 뒤 다시 받음(`restart`). */
   const loadPlan = (): Promise<void> =>
     fetchRoutePlan(projectId)
@@ -552,13 +621,10 @@ function createPagePipeline(
     .catch(() => undefined);
 
   const unsubscribe = [
-    store.subscribe(
-      "pipes",
-      (pipes) => started && !echo && void pipe.update("pipe", pipes ?? savedPipes),
-    ),
+    store.subscribe("pipes", (pipes) => started && !echo && void feed("pipe", pipes ?? savedPipes)),
     store.subscribe(
       "structures",
-      (list) => started && !echo && void pipe.update("structure", list ?? savedStructures),
+      (list) => started && !echo && void feed("structure", list ?? savedStructures),
     ),
   ];
 
@@ -579,7 +645,7 @@ function createPagePipeline(
       if (!started) return start();
       const before = pipe.output("route")?.line ?? null;
       const after = draft ? draftLine(draft, plan?.min_radius_m ?? 0).line : savedLine();
-      const run = pipe.update("route", draft, routeRange(before, after));
+      const run = feed("route", draft, routeRange(before, after));
       if (run && !draft && wasDraft) {
         quietGeneration = pipe.generation;
         dropping = run.then(finishDrop);
@@ -595,7 +661,7 @@ function createPagePipeline(
       if (same(edits, pipe.input("alignment"))) return;
       const nodes = pipe.output("planline")?.basePvi.map((node) => node.chainage_m) ?? [];
       const before = pipe.input("alignment") as AlignmentEdits | null;
-      void pipe.update("grade", edits, gradeRange(before, edits, nodes));
+      void feed("grade", edits, gradeRange(before, edits, nodes));
     },
     restart() {
       if (!started) return start();
@@ -604,8 +670,14 @@ function createPagePipeline(
     earthwork(context) {
       earthwork = context;
       const cross = crossNow()?.input ?? null;
-      if (started && cross) void pipe.update("cross", cross);
+      if (started && cross) void feed("cross", cross);
     },
+    cross() {
+      const cross = started ? (crossNow()?.input ?? null) : null;
+      if (cross) void feed("cross", cross);
+    },
+    reconcile,
+    ownsCross: Boolean(options.savedCross),
     detail: () => shown,
     dispose() {
       disposed = true;
diff --git a/A00_Common/design/design_profile.ts b/A00_Common/design/design_profile.ts
index faa2750cb..6481c3a03 100644
--- a/A00_Common/design/design_profile.ts
+++ b/A00_Common/design/design_profile.ts
@@ -324,9 +324,9 @@ export function createDesignProfile(ctx: DesignProfileContext) {
     refresh: () => renderBalance(),
   });
 
-  /** 편집을 적용한다. 법정 위반 정책이 block이면 새 위반이 생기는 편집을 막는다. */
-  function applyEdits(next: AlignmentEdits): void {
-    if (!base || !alignment) return;
+  /** 편집을 적용한다. 법정 위반 정책이 block이면 새 위반이 생기는 편집을 막는다. false = 막힘. */
+  function applyEdits(next: AlignmentEdits): boolean {
+    if (!base || !alignment) return false;
     const candidate = buildAlignment(base, next);
     if (
       base.policy.grade_violation_policy === "block" &&
@@ -336,12 +336,13 @@ export function createDesignProfile(ctx: DesignProfileContext) {
         `종단기울기 상한 ${base.policy.max_grade_pct.toFixed(1)}%를 넘어 편집을 적용하지 않았습니다.`,
         "error",
       );
-      return;
+      return false;
     }
     // 최소고 가드 — 편집 경로가 전부 여기로 모인다(2026-09-02 직선화·쉬프트·틸팅·방향키 누락 수정).
-    if (blocksMinCover(base, alignment, candidate, enforceMinCover, minCoverTargets)) return;
+    if (blocksMinCover(base, alignment, candidate, enforceMinCover, minCoverTargets)) return false;
     store.replace(next);
     history.record();
+    return true;
   }
 
   /** 계획선 측점 줄 = 측점 한 벌 — 셈은 `design_profile_base` 몫(계산 묶음 planline 도 같은 기준). */
@@ -353,8 +354,8 @@ export function createDesignProfile(ctx: DesignProfileContext) {
     pagePipeline.pipelineGrade(projectId, store.edits());
     // 계획고가 바뀌면 측점별 횡단 단면적도 함께 바뀐다 — 전 측점을 다시 계산해 공유
     // 캐시에 얹는다. 그래야 **횡단 기준** 유토곡선과 횡단 카드가 따라 움직인다
-    // (2026-08-03 사용자 보고: B05에서 계획선을 끌어도 횡단 곡선이 그대로였음).
-    scheduleCrossPreview();
+    // (2026-08-03 사용자 보고: B05에서 계획선을 끌어도 횡단 곡선이 그대로였음). 묶음이 맡으면 그 cross 한 벌(365-4).
+    if (!pagePipeline.pipelineOwnsCross(projectId)) scheduleCrossPreview();
     drawSoon();
   }
   /** 다음 틀에 한 번 그림 — 같은 차례 알림 · 갈아끼움 · 설정이 여러 번 불러도 한 번(349-0s). */
diff --git a/A00_Common/design/design_profile_overlays.ts b/A00_Common/design/design_profile_overlays.ts
index 5926afe74..f5735dcb2 100644
--- a/A00_Common/design/design_profile_overlays.ts
+++ b/A00_Common/design/design_profile_overlays.ts
@@ -59,8 +59,6 @@ export function createProfileOverlays(deps: ProfileOverlaysDeps) {
   const column = document.createElement("div");
   column.className = "b05-route-profile__column";
   column.append(bodyWrap, massHaul.overlay);
-  // 판의 가로 스크롤을 종단 스크롤러와 양방향 동기화 — 측점 세로선 정렬 유지.
-  massHaul.attachScrollSync(body);
   // 테이블은 종단 칸 바닥 겹침 판(2026-08-05 사용자 지시).
   const tableOverlay = createProfileTableOverlay(onChange);
   bodyWrap.append(tableOverlay.overlay, tableOverlay.handle);
diff --git a/A00_Common/design/design_shared.ts b/A00_Common/design/design_shared.ts
index 803c7c158..3d87fd8c8 100644
--- a/A00_Common/design/design_shared.ts
+++ b/A00_Common/design/design_shared.ts
@@ -29,6 +29,19 @@ import { saveDesign, type DesignSaveStep } from "./design_save";
 import { markDesignClean } from "./design_leave";
 import { resetDesign } from "./design_reset";
 import type { DesignView } from "./design_dock";
+import { routeDraftBridge, type PagePipelineOptions } from "./design_pipeline_page";
+import { SECTION_STATION_INTERVAL_M } from "../../B05_Profile/logic/B05_Profile_Sections_Stations";
+import {
+  applyStructureAreaRows,
+  structureAreaRows,
+} from "../../B06_Section/B06_Section_Structure_Layouts";
+import {
+  holdSectionDetail,
+  restoreSectionDetail,
+  swapSectionStations,
+} from "../../B06_Section/B06_Section_Section_Store";
+import { refreshCrossDesigns } from "../../B06_Section/B06_Section_Cross_Refresh";
+import { detailCross } from "../../B05_Profile/logic/B05_Profile_Pipeline_Detail";
 
 function L(key: keyof typeof ui_locales): string {
   return ui_locales[key][currentLanguageIndex];
@@ -62,6 +75,8 @@ export interface DesignViewBinding {
   onReset?: () => void;
   /** 다른 보기가 고친 관 옵션을 이 보기 캐시(횡단 스펙)에 얹는다. */
   onPipeOptions?: (chainageM: number, patch: Record<string, number | string>) => void;
+  /** 계산 묶음 알림 — 묶음은 페이지가 세움(365-1) · 보기는 알림만 받음. */
+  pipeline?: Pick<PagePipelineOptions, "onCorridorStale" | "onFacilitiesFollowed">;
 }
 
 /** 한 벌 자리 — 페이지(`design_page`)가 만들어 두 보기에 같은 객체로 넘긴다. */
@@ -182,9 +197,48 @@ export function sharedProfile(shared: DesignPageShared): DesignProfile {
   attachProfilePopout(profile, shared.profileSlot, popoutButton);
   attachSubPanelPopouts(profile);
   shared.profile = profile;
+  if (shared.projectId) startPagePipeline(shared, profile);
   return profile;
 }
 
+/** 계산 묶음 한 벌(365-1) — 종단도와 함께 페이지가 세움 · B05 · B06 어느 쪽으로 들어와도(새로고침도) 노선
+ *  초안을 셈. 편집기는 `routeDraftBridge` 로 이 다리를 받아 씀 · 보기 몫 알림은 `pipeline` 바인딩으로. */
+function startPagePipeline(shared: DesignPageShared, profile: DesignProfile): void {
+  const projectId = shared.projectId;
+  const each = (fn: (hooks: NonNullable<DesignViewBinding["pipeline"]>) => void): void =>
+    Object.values(shared.bindings).forEach((binding) => binding?.pipeline && fn(binding.pipeline));
+  routeDraftBridge(projectId, profile, {
+    stationIntervalM: SECTION_STATION_INTERVAL_M,
+    onCorridorStale: () => each((hooks) => hooks.onCorridorStale?.()),
+    onFacilitiesFollowed: (far) => each((hooks) => hooks.onFacilitiesFollowed?.(far)),
+    onUnstable: () => showToast(L("Design_Pipeline_Unstable"), "warning"),
+    // 저장 노선 횡단 = 다시 셈 창구 한 벌(365-4) — 카드 · 유토곡선 · [저장] 패치가 보는 상세 설계를 고치고 그 값을
+    // 묶음 출력으로(발자국 · 평면 횡단 판) · 측점이 상세와 다르면(갈아끼움 전) 묶음 엔진
+    savedCross: async (detail, routeId, stations) => {
+      if (!detailCross(detail, stations)) return null;
+      const edits = profile.pipelineSource().edits;
+      const updated = await refreshCrossDesigns({ projectId, routeId, detail, edits });
+      if (updated.length) toAll(shared, "onCrossDesignsUpdated")(updated);
+      profile.redraw();
+      return detailCross(detail, stations);
+    },
+    structureAreas: ({ cross_sections: rows }) =>
+      applyStructureAreaRows(rows, structureAreaRows(rows)),
+    // 초안 시작 — 초안 전 상태를 떠 둠 · 버리면 그대로(측점이 달라도 · 349-0o) · 상세가 없으면 묶음 측점으로 갈아끼움
+    holdDraft: (routeId, saved) => {
+      const hold = saved && holdSectionDetail(projectId, routeId, saved);
+      return async (stations) => {
+        if (!hold) {
+          await swapSectionStations(projectId, routeId, stations);
+          return "no-saved";
+        }
+        const back = await restoreSectionDetail(projectId, routeId, hold, stations);
+        return !back ? "no-cache" : back.same ? "saved" : "saved-diff";
+      };
+    },
+  });
+}
+
 /** 「구조물 배치」 폼 한 벌 — 알림은 지금 보기로, 상세 옵션은 횡단 보기에서만 그린다. */
 export function sharedStructures(shared: DesignPageShared): StructuresSection {
   if (shared.structures) return shared.structures;
diff --git a/A00_Common/design/design_view_cross.ts b/A00_Common/design/design_view_cross.ts
index 85da53112..8d9063801 100644
--- a/A00_Common/design/design_view_cross.ts
+++ b/A00_Common/design/design_view_cross.ts
@@ -225,11 +225,11 @@ export async function mountCrossView(
     const seq = ++structuresRefreshSeq; // 잇단 조작 — 최신 요청만 그림(54-4)
     if (savingDesign(projectId)) return; // 저장 도중 = 낡은 캐시 · 빈 초안 — 저장 뒤 한 번(323-9)
     try {
+      await new Promise((next) => setTimeout(next, 0)); // 겹친 신호(갈아끼움 · 묶음 · 초안) = 한 번(365-4)
       const fresh = await loadSectionDetail(projectId, currentRouteId);
       if (seq !== structuresRefreshSeq) return;
       sectionDetail = fresh;
-      // 면적을 **먼저** 다시 얹는다 — 유토곡선은 카드보다 앞서 계산되므로, 카드 렌더가
-      // 고치는 것만으로는 곡선이 옛 면적으로 남는다(2026-09-06 실측).
+      // 면적을 **먼저** 다시 얹는다 — 유토곡선은 카드보다 앞서 셈(카드만 고치면 곡선이 옛 면적 · 2026-09-06 실측).
       if (sectionDetail) {
         applyStructureAreaRows(
           sectionDetail.cross_sections,
diff --git a/A00_Common/design/design_view_profile.ts b/A00_Common/design/design_view_profile.ts
index 2293d6b97..7334d380c 100644
--- a/A00_Common/design/design_view_profile.ts
+++ b/A00_Common/design/design_view_profile.ts
@@ -48,16 +48,7 @@ import {
   rememberStandardDefaults,
 } from "../../B06_Section/B06_Section_UI_Standard_Panel";
 import { fetchSectionContext } from "../../B06_Section/B06_Section_Api_Fetch";
-import {
-  applyStructureAreaRows,
-  structureAreaRows,
-} from "../../B06_Section/B06_Section_Structure_Layouts";
-import {
-  holdSectionDetail,
-  invalidateSectionDetail,
-  restoreSectionDetail,
-  swapSectionStations,
-} from "../../B06_Section/B06_Section_Section_Store";
+import { invalidateSectionDetail } from "../../B06_Section/B06_Section_Section_Store";
 import {
   onStaleStructureTypes,
   structureAnchorM,
@@ -419,6 +410,11 @@ export async function mountProfileView(
   bindDesignView(shared, "profile", {
     save: profileSaveParts(actionContext),
     onReset: () => uphillOverrides.clear(),
+    // 계산 묶음(페이지 몫 · 365-1) 알림 중 종단 보기 몫 — 3D 「낡음」 · 관 · 구조물 따라감
+    pipeline: {
+      onCorridorStale: () => sections.setCorridorPending(true),
+      onFacilitiesFollowed: followFacilities,
+    },
   });
 
   // 탭이 다시 보일 때 정의 판이 바뀌었으면 종류 · 패널 다시 읽음(322-0)
@@ -539,27 +535,8 @@ export async function mountProfileView(
       smooth: latestResponse.surface_params.smooth,
       tools: [view3d.modal.button],
       recommend: panel.recommend,
-      // 계산 묶음(346-1) — 노선을 고칠 때마다 종단이 따라옴(미리보기 · [저장]이 정본).
-      draft: routeDraftBridge(activeProjectId, profilePanel, {
-        stationIntervalM: panel.values().stationInterval ?? undefined,
-        onCorridorStale: () => sections.setCorridorPending(true),
-        onFacilitiesFollowed: followFacilities,
-        structureAreas: ({ cross_sections: rows }) =>
-          applyStructureAreaRows(rows, structureAreaRows(rows)),
-        // 초안 시작 — 초안 전 상태를 떠 둠 · 버리면 그대로(측점이 달라도 · 349-0o) · 상세가 없으면(초안 둔 채
-        // 새로고침) 묶음 측점으로 갈아끼움
-        holdDraft: (routeId, saved) => {
-          const hold = saved && holdSectionDetail(activeProjectId, routeId, saved);
-          return async (stations) => {
-            if (!hold) {
-              await swapSectionStations(activeProjectId, routeId, stations);
-              return "no-saved";
-            }
-            const back = await restoreSectionDetail(activeProjectId, routeId, hold, stations);
-            return !back ? "no-cache" : back.same ? "saved" : "saved-diff";
-          };
-        },
-      }),
+      // 계산 묶음(346-1) — 페이지가 세운 다리(365-1) · 노선을 고칠 때마다 종단이 따라옴(미리보기 · [저장]이 정본).
+      draft: routeDraftBridge(activeProjectId, profilePanel),
     });
 
     // ③ 종단면·횡단 자료 — 하단 패널을 3D보다 먼저 채운다.
diff --git a/A00_Common/design/logic/design_pipeline_stations.ts b/A00_Common/design/logic/design_pipeline_stations.ts
index 9dc61c492..fcd29e639 100644
--- a/A00_Common/design/logic/design_pipeline_stations.ts
+++ b/A00_Common/design/logic/design_pipeline_stations.ts
@@ -14,7 +14,13 @@ import type {
   PlanStructure,
   PlanType,
 } from "../../../common_util/common_util_structure_station";
-import type { PipelineStation, StageContext, StageFn } from "./design_pipeline_types";
+import type {
+  PipelineRunRecord,
+  PipelineStation,
+  StageContext,
+  StageFn,
+} from "./design_pipeline_types";
+import type { SectionDetailResponse } from "../../../B06_Section/B06_Section_Api_Fetch";
 
 /** 범위 밖 측점은 앞 값(같은 열쇠 · 같은 자리)을 그대로 — 뒤 단계가 같은 객체로 「안 바뀜」을 앎. */
 export function reuseOutside(
@@ -54,3 +60,19 @@ export function createStationsStage(
     return reuseOutside(next, ctx.prev, ctx.range);
   };
 }
+
+/** 상세 측점 대 묶음 측점(1 mm) — 같으면 null · 다르면 첫 다른 자리 · 개수(묶음 기록 `restoreDiff`). */
+export function stationDiff(
+  detail: SectionDetailResponse,
+  stations: ReadonlyArray<PipelineStation>,
+): NonNullable<PipelineRunRecord["restoreDiff"]> | null {
+  const saved = detail.cross_sections.map((section) => section.chainage_m);
+  const n = Math.max(saved.length, stations.length);
+  for (let i = 0; i < n; i += 1) {
+    const pipelineM = stations[i]?.chainageM ?? null;
+    if (saved[i] !== undefined && pipelineM !== null && Math.abs(saved[i] - pipelineM) < 1e-3)
+      continue;
+    return { savedM: saved[i] ?? null, pipelineM, saved: saved.length, pipeline: stations.length };
+  }
+  return null;
+}
diff --git a/A00_Common/design/logic/design_profile_free.ts b/A00_Common/design/logic/design_profile_free.ts
index 4bb03c965..c658fca63 100644
--- a/A00_Common/design/logic/design_profile_free.ts
+++ b/A00_Common/design/logic/design_profile_free.ts
@@ -4,7 +4,8 @@
  *
  * 흐름: 세로 측점선 둘로 범위를 고름 → 시작(또는 끝) 세로선 근처 클릭 = 그 측점 계획고에 이은
  * 채 시작 → 클릭마다 점 하나(가로 = 범위 안 가장 가까운 측점선 · 높이 = 클릭한 높이) → 반대쪽
- * 세로선 근처 클릭 또는 Enter = 그 측점 계획고에 이어 끝. Esc = 취소 · Backspace = 마지막 점 빼기.
+ * 세로선 근처 클릭 또는 Enter = 그 측점 계획고에 이어 끝. Esc = 취소 · ↶ ↷(Backspace = ↶) =
+ * 자유지정 안 한 걸음씩(범위 · 시작 · 점 · 367-3) — 큰 이력과 따로 · 끝나면 큰 이력 한 걸음.
  *
  * 적용은 직선화와 같은 길 — 편집 델타(`station_offsets` · `curve_radii`)만 만들어 캐시에 쓰고
  * [저장] 때 서버가 다시 셈한다. 꺾이는 점 종단곡선 = 직선화 틸팅과 같은 기본 길이 L
@@ -181,8 +182,8 @@ export interface FreeDrawDeps {
   base: () => AlignmentBase | null;
   alignment: () => ProfileAlignment | null;
   edits: () => AlignmentEdits;
-  /** 편집 적용 — 직선화 결과와 같은 길(캐시 · 되돌리기 · 막기 규칙). */
-  apply: (next: AlignmentEdits) => void;
+  /** 편집 적용 — 직선화 결과와 같은 길(캐시 · 되돌리기 · 막기 규칙). false = 막힘(열린 채). */
+  apply: (next: AlignmentEdits) => boolean | void;
   /** 모드를 끈다(적용 뒤 · Esc). */
   close: () => void;
   /** 단계 · 안내가 바뀜. */
@@ -198,6 +199,11 @@ export interface FreeDraw {
   hover: (pointer: { chainageM: number; elevationM: number; stations: number[] } | null) => void;
   /** Enter · Escape · Backspace — 먹었으면 true. */
   key: (key: string) => boolean;
+  /** 자유지정 안 한 걸음 되돌림 · 다시함(367-3) — 큰 이력과 따로. */
+  undo: () => void;
+  redo: () => void;
+  canUndo: () => boolean;
+  canRedo: () => boolean;
   marks: () => FreeMarks;
   hint: () => string;
 }
@@ -209,6 +215,25 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
   let anchor: number | null = null;
   let points: FreeVertex[] = [];
   let target: FreeVertex | null = null;
+  /** 자유지정 안 이력(367-3) — 상태 바뀐 클릭만 쌓음 · 새 클릭이 future 비움. */
+  interface Snap {
+    phase: FreePhase;
+    pending: number | null;
+    range: [number, number] | null;
+    anchor: number | null;
+    points: FreeVertex[];
+  }
+  let past: Snap[] = [];
+  let future: Snap[] = [];
+  const snap = (): Snap => ({ phase, pending, range, anchor, points: [...points] });
+  function step(from: Snap[], to: Snap[]): void {
+    const state = from.pop();
+    if (!state) return;
+    to.push(snap());
+    ({ phase, pending, range, anchor, points } = state);
+    target = null;
+    deps.changed();
+  }
 
   function reset(): void {
     phase = "range";
@@ -217,6 +242,8 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
     anchor = null;
     points = [];
     target = null;
+    past = [];
+    future = [];
   }
 
   /** 그 측점의 지금 계획고(변화점이면 라운드 중심 z — 직선화와 같은 값). */
@@ -263,8 +290,9 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
     if (!base || end === null || z === null) return;
     const vertices = [...path(), { chainage_m: end, elevation_m: z }];
     const next = buildFreeEdits(base, deps.edits(), vertices);
+    // 막히면(기울기 · 흙덮기) 자유지정 열린 채 — 그린 점 그대로(367-3)
+    if (deps.apply(next) === false) return;
     reset();
-    deps.apply(next);
     deps.close();
   }
 
@@ -272,6 +300,7 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
     phase: () => phase,
     reset,
     click(chainageM, elevationM, stations) {
+      const before = snap();
       if (phase === "range") {
         const station = snapStation(stations, chainageM);
         if (station === null) return true;
@@ -297,6 +326,10 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
         }
         points.push(next);
       }
+      if (JSON.stringify(snap()) !== JSON.stringify(before)) {
+        past.push(before);
+        future = [];
+      }
       target = null;
       deps.changed();
       return true;
@@ -316,18 +349,16 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
         return true;
       }
       if (key === "Backspace") {
-        if (phase !== "drawing") return false;
-        if (points.length) points.pop();
-        else {
-          anchor = null;
-          phase = "armed";
-        }
-        target = null;
-        deps.changed();
+        if (!past.length) return false;
+        step(past, future);
         return true;
       }
       return false;
     },
+    undo: () => step(past, future),
+    redo: () => step(future, past),
+    canUndo: () => past.length > 0,
+    canRedo: () => future.length > 0,
     marks() {
       const maxPct = deps.base()?.policy.max_grade_pct ?? Number.POSITIVE_INFINITY;
       const dots = path();
@@ -357,7 +388,7 @@ export function createFreeDraw(deps: FreeDrawDeps): FreeDraw {
           : `${pending.toFixed(1)}m 선택 — 범위 끝 세로 측점선을 고르세요`;
       }
       if (phase === "armed") return "시작(또는 끝) 세로선 근처를 눌러 시작하세요 (Esc 취소)";
-      return "클릭마다 점 · 반대쪽 세로선 또는 Enter 로 끝 (Backspace 점 빼기 · Esc 취소)";
+      return "클릭마다 점 · 반대쪽 세로선 또는 Enter 로 끝 (↶ · Backspace 되돌리기 · Esc 취소)";
     },
   };
 }
diff --git a/B03_FileInput/B03_FileInput_Email.py b/B03_FileInput/B03_FileInput_Email.py
index 4da466963..2c273837a 100644
--- a/B03_FileInput/B03_FileInput_Email.py
+++ b/B03_FileInput/B03_FileInput_Email.py
@@ -218,14 +218,14 @@ async def send_initial_analysis_complete_email(
         {design_rows}
       </div>
       <div class="notice">
-        기본값으로 계산한 결과입니다. 종단설계 화면에서 검토·수정한 뒤 횡단설계에서
+        기본값으로 계산한 결과입니다. 노선설계 화면에서 검토·수정한 뒤 횡단설계에서
         [확정]을 누르면 다음 단계(수량 산출)로 넘어갑니다.
       </div>
         """
     else:
         design_block = """
       <div class="notice">
-        초기 노선·종횡단 자동 계산은 완료되지 않았습니다. 종단설계 화면에서 직접
+        초기 노선·종횡단 자동 계산은 완료되지 않았습니다. 노선설계 화면에서 직접
         경로를 계산해 주세요.
       </div>
         """
@@ -239,7 +239,7 @@ async def send_initial_analysis_complete_email(
       </div>
       {design_block}
       <p style="text-align: center; margin: 26px 0;">
-        <a class="button" href="{html.escape(result_url)}">종단설계 화면 열기</a>
+        <a class="button" href="{html.escape(result_url)}">노선설계 화면 열기</a>
       </p>
       <p style="color:#6b7280;font-size:13px;">
         로그인이 필요한 경우 인증 후 같은 화면으로 이동합니다.
diff --git a/B03_FileInput/B03_FileInput_Service_Chain.py b/B03_FileInput/B03_FileInput_Service_Chain.py
index c4902a77c..afdcc4f3f 100644
--- a/B03_FileInput/B03_FileInput_Service_Chain.py
+++ b/B03_FileInput/B03_FileInput_Service_Chain.py
@@ -105,7 +105,7 @@ async def _prepare_drainage_pipes_and_reprofile(
 
         marks.append(("배수유역 분석", time.perf_counter()))
 
-        # 2) 기본 관(도로 × 상류 세류선) + 최대 간격 자동 보충을 정본으로 저장한다.
+        # 2) 기본 관(도로 × 상류 세류선 교차)만 정본으로 저장한다 — 간격 보충은 [자동 제안](369).
         pipes = await put_pipe_points(project_id, None)
         if isinstance(pipes, JSONResponse):
             logger.error(
diff --git a/B04_PreProcess/B04_PreProcess_Api_Fetch.ts b/B04_PreProcess/B04_PreProcess_Api_Fetch.ts
index b406cc303..89744f458 100644
--- a/B04_PreProcess/B04_PreProcess_Api_Fetch.ts
+++ b/B04_PreProcess/B04_PreProcess_Api_Fetch.ts
@@ -620,14 +620,16 @@ export async function fetchDetailPipePoints(projectId: string): Promise<DetailBa
 
 /** 편집 중인 관 목록으로 세부유역을 다시 나눈다(저장하지 않는다).
  *
- *  빈 목록 = 관 0개(312) · 기본 관 + 자동 보충으로 되돌리기는 `resetDetailPipePoints`(DELETE)만. */
+ *  빈 목록 = 관 0개(312) · null = 세류선 교차 관만(369) · `auto`([자동 제안]) = "all" 전체 자동
+ *  (같은 자리 관은 속성 유지) · "add" 지금 관 + 빈 구간 보충. */
 export async function computeDetailBasins(
   projectId: string,
-  points: DetailPipeInput[],
+  points: DetailPipeInput[] | null,
+  auto?: "all" | "add",
 ): Promise<DetailBasinResponse> {
   return requestJson<DetailBasinResponse>(`/projects/${projectId}/drainage/detail-basins`, {
     method: "POST",
-    body: JSON.stringify({ points }),
+    body: JSON.stringify(auto ? { points, auto } : { points }),
   });
 }
 
diff --git a/B04_PreProcess/B04_PreProcess_Engine_Watershed_Analyze.py b/B04_PreProcess/B04_PreProcess_Engine_Watershed_Analyze.py
index 4d8981143..eb44d6739 100644
--- a/B04_PreProcess/B04_PreProcess_Engine_Watershed_Analyze.py
+++ b/B04_PreProcess/B04_PreProcess_Engine_Watershed_Analyze.py
@@ -342,7 +342,7 @@ def build_flow_arrows(analysis: Any, flow: Any) -> list[tuple[float, float, floa
 def _base_pipes(
     vertices: list[RouteVertex], stream_features: list[dict[str, Any]]
 ) -> list[StructureCandidate]:
-    """도로 × 세류선 교차점을 기본 관 위치로 삼는다. 300m 보충 배치는 다음 단계다."""
+    """도로 × 세류선 교차점을 기본 관 위치로 삼는다. 간격 보충은 [자동 제안] 때만(369)."""
     pipes: list[StructureCandidate] = []
     for candidate in find_stream_crossings(vertices, stream_features):
         if pipes and candidate.chainage_m - pipes[-1].chainage_m < DRAINAGE_PIPE_MIN_SPACING_M:
diff --git a/B04_PreProcess/B04_PreProcess_Router_Basins.py b/B04_PreProcess/B04_PreProcess_Router_Basins.py
index 2b27942d4..d4a6f9726 100644
--- a/B04_PreProcess/B04_PreProcess_Router_Basins.py
+++ b/B04_PreProcess/B04_PreProcess_Router_Basins.py
@@ -2,7 +2,7 @@
 
 격자 해석은 하지 않는다. 배수유역 분석이 저장해 둔 `03_road_routing` 산출물을 읽어
 
-  · 기본 관(도로 × 상류 세류선 교차점) + 최대 간격 자동 보충으로 관 목록을 만들고
+  · 기본 관(도로 × 상류 세류선 교차점)으로 관 목록을 만들고([자동 제안] = 최대 간격 보충 · 369)
   · 계획노선 종단 Z로 노면 물이 어느 관으로 가는지 정해 세부유역을 나눈다
 
 계산 알고리즘은 B05 사용자 화면과 공용이다(`common_util_drainage_detail`) — 같은 이름의
@@ -67,6 +67,9 @@ router = APIRouter(prefix="/api/projects", tags=["B04 Surface Drainage Basins"])
 
 _NO_ANALYSIS = "배수유역 분석 결과가 없습니다. [유역 분석]을 먼저 실행하세요."
 # 노선 지문이 분석 때와 다름(옛 저장분은 지문 없음) — 옛 격자로 나누면 틀린 유역이 나온다(342-3).
+# 머리 「배수유역 낡음」 = 화면 `STALE_PREFIX`(B05 Drainage_Live · 369) 짝.
+# [자동 제안] 방식(369) — None = 지금 목록 그대로(없으면 세류선 교차만) · all · add
+AUTO_MODES = (None, "all", "add")
 STALE_MESSAGE = (
     "배수유역 낡음 — 노선이 분석 때와 다릅니다. 유역을 다시 분석해야 세부 유역을 나눕니다."
 )
@@ -78,20 +81,22 @@ def _build(
     points: list[PipePoint] | None,
     routing: Any = None,
     upstream_lonlat: list | None = None,
+    auto: str | None = None,
 ) -> tuple[DrainageDetail | None, list[PipePoint]]:
     """세부유역을 계산하고, 그 결과에 쓰인 관 목록을 함께 돌려준다.
 
-    `points`가 None 이면 B04 기본 관에 최대 간격 규칙으로 자동 보충한 목록이 만들어진다.
-    있으면 그 자리를 그대로 쓰되, 관이 왜 거기 있는지(기본/자동/수동)는 넘겨받은 목록의
-    표시를 유지한다 — 계산기는 확정 좌표만 보므로 그대로 두면 전부 "수동"이 된다.
+    `points`가 None 이면 B04 기본 관(세류선 교차)만. 있으면 그 자리를 그대로 쓰되, 관이 왜 거기
+    있는지(기본/자동/수동)는 넘겨받은 목록의 표시를 유지한다 — 계산기는 확정 좌표만 보므로 그대로
+    두면 전부 "수동"이 된다. `auto`([자동 제안] · 369) = "all" 자리 새로 · "add" 빈 구간 보충 —
+    같은 자리(0.05 m) 관만 속성 · id 를 이어받고 나머지는 새 관(등록부 기본값).
     """
     directory = drainage_dir(stored_path)
     chainages = [point.chainage_m for point in points] if points is not None else None
-    detail = build_detail(directory, context.vertices, chainages, routing, upstream_lonlat)
+    detail = build_detail(directory, context.vertices, chainages, routing, upstream_lonlat, auto)
     if detail is None:
         return None, []
     if points is not None:
-        _retag(detail.pipes, points)
+        _retag(detail.pipes, points, keep_new=auto is not None)
     rebuilt = _rebuilt(detail)
     # 원본에 없던 자리 = 이번에 새로 놓인 관(자동 배치 · 간격 보충) — 등록부 기본값을 받을 관
     fresh = [
@@ -132,11 +137,14 @@ _DETAIL_CACHE_SIZE = 4
 DETAIL_CACHE_FILENAME = "04_detail_cache.pkl"
 
 
-def _detail_key(context: DrainageContext, points: list[PipePoint] | None) -> str:
+def _detail_key(
+    context: DrainageContext, points: list[PipePoint] | None, auto: str | None = None
+) -> str:
     directory = drainage_dir(context.stored_path)
     digest = hashlib.sha1(usedforsecurity=False)
     listed = None if points is None else [point.as_dict() for point in points]
-    digest.update(json.dumps(listed, sort_keys=True, ensure_ascii=False).encode())
+    # auto 를 열쇠에 — 같은 관 목록이라도 [자동 제안] 결과와 섞이지 않게(369 · 옛 저장본도 비껴감)
+    digest.update(json.dumps([listed, auto], sort_keys=True, ensure_ascii=False).encode())
     for vertex in context.vertices:
         digest.update(f"{vertex.x:.3f},{vertex.y:.3f},{vertex.z:.3f};".encode())
     routing = STAGES["road_routing"]
@@ -167,10 +175,10 @@ def _remember(key: str, value: tuple[DrainageDetail, list[PipePoint]]) -> None:
 
 
 def _build_cached(
-    context: DrainageContext, points: list[PipePoint] | None
+    context: DrainageContext, points: list[PipePoint] | None, auto: str | None = None
 ) -> tuple[DrainageDetail | None, list[PipePoint]]:
     """`_build` + 저장본 — 관 목록은 사본으로 돌려준다(저장이 좌표를 채워도 저장본은 그대로)."""
-    key = _detail_key(context, points)
+    key = _detail_key(context, points, auto)
     hit = _DETAIL_CACHE.get(key)
     if hit is None:
         try:
@@ -180,7 +188,7 @@ def _build_cached(
         except (OSError, pickle.PickleError, EOFError, AttributeError, KeyError, TypeError):
             hit = None
     if hit is None:
-        detail, carried = _build(context.stored_path, context, points)
+        detail, carried = _build(context.stored_path, context, points, auto=auto)
         if detail is None:
             return None, []
         hit = (detail, carried)
@@ -276,8 +284,20 @@ def ford_height_m(flow_m3s: float | None, width_m: float) -> float | None:
     return math.ceil(depth * 100 - 1e-9) / 100
 
 
-def _retag(pipes: list[StructureCandidate], points: list[PipePoint]) -> None:
-    """확정 좌표로 되돌아온 관에 원래의 생성 사유를 다시 붙인다."""
+def _retag(
+    pipes: list[StructureCandidate], points: list[PipePoint], keep_new: bool = False
+) -> None:
+    """확정 좌표로 되돌아온 관에 원래의 생성 사유를 다시 붙인다.
+
+    `keep_new`([자동 제안]) = 같은 자리(0.05 m) 관만 · 새로 놓인 관은 계산기 사유
+    (stream · spacing) 그대로.
+    """
+    if keep_new:
+        picks = carry_indices([pipe.chainage_m for pipe in pipes], [p.chainage_m for p in points])
+        for pipe, pick in zip(pipes, picks):
+            if pick is not None:
+                pipe.reason = points[pick].source
+        return
     by_chainage = {round(point.chainage_m, 2): point.source for point in points}
     for pipe in pipes:
         source = by_chainage.get(round(pipe.chainage_m, 2))
@@ -452,11 +472,16 @@ async def _resolve(
     돌려준다 — 관 목록도 없으면(자동 생성 자리) 409(342-3). 마지막 값 = 낡음.
 
     빈 목록(`[]`)은 「관 0개」로 그대로 쓴다 — 자동 생성은 요청에 칸이 없고 저장분도 없을(None) 때만(312).
+    요청 `auto`([자동 제안] · 369) = "all" · "add" — `_build` 참고 · 없으면 None.
     """
     context, reason = await load_drainage_context(project_id)
     if context is None:
         return JSONResponse(status_code=404, content={"status": "error", "message": reason})
 
+    auto = (payload or {}).get("auto")
+    if auto not in AUTO_MODES:
+        message = f"auto 는 {', '.join(m for m in AUTO_MODES if m)} 중 하나입니다."
+        return JSONResponse(status_code=400, content={"status": "error", "message": message})
     try:
         raw = (payload or {}).get("points")
         requested = None if raw is None else parse_pipe_points(raw)
@@ -470,7 +495,7 @@ async def _resolve(
     saved = requested is None and stored is not None
 
     if analysis_route_signature(context.stored_path) != signature:
-        if points is None:
+        if points is None or auto is not None:  # 자동 자리 = 지금 노선 분석이 있어야(369)
             return JSONResponse(
                 status_code=409, content={"status": "stale", "message": STALE_MESSAGE}
             )
@@ -479,9 +504,11 @@ async def _resolve(
 
     # [저장]은 정본으로 다시 셈 — 저장본은 GET · POST 만
     if fresh:
-        result = await asyncio.to_thread(_build, context.stored_path, context, points)
+        result = await asyncio.to_thread(
+            lambda: _build(context.stored_path, context, points, auto=auto)
+        )
     else:
-        result = await asyncio.to_thread(_build_cached, context, points)
+        result = await asyncio.to_thread(_build_cached, context, points, auto)
     detail, resolved = result
     if detail is None:
         return JSONResponse(status_code=404, content={"status": "error", "message": _NO_ANALYSIS})
@@ -511,8 +538,9 @@ async def post_detail_basins(
 ) -> dict[str, Any] | JSONResponse:
     """화면에서 편집 중인 관 목록으로 세부유역을 다시 나눈다(저장하지 않는다).
 
-    `points` 칸 없이 부르면 저장분을 무시하고 기본 관 + 자동 보충으로 되돌린다 —
-    노선이 바뀌어 전체 분석을 다시 돌린 직후의 경로다. 빈 목록은 관 0개(312).
+    `points` 칸 없이 부르면 저장분을 무시하고 기본 관(세류선 교차)만으로 되돌린다 —
+    [배관 배치 초기화] · 노선이 바뀌어 전체 분석을 다시 돌린 직후의 경로다. 빈 목록은 관 0개(312).
+    `auto` = [자동 제안](369) — "all" 전체 자동 · "add" 지금 관 + 빈 구간 보충.
     """
     resolved = await _resolve(project_id, payload, use_stored=False)
     if isinstance(resolved, JSONResponse):
@@ -523,7 +551,7 @@ async def post_detail_basins(
 
 @router.delete("/{project_id}/drainage/pipe-points", response_model=None)
 async def delete_pipe_points(project_id: UUID) -> dict[str, Any] | JSONResponse:
-    """저장된 관 지점을 버리고 기본 관 + 자동 보충 배치로 되돌린다("초기화").
+    """저장된 관 지점을 버리고 기본 관(세류선 교차) 배치로 되돌린다("초기화").
 
     화면만 되돌리면 다시 들어왔을 때 옛 관이 살아난다 — 저장분과 파생 산출물까지 지운다
     (2026-08-02 사용자 보고).
diff --git a/B04_PreProcess/B04_PreProcess_Router_Watershed_Live.py b/B04_PreProcess/B04_PreProcess_Router_Watershed_Live.py
index 471da8f43..1ec330489 100644
--- a/B04_PreProcess/B04_PreProcess_Router_Watershed_Live.py
+++ b/B04_PreProcess/B04_PreProcess_Router_Watershed_Live.py
@@ -22,7 +22,7 @@ from fastapi.responses import JSONResponse
 from B04_PreProcess.B04_PreProcess_Engine_Watershed_Analyze import preview_stages
 from B04_PreProcess.B04_PreProcess_Engine_Watershed_Expand import AnalysisStopped
 from B04_PreProcess.B04_PreProcess_Engine_Watershed_Export import drainage_dir
-from B04_PreProcess.B04_PreProcess_Router_Basins import _build, _payload
+from B04_PreProcess.B04_PreProcess_Router_Basins import AUTO_MODES, _build, _payload
 from B04_PreProcess.B04_PreProcess_Router_Watershed import _prepare, router
 from common_util.common_util_drainage_context import _open_sampler, load_drainage_context
 from common_util.common_util_drainage_detail import RoadRouting
@@ -78,7 +78,8 @@ def live_routing(preview: Any, route_xy: list[tuple[float, float]], to_lonlat: A
 async def post_drainage_live(
     project_id: UUID, payload: dict[str, Any] | None = None
 ) -> dict[str, Any] | JSONResponse:
-    """몸통 = {generation, route: RouteDraft | null(저장 노선), points: 관 목록 | null(자동)}."""
+    """몸통 = {generation, route: RouteDraft | null(저장 노선),
+    points: 관 목록 | null(세류선 교차만), auto: [자동 제안] 방식(all · add · 369) | 없음}."""
     body = payload or {}
     generation = int(body.get("generation") or 0)
     key = str(project_id)
@@ -87,6 +88,9 @@ async def post_drainage_live(
     def superseded() -> bool:
         return _LATEST_GENERATION.get(key) != generation
 
+    auto = body.get("auto")
+    if auto not in AUTO_MODES:
+        return JSONResponse(status_code=400, content={"status": "error", "message": "auto 틀림"})
     try:
         raw = body.get("points")
         points = None if raw is None else parse_pipe_points(raw)
@@ -139,7 +143,7 @@ async def post_drainage_live(
         [list(to_lonlat(x, y)) for x, y in line.coords] for line in preview.region.split.upstream
     ]
     detail, carried = await asyncio.to_thread(
-        _build, context.stored_path, live, points, routing, upstream
+        lambda: _build(context.stored_path, live, points, routing, upstream, auto=auto)
     )
     if detail is None:
         return JSONResponse(
diff --git a/B05_Profile/B05_Profile_Api_Replan.ts b/B05_Profile/B05_Profile_Api_Replan.ts
index d8e10a59b..9379b468f 100644
--- a/B05_Profile/B05_Profile_Api_Replan.ts
+++ b/B05_Profile/B05_Profile_Api_Replan.ts
@@ -129,8 +129,8 @@ export interface RouteReplanResponse {
   route_id: number | null;
   total_length_m: number | null;
   vertex_count?: number;
-  /** 노선 저장 결과(346-3 · 서버 `B05_Profile_Route_Save` 머리) — 관 지킴 · 새 교차 · 오목 보충. */
-  pipes?: { kept: number; crossing: number; concave: number };
+  /** 노선 저장 결과(346-3 · 서버 `B05_Profile_Route_Save` 머리) — 관 지킴 · 새 교차. */
+  pipes?: { kept: number; crossing: number };
   structures?: { moved: number; far: number };
   /** 새 노선에 못 넘긴 횡단 고침(측점이 사라짐) 수. */
   cross_dropped?: number;
@@ -229,7 +229,7 @@ export async function fetchRouteElevations(
   return payload.z;
 }
 
-/** 횡단 미리보기 한 장 — 고치던 노선 그대로 그 측점만 서버가 셈해 준다(계획서 0-9 ⑧). */
+/** 횡단 미리보기 한 장(평면 오른쪽 판) — 계산 묶음 그 측점을 이 꼴로 그림(365-3 · 서버 길 없음). */
 export interface CrossPreviewResponse {
   status: string;
   chainage_m: number;
@@ -241,7 +241,7 @@ export interface CrossPreviewResponse {
   cross_half_width_m: number;
   /** 원지반 횡단 샘플. */
   samples: Array<{ offset_m?: number; elevation_m?: number | null; valid: boolean }>;
-  /** 기본 계획 횡단 — B06 `compute_cross_design` 이 낸 것. 계획고를 못 세우면 null. */
+  /** 계획 횡단 — 묶음 cross 단계 설계(B06 카드와 같음). 계획고를 못 세우면 null. */
   design: {
     design_line: Array<{ offset_m: number; elevation_m: number }>;
     cut_area_m2: number;
@@ -250,32 +250,6 @@ export interface CrossPreviewResponse {
   } | null;
 }
 
-export interface CrossPreviewRequest {
-  vertices: Array<{ x: number; y: number; curve: boolean; radius_m: number | null }>;
-  chainage_m: number;
-  min_radius_m: number;
-  station_interval_m: number;
-  /** 횡단 반폭(m) — 없으면 서버 기본값. */
-  cross_half_width_m?: number;
-  /** [측점 스냅] 켬 — 호 안 측점 하나를 곡선 중점으로(요구 224-2). */
-  station_snap?: boolean;
-}
-
-/** 한 측점 횡단을 묻는다. 종·횡단을 한 번 돌리므로 **한두 초** 걸린다(사용자 확정: 괜찮음). */
-export async function fetchCrossPreview(
-  projectId: string,
-  request: CrossPreviewRequest,
-): Promise<CrossPreviewResponse> {
-  return requestJson<CrossPreviewResponse>(
-    `/projects/${projectId}/route/cross-preview`,
-    {
-      method: "POST",
-      body: JSON.stringify({ ...request, terrain: analysisTerrain(projectId) }),
-    },
-    120000,
-  );
-}
-
 /** 계획노선을 예상노선으로 되돌리고 같은 재계산을 돈다(노선 초기화). */
 export async function resetRoutePlan(projectId: string): Promise<RouteReplanResponse> {
   return requestJson<RouteReplanResponse>(
diff --git a/B05_Profile/B05_Profile_Route_Save.py b/B05_Profile/B05_Profile_Route_Save.py
index 9829b0680..6afb130af 100644
--- a/B05_Profile/B05_Profile_Route_Save.py
+++ b/B05_Profile/B05_Profile_Route_Save.py
@@ -9,14 +9,14 @@ API — `POST /api/projects/{id}/route/replan`(`B05_Profile_Router_Replan.replan
       stationSnap, terrain}` · 오면 `vertices` · `station_snap` · `terrain` 대신 이것.
     `as_initial` — 추천 노선 [적용](초기값 다시 뜸) · 손으로 고친 노선 저장은 false(초기값 그대로).
   응답 200 `{status: "success", project_id, route_id, total_length_m, vertex_count, current_initial,
-    initial_refreshed, pipes: {kept, crossing, concave}, structures: {moved, far}, cross_dropped,
+    initial_refreshed, pipes: {kept, crossing}, structures: {moved, far}, cross_dropped,
     drainage_stale: true, seconds}`.
   오류 400(노드 둘 미만 · 초안 칸 길이 어긋남) · 404(프로젝트 없음) ·
     409 `{status: "error", message}`(체인 실패 — 노선 · 관 · 구조물 · 종횡단 파일 · 새 노선 행을
     옛것으로 되살린 뒤).
 
 규칙:
-  - 관 정본을 지우지 않음 — 좌표를 따라감 · 새 세류선 교차점 기본 관 · 오목 지점 보충만 더함
+  - 관 정본을 지우지 않음 — 좌표를 따라감 · 새 세류선 교차점 기본 관만 더함
     (`B05_Profile_Route_Save_Parts`) · 배수유역 저장분은 노선 지문이 달라 「낡음」(B04 `_resolve`).
   - 계획고 = 바뀐 구간만 새 지반 첫 계획선 · 그 밖 사용자 계획고 지킴
     (`B05_Profile_Engine_Grade_Carry` · 바뀐 구간 = 옛 · 새 **계획 폴리라인** — 화면 planline 과
@@ -37,15 +37,12 @@ from pathlib import Path
 from typing import Any, Literal
 from uuid import UUID
 
-import numpy as np
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
 
 from B05_Profile.B05_Profile_Route_Save_Parts import (
     add_crossing_pipes,
     carry_cross_inputs,
-    concave_chainages,
-    fill_concave_pipes,
     follow_pipes,
     station_keys,
     vertices_of,
@@ -161,40 +158,14 @@ def _xy(project_root: Path, route_data_path: str | None) -> list[list[float]]:
         return []
 
 
-def _ground_along(project_root: Path, selection: dict[str, Any], vertices: list) -> tuple:
-    """새 노선 지반 종단(2 m) — 오목 지점 찾기. 지표면을 못 열면 빈 배열(보충 건너뜀)."""
-    from shapely.geometry import LineString
-
-    from B05_Profile.B05_Profile_Route_Save_Parts import CONCAVE_STEP_M
-    from common_util.common_util_surface_sampler import build_surface_sampler
-
-    try:
-        sampler = build_surface_sampler(
-            project_root / "B04_PreProcess" / "models",
-            str(selection.get("source_filter")),
-            str(selection.get("method") or "dtm"),
-            bool(selection.get("smooth")),
-        )
-    except (FileNotFoundError, KeyError, OSError, ValueError):
-        logger.warning("노선 저장: 지표면을 못 열어 오목 지점 보충을 건너뜀")
-        return np.zeros(0), np.zeros(0)
-    line = LineString([(vertex.x, vertex.y) for vertex in vertices])
-    chainage = np.arange(0.0, line.length + 1e-9, CONCAVE_STEP_M)
-    xy = np.array([line.interpolate(float(s)).coords[0] for s in chainage], dtype=np.float64)
-    z, valid = sampler.sample_xy(xy)
-    return chainage[valid], np.asarray(z, dtype=np.float64)[valid]
-
-
 async def _place_pipes(
     project_id: UUID,
-    project_root: Path,
     stored_path: str,
-    selection: dict[str, Any],
     old_pipes: list,
     old_xy: list[list[float]],
     points: list[dict[str, float]],
 ) -> tuple[list, dict[str, int]]:
-    """관 따라감 → 새 교차점 기본 관 → 오목 지점 보충 → 정본 저장(새 노선 지문)."""
+    """관 따라감 → 새 교차점 기본 관 → 정본 저장(새 노선 지문) · 간격 보충 없음(369)."""
     from B04_PreProcess.B04_PreProcess_Engine_Watershed_Analyze import _base_pipes
     from B04_PreProcess.B04_PreProcess_Router_Watershed import _prepare
     from common_util.common_util_drainage_pipes import route_signature, save_pipe_points
@@ -207,8 +178,6 @@ async def _place_pipes(
     pairs = follow_pipes(old_pipes, vertices)
     total = float(vertices[-1].chainage_m)
     crossing = add_crossing_pipes(pairs, _base_pipes(vertices, streams), old_xy, total)
-    chainage, ground = await asyncio.to_thread(_ground_along, project_root, selection, vertices)
-    concave = fill_concave_pipes(pairs, concave_chainages(chainage, ground), vertices, old_xy)
     await asyncio.to_thread(
         save_pipe_points,
         stored_path,
@@ -216,7 +185,7 @@ async def _place_pipes(
         [pipe for _, pipe in pairs],
         vertices,
     )
-    return pairs, {"kept": len(old_pipes), "crossing": crossing, "concave": concave}
+    return pairs, {"kept": len(old_pipes), "crossing": crossing}
 
 
 async def _carry_profile(
@@ -431,10 +400,8 @@ async def run_route_save_chain(
         new_xy = _xy(project_root, solved.route_data_path)
         marks.append(("노선 풀기 · 구조물 따라감", time.perf_counter()))
 
-        pairs, pipes = await _place_pipes(
-            project_id, project_root, stored_path, selection, old_pipes, old_xy, points
-        )
-        marks.append(("관 따라감 · 교차점 · 오목 보충", time.perf_counter()))
+        pairs, pipes = await _place_pipes(project_id, stored_path, old_pipes, old_xy, points)
+        marks.append(("관 따라감 · 교차점", time.perf_counter()))
 
         seed = asdict(_section_options(request, old_section_options))
         seed.pop("extra_stations", None)
diff --git a/B05_Profile/B05_Profile_Route_Save_Parts.py b/B05_Profile/B05_Profile_Route_Save_Parts.py
index d31a7277a..c4f37273d 100644
--- a/B05_Profile/B05_Profile_Route_Save_Parts.py
+++ b/B05_Profile/B05_Profile_Route_Save_Parts.py
@@ -1,4 +1,4 @@
-"""노선 저장 길(346-3) 순수 부품 — 관 따라감 · 새 교차점 기본 관 · 오목 지점 보충 · 측점 열쇠 ·
+"""노선 저장 길(346-3) 순수 부품 — 관 따라감 · 새 교차점 기본 관 · 측점 열쇠 ·
 횡단 이월.
 
 DB · 파일 없이 값만 받아 값을 돌려준다(시험이 그대로 부름). 차례 · 저장 · 되살림은
@@ -7,7 +7,7 @@ DB · 파일 없이 값만 받아 값을 돌려준다(시험이 그대로 부름
   - 관 = 좌표가 정본 — 새 노선에 투영해 누가거리만 다시(`project_pipe_points` · 정수 m). 지우지 않음
     (사용자 관 편집 지킴).
   - 새 세류선 교차점(옛 노선 위에 없던 자리)에 관이 없으면 기본 관 하나(`_base_pipes` 결과를 받음).
-  - 관 최대 간격 보충 = 옛 노선에서 벗어난 자리의 **오목 지점**(지반 종단 낮은 곳)에만 — 격자 없음.
+  - 관 최대 간격 보충 없음(369) — 간격 보충은 배수유역 [자동 제안]만.
   - 측점 열쇠 = `common_util_station_key.station_key` 한 벌(sub2 짝) — 일반 `grid:k` ·
     관 `pipe:<id>` · 구조물 `structure:<id>` · 시종점 `end:BP` · `end:EP` ·
     id 없으면 `at:<누가거리 0.01 m>`.
@@ -22,11 +22,9 @@ import copy
 import math
 from typing import Any, Sequence
 
-import numpy as np
 from shapely.geometry import LineString, Point
 
 from common_util.common_util_drainage_pipes import (
-    PIPE_SOURCE_SPACING,
     PIPE_SOURCE_STREAM,
     PipePoint,
     project_pipe_points,
@@ -35,14 +33,10 @@ from common_util.common_util_route_geometry import RouteVertex
 from common_util.common_util_station_key import chainage_key as station_chainage_key
 from common_util.common_util_station_key import station_key
 from common_util.common_util_structure_station import plan_stations, snap_structure_station
-from config.config_system import DRAINAGE_PIPE_MAX_SPACING_M, DRAINAGE_PIPE_MIN_SPACING_M
+from config.config_system import DRAINAGE_PIPE_MIN_SPACING_M
 
 # 옛 노선에서 이만큼(m) 넘게 떨어진 자리 = 노선이 바뀐 자리(교차점 · 보충 대상).
 MOVED_AWAY_M = 0.5
-# 오목 지점을 찾을 지반 표본 간격(m) · 고름 창(표본 수) — DTM 잔물결을 오목으로 안 읽게.
-# ponytail: 이동 평균 + 국소 최저 · 계곡이 얕아 놓치면 창을 줄이거나 흐름 강도와 섞을 것.
-CONCAVE_STEP_M = 2.0
-CONCAVE_WINDOW = 5
 _SAME_M = 0.01
 
 
@@ -96,57 +90,6 @@ def add_crossing_pipes(
     return added
 
 
-def concave_chainages(chainage: np.ndarray, ground: np.ndarray) -> list[tuple[float, float]]:
-    """지반 종단의 오목 지점(이동 평균 국소 최저) → [(누가거리, 고른 지반고)]."""
-    if ground.size < 3:
-        return []
-    kernel = np.ones(CONCAVE_WINDOW) / CONCAVE_WINDOW
-    pad = CONCAVE_WINDOW // 2
-    smooth = np.convolve(np.pad(ground, pad, mode="edge"), kernel, mode="valid")
-    return [
-        (float(chainage[i]), float(smooth[i]))
-        for i in range(1, smooth.size - 1)
-        if smooth[i] < smooth[i - 1] and smooth[i] <= smooth[i + 1]
-    ]
-
-
-def fill_concave_pipes(
-    pairs: list[tuple[int, PipePoint]],
-    concave: list[tuple[float, float]],
-    vertices: list[RouteVertex],
-    old_xy: Sequence[Sequence[float]] | None,
-) -> int:
-    """관 사이(시종점 포함)가 최대 간격을 넘으면 옛 노선 밖 오목 지점 중 가장 낮은 곳에 관."""
-    line = LineString([(vertex.x, vertex.y) for vertex in vertices])
-    old_line = LineString(old_xy) if old_xy and len(old_xy) >= 2 else None
-    total = float(line.length)
-    added = 0
-    while True:
-        edges = [0.0, *(pipe.chainage_m for _, pipe in pairs), total]
-        best: tuple[float, float] | None = None
-        for start, end in zip(edges, edges[1:]):
-            if end - start <= DRAINAGE_PIPE_MAX_SPACING_M:
-                continue
-            for at, z in concave:
-                if not (
-                    start + DRAINAGE_PIPE_MIN_SPACING_M < at < end - DRAINAGE_PIPE_MIN_SPACING_M
-                ):
-                    continue
-                point = line.interpolate(at)
-                if _moved_away(old_line, point.x, point.y) and (best is None or z < best[1]):
-                    best = (at, z)
-        if best is None:
-            return added
-        at = snap_structure_station(best[0], [total])
-        point = line.interpolate(at)
-        pairs.append(
-            (-1, PipePoint(chainage_m=at, source=PIPE_SOURCE_SPACING, x=point.x, y=point.y))
-        )
-        pairs.sort(key=lambda pair: pair[1].chainage_m)
-        concave = [item for item in concave if abs(item[0] - best[0]) > _SAME_M]
-        added += 1
-
-
 def _facility_owners(
     pipes: Sequence[PipePoint], structures: Sequence[Any]
 ) -> dict[float, tuple[str, str | None]]:
diff --git a/B05_Profile/B05_Profile_Router_Terrain.py b/B05_Profile/B05_Profile_Router_Terrain.py
index 379907567..bbf439ac5 100644
--- a/B05_Profile/B05_Profile_Router_Terrain.py
+++ b/B05_Profile/B05_Profile_Router_Terrain.py
@@ -1,15 +1,14 @@
 """계획노선 편집 중 **지반고만** 묻는 가벼운 통로.
 
 편집 모달은 [확인] 전까지 아무 계산도 내보내지 않는다(계획서 0-2 확정 7). 다만 두 점을 찍어
-**구간 길이와 종단기울기**를 볼 때(0-9 ⑤)와 한 측점의 **횡단도 미리보기**(⑧)는 지반고가
-있어야 한다. 새 계산이 아니라 **이미 확정된 지표면을 읽기만** 하는 통로라 그 규칙과 부딪히지
+**구간 길이와 종단기울기**를 볼 때(0-9 ⑤)는 지반고가 있어야 한다(측점 횡단 미리보기 = 계산
+묶음 · 365-3). 새 계산이 아니라 **이미 확정된 지표면을 읽기만** 하는 통로라 그 규칙과 부딪히지
 않는다 — 노선을 갈아 끼우지도, 정본을 건드리지도 않는다.
 
 표고 조회는 종·횡단 생성기가 쓰는 것과 **같은 sampler**(`build_surface_sampler`)를 연다.
 두 화면이 다른 표고를 보면 같은 자리의 기울기가 갈린다.
 
   POST /api/projects/{id}/route/elevations    → 점 묶음의 지반고
-  POST /api/projects/{id}/route/cross-preview → 고치던 노선의 한 측점 횡단 미리보기
   GET  /api/projects/{id}/route/terrain-sources → 고를 수 있는 분석 지형(라이다 · 수치지형도)
   GET  /api/projects/{id}/surface/models/{mid}/grid → DTM 격자 원시 이진(브라우저 표본기 · ETag)
 
@@ -30,13 +29,7 @@ from fastapi.responses import JSONResponse, Response
 from pydantic import BaseModel, Field
 
 from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_path
-from B05_Profile.B05_Profile_Engine_Sections_Core import (
-    SectionGenerationOptions,
-    generate_sections,
-)
-from B06_Section.B06_Section_Engine_Design import compute_cross_design, curve_widening_args
 from common_util.common_util_http_cache import cached_file_response
-from common_util.common_util_route_polyline import build_planned_polyline
 from common_util.common_util_storage import resolve_stored_project_path
 from common_util.common_util_surface_confirmation import (
     AnalysisTerrain,
@@ -121,143 +114,6 @@ async def read_route_elevations(project_id: UUID, request: ElevationRequest) ->
     }
 
 
-class PreviewVertex(BaseModel):
-    """편집 중인 꺾임점 하나 — `RouteVertexInput` 과 같은 꼴."""
-
-    x: float
-    y: float
-    curve: bool = True
-    radius_m: float | None = None
-
-
-class CrossPreviewRequest(BaseModel):
-    """고치던 노선 그대로 한 측점의 횡단을 미리 본다."""
-
-    vertices: list[PreviewVertex] = Field(..., min_length=2)
-    chainage_m: float = Field(..., ge=0)
-    #: 법정 최소곡선반지름(m) — 화면이 `/route/plan` 에서 받은 값을 그대로 돌려준다.
-    min_radius_m: float = Field(12.0, gt=0)
-    station_interval_m: float | None = None
-    #: 횡단 반폭(m) — 화면이 적용해 둔 값. 비면 서버 기본값.
-    cross_half_width_m: float | None = Field(None, gt=0)
-    terrain: AnalysisTerrain | None = None
-    #: [측점 스냅] 켬(요구 224-2) — 편집 창 단추 값 그대로.
-    station_snap: bool = False
-
-
-def _cross_preview(
-    project_root: Path,
-    params: dict,
-    request: CrossPreviewRequest,
-) -> dict | None:
-    """고치던 노선으로 종·횡단을 한 번 돌려 그 측점 한 장을 뽑는다.
-
-    **B05·B06 의 정본 로직을 그대로 재사용한다**(2026-09-12 사용자 확정 「기본 로직은 B06에
-    존재함. 재사용」) — `generate_sections` 가 측점·접선·지반 샘플을, `compute_cross_design`
-    이 설계선을 만든다. 여기서 기하를 새로 짜지 않는다.
-
-    ⚠ **계획고는 아직 없다.** 계획고는 [확인] 뒤 전 체인이 낳는 값이라 편집 중에는 존재하지
-    않는다. 그래서 그 측점의 **지반고를 그대로 계획고로 놓는다**(지반 추종) — 절·성토가 사면
-    기울기만으로 서는 「기본 계획 횡단」이며, 사용자가 보기로 한 것도 그것이다.
-    """
-    try:
-        sampler = build_surface_sampler(
-            project_root / _MODELS_SUBDIR,
-            str(params["source_filter"]),
-            str(params["method"]),
-            bool(params["smooth"]),
-        )
-    except (FileNotFoundError, KeyError, OSError, ValueError) as exc:
-        logger.warning("횡단 미리보기: 지표면을 열지 못했습니다 — %s", exc)
-        return None
-
-    built = build_planned_polyline(
-        [(vertex.x, vertex.y) for vertex in request.vertices],
-        min_radius_m=request.min_radius_m,
-        # 화면이 준 노드는 이미 꺾임점이다 — 다시 뽑으면 선이 깎인다(`_write_planned_polyline`).
-        simplify=False,
-        curve_flags=[vertex.curve for vertex in request.vertices],
-        radii=[vertex.radius_m for vertex in request.vertices],
-    )
-    interval = request.station_interval_m
-    defaults = SectionGenerationOptions()
-    options = SectionGenerationOptions(
-        station_interval_m=float(interval)
-        if interval and interval > 0
-        else defaults.station_interval_m,
-        cross_half_width_m=request.cross_half_width_m or defaults.cross_half_width_m,
-    )
-    # 곡선표 = 방금 지은 노선의 곡선 — 스냅 자리 · 확폭이 [확인] 뒤 서버 정본과 같은 규칙.
-    result = generate_sections(
-        built.vertices,
-        sampler,
-        options,
-        design_curves=[curve.as_dict() for curve in built.curves],
-        station_snap=request.station_snap,
-    )
-    sections = result["cross_sections"]
-    if not sections:
-        return None
-    section = min(sections, key=lambda row: abs(float(row["chainage_m"]) - request.chainage_m))
-
-    design = None
-    center_z = section.get("center_z")
-    if center_z is not None:
-        # 단면유형 기본값은 B06 화면과 같다 — 등고가 높은 쪽을 절토로 본다.
-        section_mode = "right_cut" if section.get("uphill_side") == "right" else "left_cut"
-        design = compute_cross_design(
-            section["samples"],
-            float(center_z),
-            ground_type="soil",
-            section_mode=section_mode,
-            **curve_widening_args(section),
-        )
-    return {
-        "chainage_m": round(float(section["chainage_m"]), 3),
-        "label": section.get("label"),
-        "uphill_side": section.get("uphill_side"),
-        "plan_radius_m": section.get("plan_radius_m"),
-        "curve_widening_m": section.get("curve_widening_m"),
-        # 샘플이 실제로 덮은 반폭 — 평면도 반폭 선이 이 값을 그대로 쓴다.
-        "cross_half_width_m": options.cross_half_width_m,
-        "samples": section["samples"],
-        "design": design,
-        "total_length_m": round(float(result["longitudinal"]["total_length_m"]), 3)
-        if result.get("longitudinal", {}).get("total_length_m") is not None
-        else None,
-    }
-
-
-@router.post("/{project_id}/route/cross-preview", response_model=None)
-async def read_cross_preview(project_id: UUID, request: CrossPreviewRequest) -> dict | JSONResponse:
-    """고치던 계획노선의 **한 측점 횡단**을 돌려준다(계획서 0-9 ⑧).
-
-    정본을 건드리지 않는다 — 파일도 DB 도 쓰지 않고 그 자리에서 셈해 돌려주기만 한다.
-    """
-    pool = get_db_pool()
-    async with pool.acquire() as connection:
-        stored = await get_project_storage_relative_path(connection, project_id)
-        if not stored:
-            return JSONResponse(
-                status_code=404,
-                content={"status": "error", "message": "프로젝트 저장 경로를 찾을 수 없습니다."},
-            )
-        params = await get_surface_confirmation_params(connection, str(project_id))
-    params = analysis_terrain_params(params, request.terrain)
-
-    project_root = Path(resolve_stored_project_path(stored))
-    preview = await asyncio.to_thread(_cross_preview, project_root, params, request)
-    if preview is None:
-        return JSONResponse(
-            status_code=409,
-            content={
-                "status": "error",
-                "message": "확정된 지표면이 없어 횡단을 미리 볼 수 없습니다.",
-            },
-        )
-    return {"status": "success", "project_id": str(project_id), **preview}
-
-
 @router.get("/{project_id}/route/terrain-sources", response_model=None)
 async def read_terrain_sources(project_id: UUID) -> dict | JSONResponse:
     """편집 모달이 고를 수 있는 분석 지형 — 둘이면 고르기를 띄움 · 하나면 숨김."""
diff --git a/B05_Profile/B05_Profile_UI_Corridor_Station_Structure.ts b/B05_Profile/B05_Profile_UI_Corridor_Station_Structure.ts
index 8a22ff43b..cac55c2ca 100644
--- a/B05_Profile/B05_Profile_UI_Corridor_Station_Structure.ts
+++ b/B05_Profile/B05_Profile_UI_Corridor_Station_Structure.ts
@@ -308,8 +308,8 @@ export function culvertSilhouettes(section: CrossSection): StructureSilhouette[]
     const side: "left" | "right" = wall.outward > 0 ? "left" : "right";
     const slope = trimSlopeOf(side);
     if (slope) pushTopSlope(side, slope.points);
-    // 구조물 전면 실루엣 — 이음선 상단에서 전면 발끝까지 내려온다.
-    push(side, [wall.topJoint, wall.bottomFront]);
+    // 구조물 전면 실루엣 — 성토 위 이음에서 전면 발끝까지 내려온다(371-1).
+    push(side, [wall.fillTop, wall.bottomFront]);
     spans[side] = wallSpanOf(section, wall.role === "inlet" ? "inlet" : "outlet");
   }
   const outletSegments = layout.outletFill.segments.filter((segment) => segment.kind !== "cut");
@@ -321,13 +321,13 @@ export function culvertSilhouettes(section: CrossSection): StructureSilhouette[]
       addRun(outletSide, segment.points);
     }
     const wall = layout.extraWalls[step];
-    if (wall) push(outletSide, [wall.topJoint, wall.bottomFront]);
+    if (wall) push(outletSide, [wall.fillTop, wall.bottomFront]);
   }
   layout.basinFill.segments.forEach((segment) => {
     push(inletSide, segment.points);
     addRun(inletSide, segment.points);
   });
-  layout.basinExtras.forEach((wall) => push(inletSide, [wall.topJoint, wall.bottomFront]));
+  layout.basinExtras.forEach((wall) => push(inletSide, [wall.fillTop, wall.bottomFront]));
 
   let basinCut = false;
   if (layout.basin) {
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Chrome.ts b/B05_Profile/B05_Profile_UI_Drainage_Chrome.ts
index 1978588af..7a82c1545 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Chrome.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Chrome.ts
@@ -7,6 +7,7 @@
  * 배선(토글·포인터·그리기)은 전부 본체가 맡는다.
  * ========================================================================== */
 
+import { currentLanguageIndex, ui_locales } from "@ui/ui_template_locale";
 import { createWorkflowPanelHandle } from "@ui/ui_template_overlay";
 import { createPanelResizer } from "@ui/ui_template_resizer";
 import { createProgressCircle } from "@ui/ui_template_progress";
@@ -20,6 +21,8 @@ export interface DrainageChrome {
   analyzeButton: HTMLButtonElement;
   deleteButton: HTMLButtonElement;
   autoButton: HTMLButtonElement;
+  /** [자동 제안](369) — 고름 창 · 배선은 `B05_Profile_UI_Drainage_Live`. */
+  proposeButton: HTMLButtonElement;
   viewport: HTMLElement;
   backgroundImage: HTMLImageElement;
   canvas: HTMLCanvasElement;
@@ -88,13 +91,18 @@ export function createDrainageChrome(
   deleteButton.textContent = labels.deleteSelected;
   deleteButton.title = labels.deleteSelectedTip;
   deleteButton.disabled = true;
-  // 자동 제안으로 되돌리기 — 편집한 배관 배치를 버리고 백엔드 자동 제안으로 재산정.
+  // 배관 배치 초기화 — 편집한 배관 배치를 버리고 세류선 교차 자리만(초안 · 369).
   const autoButton = document.createElement("button");
   autoButton.type = "button";
   autoButton.className = "b05-drainage__analyze b05-drainage__tool";
   autoButton.textContent = labels.auto;
   autoButton.title = labels.autoTip;
-  header.append(analyzeButton, deleteButton, autoButton);
+  const proposeButton = document.createElement("button");
+  proposeButton.type = "button";
+  proposeButton.className = "b05-drainage__analyze b05-drainage__tool b05-drainage__propose";
+  proposeButton.textContent = ui_locales.B05_Drainage_Btn_Propose[currentLanguageIndex];
+  proposeButton.title = ui_locales.B05_Drainage_Btn_Propose_Tip[currentLanguageIndex];
+  header.append(analyzeButton, deleteButton, autoButton, proposeButton);
 
   const viewport = document.createElement("div");
   viewport.className = "b05-drainage__viewport";
@@ -155,6 +163,7 @@ export function createDrainageChrome(
     analyzeButton,
     deleteButton,
     autoButton,
+    proposeButton,
     viewport,
     backgroundImage,
     canvas,
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Live.ts b/B05_Profile/B05_Profile_UI_Drainage_Live.ts
index 9bbff9a3e..e83a28ef8 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Live.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Live.ts
@@ -14,9 +14,14 @@
  *   - 서버가 「낡음」으로 답하면(노선 [저장] 뒤 등) 같은 흐림 + [업데이트] · 자동이면 3 s 뒤.
  *   - 답은 패널 요청 감싸기(`DetailRunner`, quiet)로 올림 — 옛 차례 · 서버가 그만둔 답은 버림.
  *   - 덮개 · 잠금 없음 — 다른 칸 조작은 그대로.
+ *   - [자동 제안](369) — 고름 창 ① 전체 자동(all) ② 지정 포함 추가(add) · [배관 배치 초기화] = 세류선 교차
+ *     관만 · 셋 다 초안(세션) · [저장] 때 정본 · 답이 오면 사진첩 한 걸음(늦은 답도 앞 걸음에 안 묻힘) ·
+ *     낡은 동안 [자동 제안] 끔 · 노선 초안 중이거나 저장 분석이 낡았으면(옛 노선) 「지금 노선으로 셈」 길에
+ *     방식을 실어 보냄(저장 분석으로 셈 = 옛 노선 자리 · 409).
  * ========================================================================== */
 
 import { API_BASE_URL } from "@config/config_frontend";
+import { currentLanguageIndex, ui_locales } from "@ui/ui_template_locale";
 import { createProgressCircle } from "@ui/ui_template_progress";
 import { openModal } from "@ui/ui_template_modal";
 import { readStateRaw, writeStateRaw } from "../A00_Common/b_page_state";
@@ -37,6 +42,7 @@ import {
 } from "./logic/B05_Profile_Drainage_Live";
 import type { DetailRunner } from "./B05_Profile_UI_Drainage_Run";
 import { createDrainageSuggest, type DrainageSuggest } from "./B05_Profile_UI_Drainage_Suggest";
+import { pageHistory } from "./B05_Profile_UI_Profile_History";
 
 const MODE_KEY = "drainage-mode";
 
@@ -47,7 +53,7 @@ export interface DrainageLiveDeps {
   basinList: HTMLElement;
   pipeRequest: () => DetailPipeInput[];
   runner: DetailRunner;
-  /** [적용] 답이 화면에 오른 뒤 — 세션 초안에 담음. */
+  /** [적용] · [자동 제안] 답이 화면에 오른 뒤 — 세션 초안에 담음. */
   rememberPipes: () => void;
   /** 저장 배수유역 다시 받기(열 때와 같은 길 · 조용히) — 답을 화면에 올렸으면 true. */
   loadSaved: () => Promise<boolean>;
@@ -62,6 +68,8 @@ export interface DrainageLive {
   markStale(): void;
   /** [확정]이 서버에서 다시 셈 — 낡음 지움(떠 있는 요청 · 기다림도 끊음). */
   markFresh(): void;
+  /** [배관 배치 초기화] — 세류선 교차 관만으로 초안(369 · 저장분은 [저장] 때). */
+  resetToStreams(): void;
   readonly stale: boolean;
   suggest: DrainageSuggest;
 }
@@ -69,7 +77,7 @@ export interface DrainageLive {
 /** 「지금 노선으로 셈」 — 서버 `post_drainage_live` · 작업본에 안 씀. */
 async function fetchLive(
   projectId: string,
-  body: ReturnType<typeof liveRequestBody>,
+  body: ReturnType<typeof liveRequestBody> | (Proposal & { generation: number }),
   signal: AbortSignal,
 ): Promise<DetailBasinResponse & { status?: string; generation?: number }> {
   const response = await fetch(`${API_BASE_URL}/projects/${projectId}/drainage/live`, {
@@ -88,16 +96,33 @@ export function readDrainageMode(): DrainageMode {
   return parseDrainageMode(readStateRaw(MODE_KEY));
 }
 
+const L = (key: keyof typeof ui_locales): string => ui_locales[key][currentLanguageIndex];
+
+/** 서버 「낡음」 글 머리 — 짝 `B04_PreProcess_Router_Basins.STALE_MESSAGE`. */
+const STALE_PREFIX = "배수유역 낡음";
+
+/** [자동 제안] · [배관 배치 초기화] 요청 — 관 목록 없음(null) = 세류선 교차만. */
+type Proposal = { points: DetailPipeInput[] | null; auto?: "all" | "add" };
+
 export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
   const viewport = deps.root.querySelector<HTMLElement>(".b05-drainage__viewport") as HTMLElement;
   const header = deps.root.querySelector<HTMLElement>(".b05-drainage__header") as HTMLElement;
-  const suggest = createDrainageSuggest(deps.pipeRequest, (points) => {
+  const propose = header.querySelector<HTMLButtonElement>(".b05-drainage__propose");
+  /** 관 초안 요청 — 답이 화면에 오르면 세션 초안 + 사진첩 한 걸음(400 ms 넘은 답도 제 걸음). */
+  const draft = (request: (projectId: string) => Promise<DetailBasinResponse>): void => {
     const projectId = deps.runner.projectId();
     if (!projectId) return;
     void deps.runner
-      .run(() => computeDetailBasins(projectId, points))
-      .then((ok) => ok && deps.rememberPipes());
-  });
+      .run(() => request(projectId))
+      .then((ok) => {
+        if (!ok) return;
+        deps.rememberPipes();
+        pageHistory()?.record();
+      });
+  };
+  const suggest = createDrainageSuggest(deps.pipeRequest, (points) =>
+    draft((projectId) => computeDetailBasins(projectId, points)),
+  );
   deps.basinList.before(suggest.root);
   let mode = readDrainageMode();
   let route: unknown = null;
@@ -106,6 +131,8 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
   let drafted = false;
   /** 저장분 다시 받기 답이 「낡음」이었나(`markStale` 이 세움). */
   let savedStale = false;
+  /** 저장 분석이 옛 노선(서버 「낡음」 답 · [확정] 전까지) — [자동 제안]은 지금 노선으로 셈. */
+  let analysisStale = false;
   let generation = 0;
   /** 마지막 단계 입력 지문 — 같으면 묶음이 다시 돈 것뿐. */
   let key = "";
@@ -136,6 +163,10 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
   const paint = (): void => {
     deps.root.classList.toggle("is-stale", stale && mode === "manual");
     suggest.setStale(stale);
+    if (propose) {
+      propose.disabled = stale;
+      propose.title = L(stale ? "B05_Drainage_Btn_Propose_Stale" : "B05_Drainage_Btn_Propose_Tip");
+    }
     veil.hidden = !stale || mode === "auto" || inflight !== null;
     busy.root.hidden = inflight === null;
   };
@@ -147,7 +178,8 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
     inflight = null;
   }
 
-  function refresh(): void {
+  /** 지금 노선으로 셈 — `proposal` 이면 그 관 목록 · 방식으로(답 = 관 초안 · 사진첩 한 걸음). */
+  function refresh(proposal?: Proposal): void {
     const projectId = deps.runner.projectId();
     if (!projectId) return;
     cancel();
@@ -155,7 +187,7 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
     const controller = new AbortController();
     inflight = controller;
     paint();
-    const body = liveRequestBody(sent.generation, route, deps.pipeRequest());
+    const body = { ...liveRequestBody(sent.generation, route, deps.pipeRequest()), ...proposal };
     void deps.runner
       .run(async () => {
         const response = await fetchLive(projectId, body, controller.signal);
@@ -168,10 +200,30 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
         if (inflight !== controller) return;
         inflight = null;
         if (applied) stale = false;
+        if (applied && proposal) {
+          deps.rememberPipes();
+          pageHistory()?.record();
+        }
         paint();
       });
   }
 
+  /** [자동 제안] · [배관 배치 초기화] — 저장 분석이 지금 노선과 같으면 빠른 길(detail-basins) ·
+   *  그 길이 「낡음」(409 · 화면이 아직 몰랐던 낡음)이면 곧바로 지금 노선으로 셈 길로 다시. */
+  function proposeDraft(proposal: Proposal): void {
+    if (analysisStale || draftMakesStale(route)) return refresh(proposal);
+    draft(async (projectId) => {
+      try {
+        return await computeDetailBasins(projectId, proposal.points, proposal.auto);
+      } catch (error) {
+        if (!(error instanceof Error) || !error.message.startsWith(STALE_PREFIX)) throw error;
+        analysisStale = true;
+        queueMicrotask(() => refresh(proposal)); // 이 요청은 조용히 버림(뒤 차례가 받음)
+        throw new DOMException("stale", "AbortError");
+      }
+    });
+  }
+
   /** 평면 · 관 자리 조작 — 처음으로(요청 끊기 · 다시 흐림 또는 다시 3 s). */
   function invalidate(): void {
     cancel();
@@ -223,6 +275,36 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
     });
   }
 
+  /** [자동 제안] 고름 창 — ⚙ 창과 같은 틀 · 고르면 닫고 그 방식으로 초안. */
+  function openPropose(): void {
+    if (stale) return;
+    openModal({
+      title: L("B05_Drainage_Propose_Title"),
+      closeLabel: "닫기",
+      mount(body, close) {
+        const choices: Array<["all" | "add", string, string]> = [
+          ["all", L("B05_Drainage_Propose_All"), L("B05_Drainage_Propose_All_Hint")],
+          ["add", L("B05_Drainage_Propose_Add"), L("B05_Drainage_Propose_Add_Hint")],
+        ];
+        choices.forEach(([value, label, hint], order) => {
+          const row = document.createElement("label");
+          row.className = "b05-drainage__mode";
+          const input = document.createElement("input");
+          input.type = "radio";
+          input.name = "b05-drainage-propose";
+          input.addEventListener("change", () => {
+            close();
+            proposeDraft({ points: deps.pipeRequest(), auto: value });
+          });
+          const text = document.createElement("span");
+          text.textContent = `${order === 0 ? "①" : "②"} ${label} — ${hint}`;
+          row.append(input, text);
+          body.append(row);
+        });
+      },
+    });
+  }
+
   function setMode(next: DrainageMode): void {
     mode = next;
     writeStateRaw(MODE_KEY, next);
@@ -232,8 +314,9 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
     paint();
   }
 
-  update.addEventListener("click", refresh);
+  update.addEventListener("click", () => refresh());
   gear.addEventListener("click", openSettings);
+  propose?.addEventListener("click", openPropose);
 
   return {
     stage(ctx) {
@@ -247,10 +330,11 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
       else if (wasDraft) backToSaved();
       return null;
     },
-    refresh,
+    refresh: () => refresh(),
     suggest,
     markStale() {
       savedStale = true;
+      analysisStale = true;
       if (stale) return;
       stale = true;
       if (mode === "auto" && !inflight) timer = window.setTimeout(refresh, QUIET_MS);
@@ -259,8 +343,10 @@ export function createDrainageLive(deps: DrainageLiveDeps): DrainageLive {
     markFresh() {
       cancel();
       stale = false;
+      analysisStale = false;
       paint();
     },
+    resetToStreams: () => proposeDraft({ points: null }),
     get stale() {
       return stale;
     },
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Panel.ts b/B05_Profile/B05_Profile_UI_Drainage_Panel.ts
index 1dbc5ccf5..ab255052d 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Panel.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Panel.ts
@@ -5,7 +5,6 @@ import {
   computeDetailBasins,
   fetchDetailPipePoints,
   getVWorldMapUrl,
-  resetDetailPipePoints,
   saveDetailPipePoints,
   type DetailBasin,
   type DetailBasinResponse,
@@ -35,6 +34,7 @@ import { snapStructureStation } from "../common_util/common_util_structure_stati
 import { createFacilityStore } from "./B05_Profile_UI_Drainage_Facility";
 import { mergeFacilityOptions } from "./logic/B05_Profile_UI_Drainage_Facility_Merge";
 import { readPendingPipes, writePendingPipes } from "./B05_Profile_Api_Pipes_Draft";
+import { pageReplaying } from "./B05_Profile_UI_Profile_History";
 import { buildPipeReports } from "./B05_Profile_UI_Drainage_Report";
 import { fillFordHeights, fordWaitsOf, waitsFordHeight } from "./B05_Profile_UI_Drainage_Ford_Fill";
 import { createDrainageChrome } from "./B05_Profile_UI_Drainage_Chrome";
@@ -59,6 +59,7 @@ import {
   summaryText,
   basinIndexOfPipe,
   pipeMarkerColor,
+  adoptDraftPipes,
   reconcilePipes,
   WIDTH_KEY,
   type DrainageLayer,
@@ -416,10 +417,6 @@ export function createDrainagePanel(callbacks: DrainagePanelCallbacks = {}): Dra
       : fetchDetailPipePoints(projectId as string);
   };
 
-  /** 저장분까지 버리고 자동 배치로 되돌린다("초기화"). 화면만 되돌리면 다시 들어왔을 때
-   *  옛 관이 살아난다(2026-08-02 사용자 보고). */
-  const resetPipes = (): Promise<boolean> => run(() => resetDetailPipePoints(projectId as string));
-
   /** 세부유역을 다시 나눈다(격자 해석 없음) — 같은 틱의 여러 부름은 한 번(342-3 · 옛 소수 관 옮김).
    *  시설 종류·구간·옵션은 계산기에서 사라지므로 요청에 되붙인다. */
   const analyze = batched(() => run(() => computeDetailBasins(projectId as string, pipeRequest())));
@@ -435,7 +432,7 @@ export function createDrainagePanel(callbacks: DrainagePanelCallbacks = {}): Dra
   });
   analyzeButton.addEventListener("click", () => void analyze());
   deleteButton.addEventListener("click", () => void pipeEditor.deleteSelected());
-  autoButton.addEventListener("click", () => void resetPipes());
+  autoButton.addEventListener("click", live.resetToStreams); // 세류선만 · 초안(369)
 
   /** 노선 전체가 보이도록 배율·중심을 맞춘다(초기 보기 = 도로 기준 줌인).
    *
@@ -596,11 +593,13 @@ export function createDrainagePanel(callbacks: DrainagePanelCallbacks = {}): Dra
       const before = pipeEditor.pipes().map((pipe) => pipe.chainage_m);
       const next = reconcilePipes(pipeEditor.pipes(), chainages);
       if (!next) return; // 같은 목록 — 되돌아온 것이므로 여기서 끊는다
-      // 되돌리기 · 구조물 폼으로 옮겨진 관도 속성을 데려감
-      facilityStore.follow(
-        before,
-        next.map((pipe) => pipe.chainage_m),
-      );
+      // 되돌리기 = 그 걸음 초안의 속성 · id · 초안 없는 걸음은 저장분(369) · 구조물 폼은 속성 데려감
+      const pending = pageReplaying() ? readPendingPipes(projectId as string) : null;
+      if (pageReplaying() && !pending) return void run(loadSaved, true);
+      const draft = adoptDraftPipes(pending, next);
+      const after = next.map((pipe) => pipe.chainage_m);
+      if (draft) facilityStore.replaceFromResponse(draft);
+      else facilityStore.follow(before, after);
       pipeEditor.setPipes(next);
       void analyze();
     },
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Parts.ts b/B05_Profile/B05_Profile_UI_Drainage_Parts.ts
index fc92c1ec2..babcebadf 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Parts.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Parts.ts
@@ -343,6 +343,22 @@ export function mountDrainageToggles(
 
 /** 밖에서 바뀐 관 목록을 현재 목록과 맞춘다. 같으면 null — 되먹임 고리를 끊는 지점이다.
  *  다르면 새 목록을 돌려주되, 원래 생성 사유는 자리로 맞춰 이어 붙인다(기본/자동/수동 표시 보존). */
+/** 되돌리기(369) — 되살린 걸음의 관 초안(세션)이 `next` 와 같은 자리면 그 초안(속성 정본) · id 도
+ *  `next` 에 옮김. 자리가 다르면(구조물 폼이 옮김 등) null — 부르는 쪽이 속성을 따라 옮김. */
+export function adoptDraftPipes<D extends { chainage_m: number; id?: string }>(
+  draft: ReadonlyArray<D> | null,
+  next: PipePoint[],
+): ReadonlyArray<D> | null {
+  const same =
+    draft?.length === next.length &&
+    draft.every((item, index) => Math.abs(item.chainage_m - next[index].chainage_m) < 0.01);
+  if (!draft || !same) return null;
+  next.forEach((pipe, index) => {
+    if (draft[index].id) pipe.id = draft[index].id;
+  });
+  return draft;
+}
+
 export function reconcilePipes(
   before: ReadonlyArray<PipePoint>,
   chainages: ReadonlyArray<number>,
diff --git a/B05_Profile/B05_Profile_UI_Drainage_Suggest.ts b/B05_Profile/B05_Profile_UI_Drainage_Suggest.ts
index 71bd39b57..379702fa1 100644
--- a/B05_Profile/B05_Profile_UI_Drainage_Suggest.ts
+++ b/B05_Profile/B05_Profile_UI_Drainage_Suggest.ts
@@ -1,6 +1,7 @@
 /* =============================================================================
  * B05_Profile_UI_Drainage_Suggest.ts
- * 배수유역 칸 제안 목록(347-3) — 관경 · 시설 종류 · 관 자리 후보를 보여 주고 [적용] 한 번에 관 초안으로.
+ * 배수유역 칸 제안 목록(347-3) — 관경 · 시설 종류 · 관 자리 후보를 보여 주고 [적용] 한 번에 관경 · 시설만
+ * 관 초안으로(관 자리 = [자동 제안] · 369).
  * 모으기 · 얹기 규칙은 `logic/B05_Profile_Drainage_Suggest.ts` · 자동 바꿈 없음.
  * 관 자리 후보는 배수유역도에도 점선 원으로 그림(`candidates()` → 그리기 판).
  * ========================================================================== */
@@ -26,7 +27,8 @@ const facilityName = (id: string): string => FACILITY_NAME[id] ?? id;
 /** 제안 한 줄 글. */
 export function suggestionText(item: Suggestion): string {
   const at = `측점 ${Math.round(item.chainageM)} m`;
-  if (item.kind === "position") return `${at} — 관 자리 후보(흐름이 모이는 오목 자리)`;
+  if (item.kind === "position")
+    return `${at} — 관 자리 후보(흐름이 모이는 오목 자리 · [자동 제안])`;
   if (item.kind === "facility")
     return `${at} — ${facilityName(item.from)} → ${facilityName(item.to)} 검토`;
   return `${at} — 관경 ${item.from === null ? "미정" : `Ø${item.from}`} → Ø${item.to}`;
@@ -56,13 +58,19 @@ export function createDrainageSuggest(
   apply.className = "b05-drainage__analyze";
   apply.textContent = "적용";
   const applyTitle =
-    "제안을 관 초안에 한 번에 얹습니다(관 더함 · 관경 · 시설 바꿈) — [저장] 때 남습니다.";
+    "관경 · 시설 제안을 관 초안에 한 번에 얹습니다 — [저장] 때 남습니다(관 자리는 [자동 제안]).";
   apply.title = applyTitle;
   head.append(title, apply);
   const list = document.createElement("ul");
   list.className = "b05-drainage__suggest-list";
   root.append(head, list);
   let suggestions: Suggestion[] = [];
+  let stale = false;
+  /** [적용] 켜짐 — 낡지 않고 관경 · 시설 제안이 있을 때(관 자리 후보만이면 할 일 없음). */
+  const paintApply = (): void => {
+    apply.disabled = stale || !suggestions.some((item) => item.kind !== "position");
+    apply.title = stale ? "노선이 바뀌어 제안이 낡음 — 새 계산 뒤 적용" : applyTitle;
+  };
 
   apply.addEventListener("click", () => {
     if (suggestions.length && !apply.disabled)
@@ -77,6 +85,7 @@ export function createDrainageSuggest(
         : collectSuggestions(response.pipe_points, response.basins, response.pipe_candidates ?? []);
       root.hidden = suggestions.length === 0;
       title.textContent = `제안 ${suggestions.length}건`;
+      paintApply();
       list.replaceChildren(
         ...suggestions.map((item) => {
           const row = document.createElement("li");
@@ -85,9 +94,9 @@ export function createDrainageSuggest(
         }),
       );
     },
-    setStale(stale) {
-      apply.disabled = stale;
-      apply.title = stale ? "노선이 바뀌어 제안이 낡음 — 새 계산 뒤 적용" : applyTitle;
+    setStale(next) {
+      stale = next;
+      paintApply();
     },
     candidates: () =>
       suggestions.filter((item) => item.kind === "position").map((item) => item.chainageM),
diff --git a/B05_Profile/B05_Profile_UI_Profile_MassHaul.ts b/B05_Profile/B05_Profile_UI_Profile_MassHaul.ts
index 201cfa586..6a4b5b778 100644
--- a/B05_Profile/B05_Profile_UI_Profile_MassHaul.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_MassHaul.ts
@@ -17,8 +17,8 @@
  * ── 배치 (354-1 · 요구 235-7 「유토곡선도 분리」) ─────────────────────
  * 종단 열(그래프 · 표) 아래 칸에 따로 선다 — 종단도 · 표 위를 덮지 않고 높이 나눔 · 표 쌓기에도
  * 안 낀다. 높이는 판 위 경계 리사이저(`createPanelResizer`)로 조절하고 세션 동안 유지한다.
- * 머리줄([창 분할] · 접기 손잡이)은 접어도 남는다. 곡선 SVG는 판 안 자체 가로 스크롤러에
- * 들어가며, 종단 스크롤러와 scrollLeft를 양방향 동기화해 측점 세로선이 어긋나지 않게 한다.
+ * 접으면 손잡이만 남는다(367-2). 곡선은 늘 노선 전체를 한 화면에 맞춰 그린다 — 종단 측점과
+ * 맞물리는 보기 · 스크롤 동기는 없앰(367-1).
  * ========================================================================== */
 
 import { readStateRaw, stateKey, writeStateRaw } from "../A00_Common/b_page_state";
@@ -46,16 +46,13 @@ import { resetBalloonOffsets } from "@util/common_util_mass_haul_balance_view";
 import {
   createMassHaulChart,
   createMassHaulLegend,
-  createMassHaulWindowState,
   MASS_HAUL_MIN_HEIGHT,
-  scheduleMassHaulSettle,
 } from "@util/common_util_mass_haul_view";
 import { Y_WINDOW_BAKED_ATTR } from "../B06_Section/B06_Section_UI_Longitudinal";
 import { createWorkflowPanelHandle } from "@ui/ui_template_overlay";
 import { createPanelResizer } from "@ui/ui_template_resizer";
 import "@util/common_util_mass_haul.css";
 import "./B05_Profile_UI_Style_MassHaul.css";
-import { attachWheelHorizontalScroll, linkScrollLeft } from "./B05_Profile_UI_Profile_Wheel";
 import { frameOf } from "../common_util/common_util_view_window";
 
 /** 2차 패널 펼침 여부 — 세션 동안만 유지(패널 높이·접힘과 같은 수명). */
@@ -76,10 +73,8 @@ const HEIGHT_VAR = "--b05-masshaul-height";
  * 표시 상태가 갈리면 "같은 곡선인데 왜 다르게 보이나"가 된다(2026-08-03 사용자 확정).
  * 정의처는 B06 `_UI_Section_View`와 이 파일 두 곳뿐이며 값이 반드시 같아야 한다.
  */
-/** 처음 열 때는 **곡선만** 보인다 — 토량 분배(평형선·운반 블록)는 범례에서 켠다
- *  (2026-09-06 사용자 지시). 판을 v4 → v5 로 올려 이미 켜 둔 브라우저도 새 기본값으로
- *  시작하게 한다. */
-const DEFAULT_VISIBLE: string[] = [...MASS_HAUL_DEFAULT_VISIBLE];
+/** 기본 = 횡단 기준 + 토량 분배 켬(367-1) — 판 v6. [토량 분배] 는 분배 그림 보임/숨김. */
+const DEFAULT_VISIBLE: string[] = [...MASS_HAUL_DEFAULT_VISIBLE, MASS_HAUL_BALANCE_KEY];
 
 /** 유토곡선 계산에 필요한 프로젝트 설정 — B05 Page가 `fetchSectionContext()`에서 받아 넘긴다. */
 export interface RouteMassHaulContext {
@@ -150,12 +145,8 @@ export interface RouteMassHaulPanel {
   overlay: HTMLElement;
   isOpen(): boolean;
   setContext(next: RouteMassHaulContext | null): void;
-  /** 종단 가로 스크롤러와 scrollLeft를 양방향 동기화한다(설치 1회). */
-  attachScrollSync(main: HTMLElement): void;
-  /** 판 내용을 다시 그린다. 접혀 있으면 머리줄만 남기고 끝낸다. */
+  /** 판 내용을 다시 그린다. 접혀 있으면 손잡이만 남기고 끝낸다. */
   draw(params: RouteMassHaulDrawParams): void;
-  /** 가로 스크롤로 보이는 구간만 바뀜 — 창을 따를 때만 · 한 틀 한 번 · 다시 셈 없음(354-3). */
-  drawWindow(params: RouteMassHaulDrawParams): void;
 }
 
 function readVisible(): Set<string> {
@@ -199,7 +190,7 @@ export function createRouteMassHaulPanel(
   handle.className = "b05-profile__masshaul-handle";
   handle.append(handleControl.root);
   handleControl.root.setAttribute("aria-label", "유토곡선 패널");
-  // 머리줄 — 접어도 남아 [창 분할]([attachSubPanelPopouts] 가 맨 앞에 붙임) · 손잡이가 닿는다(354-1).
+  // 머리줄 — [창 분할]([attachSubPanelPopouts] 가 맨 앞에 붙임 · 펼친 때만 보임) · 손잡이(접으면 판 위 경계에 매달림 · 367-2).
   const head = document.createElement("div");
   head.className = "b05-profile__masshaul-head";
   head.append(handle);
@@ -248,10 +239,6 @@ export function createRouteMassHaulPanel(
   pendingChip.hidden = true;
   overlay.append(resizer.root, head, bar, scroll, legendLayer, pendingChip);
 
-  // 종단 그래프 영역과 같은 문법 — 세로 휠을 가로 이동으로 돌린다(2026-08-04 사용자 지시).
-  // scrollLeft 동기화 덕에 위 종단 그래프도 함께 움직인다. Shift+휠은 브라우저 기본 그대로.
-  attachWheelHorizontalScroll(scroll);
-
   /** 곡선을 그리는가 — 펼침이거나 새 창으로 뗌(뗀 창엔 접기가 없음 · 354-1). */
   const shown = (): boolean => open || overlay.classList.contains("is-popout");
 
@@ -262,7 +249,7 @@ export function createRouteMassHaulPanel(
     // 툴팁은 setOpen이 일반 문구로 덮으므로 매번 유토곡선용으로 다시 밝힌다.
     handleControl.root.title = next ? "유토곡선 접기" : "유토곡선 펼치기";
     handle.classList.toggle("is-open", next);
-    // 접으면 머리줄만 남는다(배수유역도처럼 손잡이는 늘 닿음)
+    // 접으면 손잡이만 남는다(배수유역도처럼 손잡이는 늘 닿음)
     overlay.classList.toggle("is-collapsed", !next);
     onChanged();
   }
@@ -279,29 +266,14 @@ export function createRouteMassHaulPanel(
     onChanged();
   }
 
-  // 종단 스크롤러와의 양방향 동기화 — 메아리는 공용 도우미가 걸러 냄(354-3).
-  // 토량 분배(전체 맞춤) 중에는 끊는다 — 유토곡선이 0 으로 붙으며 낸 scroll 이 종단 그래프 ·
-  // 표까지 0 으로 되돌렸다(PLAN 79-1). 유토곡선만 스크롤이 없는 상태.
-  let fitted = false;
-  let syncedMain: HTMLElement | null = null;
-  let putScroll: ((to: HTMLElement, left: number) => void) | null = null;
-  /** 종단과 맞물려 그린 곡선이 놓인 문서 — 처음 · 분배 맞춤 뒤 · 창 옮김 뒤면 종단 자리로 맞춘다. */
-  let syncedIn: Document | null = null;
-  function attachScrollSync(main: HTMLElement): void {
-    if (syncedMain === main) return;
-    syncedMain = main;
-    putScroll = linkScrollLeft(main, scroll, () => fitted);
-  }
-
   /** 곡선을 한 번이라도 그렸는지 — 재계산 대기 중 화면을 비우지 않기 위한 표시. */
   let drawnOnce = false;
-  /** 마지막으로 낸 계열 — 가로 스크롤(보이는 구간만 바뀜)은 다시 셈 없이 이걸로 그린다(354-3). */
+  /** 마지막으로 낸 계열 — 같은 계열이면 총괄값을 다시 내지 않는다. */
   let lastSeries: MassHaulSeries[] | null = null;
 
   function note(message: string): void {
     drawnOnce = false;
     lastSeries = null;
-    syncedIn = null;
     pendingChip.hidden = true;
     bar.replaceChildren();
     scroll.replaceChildren();
@@ -312,11 +284,6 @@ export function createRouteMassHaulPanel(
     bar.append(empty);
   }
 
-  // 세로창 버티기·부드러운 이동 상태 — 이 패널이 사는 동안 하나만 둔다(2026-09-04).
-  const windowState = createMassHaulWindowState();
-  /** 마지막으로 그린 입력 — 이동이 아직 안 끝났으면 다음 프레임에 이걸로 한 번 더 그린다. */
-  let lastParams: RouteMassHaulDrawParams | null = null;
-
   /** 이미 낸 계열에서 총괄값만 꺼낸다 — 계산은 하지 않는다. */
   function emitSummary(series: MassHaulSeries[]): void {
     if (!onSummary) return;
@@ -348,33 +315,16 @@ export function createRouteMassHaulPanel(
     );
   }
 
-  /** 그리기 몫 기록(349-0s) — 묶음 마지막 차례 `work.유토곡선`. `reuse` = 마지막 계열로(다시 셈 없음). */
-  function draw(params: RouteMassHaulDrawParams, reuse = false): void {
-    pipelineWork("유토곡선", () => drawNow(params, reuse));
+  /** 그리기 몫 기록(349-0s) — 묶음 마지막 차례 `work.유토곡선`. */
+  function draw(params: RouteMassHaulDrawParams): void {
+    pipelineWork("유토곡선", () => drawNow(params));
   }
 
-  /** 가로 스크롤로 보이는 구간만 바뀜(354-3) — 곡선이 창을 따를 때만(열림 · 분배 맞춤 아님 · 붙음) ·
-   *  한 틀 한 번 · 다시 셈 없이 세로 창만 다시 그림. 접힘 · 분배 · 새 창은 스크롤마다 할 일 없음. */
-  let windowDirty = false;
-  function drawWindow(params: RouteMassHaulDrawParams): void {
-    if (!open || fitted || overlay.classList.contains("is-popout") || !lastSeries) return;
-    lastParams = params;
-    // 미끄러짐 틀이 이미 잡혀 있으면 그 틀이 이 값으로 그림
-    if (windowDirty || windowState.frame) return;
-    windowDirty = true;
-    frameOf(overlay, () => {
-      if (windowDirty && lastParams) draw(lastParams, true);
-    });
-  }
-
-  function drawNow(params: RouteMassHaulDrawParams, reuse: boolean): void {
-    lastParams = params;
-    windowDirty = false;
+  function drawNow(params: RouteMassHaulDrawParams): void {
     overlay.classList.toggle("is-collapsed", !open);
     // 접혀 있어도 상단줄에는 값이 서야 한다 — 이때는 **횡단 기준만** 적분한다.
     // 펼친 경우에는 아래에서 낸 계열로 총괄값을 낸다(계산 한 번).
     if (!shown()) {
-      syncedIn = null;
       reportSummary(params);
       return;
     }
@@ -407,17 +357,13 @@ export function createRouteMassHaulPanel(
     // (354-2 · 계산 코드는 공용에 남김).
     // 결과를 아껴 두지 **않는다** — 횡단 설계가 제자리에서 갈리므로 객체 동일성으로는
     // 바뀐 것을 못 잰다(2026-09-04 캐시를 넣었다가 곡선이 안 따라와 되돌림).
-    // 스크롤로 창만 바뀐 그리기(`reuse`)는 직전 계열 그대로 — 같은 입력의 두 번째 적분이었다(354-3).
-    const series: MassHaulSeries[] =
-      reuse && lastSeries
-        ? lastSeries
-        : computeMassHaulSeries(
-            params.longitudinal,
-            params.crossSections,
-            context.conversion,
-            context.naturalSpoilMinSlope,
-            ["cross"],
-          );
+    const series: MassHaulSeries[] = computeMassHaulSeries(
+      params.longitudinal,
+      params.crossSections,
+      context.conversion,
+      context.naturalSpoilMinSlope,
+      ["cross"],
+    );
     // 총괄값은 방금 낸 계열에서 꺼낸다 — 접힘 경로처럼 따로 적분하지 않는다.
     if (series !== lastSeries) emitSummary(series);
     lastSeries = series;
@@ -446,29 +392,16 @@ export function createRouteMassHaulPanel(
       (overlay.clientHeight || OVERLAY_DEFAULT_HEIGHT) - bar.offsetHeight - 12;
     const chartHeight = Math.max(scrollHeight, MASS_HAUL_MIN_HEIGHT);
 
-    // 토량 분배를 켜면 **곡선 전체가 한 화면에** 들어와야 한다(2026-09-06 사용자 지시).
-    // 평형선·운반 블록은 노선 전체를 놓고 읽는 그림이라, 종단 그래프와의 X 맞춤(가로
-    // 스크롤)과 보이는 구간만 보는 Y 창을 둘 다 버리고 스크롤러 안쪽 폭·전 구간 Y로 그린다.
-    // 종단과 맞물릴 필요가 없으므로 반 칸 들여쓰기(originOffset)도 쓰지 않는다 — 그만큼
-    // 좌우가 비어 곡선이 가운데로 쪼그라들었다(2026-09-06 사용자 보고: 「우측 여유 과다」).
-    const fitAll = haulPlan !== null;
-    fitted = fitAll;
-    const widthPx = fitAll ? scroll.clientWidth || params.widthPx : params.widthPx;
-    const chartAxis = fitAll
-      ? {
-          ...params.axis,
-          padLeft: params.axis.axisX ?? params.axis.padLeft,
-          padRight: MASS_FIT_PAD_RIGHT,
-          viewRange: undefined,
-          window: undefined,
-          hideStations: true,
-        }
-      : {
-          ...params.axis,
-          // 새 창으로 뗀 판은 넓어 메인 보이는 구간 세로면 잘림 — 노선 전체 세로(325-2).
-          viewRange: overlay.classList.contains("is-popout") ? undefined : params.axis.viewRange,
-          window: windowState,
-        };
+    // 늘 **곡선 전체가 한 화면에**(367-1 · 측점 연계 보기 없앰) — 스크롤러 안쪽 폭 · 전 구간 Y ·
+    // 측점선 없음. 반 칸 들여쓰기(originOffset)도 안 씀(2026-09-06 「우측 여유 과다」).
+    const widthPx = scroll.clientWidth || params.widthPx;
+    const chartAxis = {
+      ...params.axis,
+      padLeft: params.axis.axisX ?? params.axis.padLeft,
+      padRight: MASS_FIT_PAD_RIGHT,
+      viewRange: undefined,
+      hideStations: true,
+    };
 
     let massAxis: { padLeft: number; ticks: Array<{ y: number; label: string }> } | null = null;
     const chart = createMassHaulChart(
@@ -495,33 +428,17 @@ export function createRouteMassHaulPanel(
     wrap.append(chart);
     // 앵커는 첫 자식 — SVG 뒤면 흐름 위치가 밀려 스크롤 시 축이 안 보인다(B06과 같은 규칙).
     if (massAxis) wrap.prepend(buildStickyYAxis(massAxis, chartHeight));
-    // 이미 종단과 맞물려 그린 곡선이면 제 자리 그대로 — 종단 값으로 되쓰면 그 사이 유토 쪽 휠이
-    // 더 간 만큼 뒤로 튐(354-3). 처음 · 분배 맞춤 뒤 · 창 옮김 뒤만 종단 자리에서 시작한다.
-    const keepLeft = !fitAll && syncedIn === scroll.ownerDocument ? scroll.scrollLeft : null;
     scroll.replaceChildren(wrap);
-    // 전체 맞춤일 때는 스크롤할 것이 없으므로 왼쪽 끝에 둔다.
-    if (fitAll) scroll.scrollLeft = 0;
-    else if (keepLeft !== null) scroll.scrollLeft = keepLeft;
-    else if (syncedMain) putScroll?.(scroll, syncedMain.scrollLeft);
-    syncedIn = fitAll ? null : scroll.ownerDocument;
+    // 스크롤할 것이 없으므로 왼쪽 끝에 둔다.
+    scroll.scrollLeft = 0;
 
-    // 범례는 계열 · 켬이 바뀔 때만 — 스크롤 그리기는 그대로 둔다.
-    if (!reuse || !legendLayer.firstChild)
-      legendLayer.replaceChildren(
-        createMassHaulLegend(series, visible, toggleSeries, () => {
-          resetBalloonOffsets();
-          onChanged();
-        }),
-      );
-    drawnOnce = true;
-    // 세로창이 아직 목표까지 안 갔으면 다음 프레임에 한 걸음 더 — 확 튀지 않고 미끄러진다.
-    scheduleMassHaulSettle(
-      windowState,
-      () => {
-        if (lastParams) draw(lastParams, true);
-      },
-      overlay,
+    legendLayer.replaceChildren(
+      createMassHaulLegend(series, visible, toggleSeries, () => {
+        resetBalloonOffsets();
+        onChanged();
+      }),
     );
+    drawnOnce = true;
   }
 
   return {
@@ -531,8 +448,6 @@ export function createRouteMassHaulPanel(
     setContext(next) {
       context = next;
     },
-    attachScrollSync,
-    draw: (params) => draw(params),
-    drawWindow,
+    draw,
   };
 }
diff --git a/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts b/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts
index 12bc11376..6372ff738 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts
@@ -49,7 +49,8 @@ export interface PanelToolsContext {
   base: () => AlignmentBase | null;
   alignment: () => ProfileAlignment | null;
   edits: () => AlignmentEdits;
-  applyEdits: (next: AlignmentEdits) => void;
+  /** false = 막힘(기울기 · 흙덮기). */
+  applyEdits: (next: AlignmentEdits) => boolean;
   /** 고른 측점 id(없으면 null). */
   selectedStationId: () => string | null;
   /** 비정규(구조물) 측점 목록 — 좌우 이동 대상 판정에 쓴다. */
@@ -157,10 +158,11 @@ export function createPanelTools(ctx: PanelToolsContext): PanelTools {
       history.record();
     },
     canResetToSaved: ctx.canRestoreSaved,
-    onUndo: () => inner.undo(),
-    onRedo: () => inner.redo(),
-    canUndo: () => inner.canUndo(),
-    canRedo: () => inner.canRedo(),
+    // 자유지정 동안 ↶ ↷ = 자유지정 안 한 걸음(367-3) — 큰 이력은 안 건드림.
+    onUndo: () => (tools.mode() === "free" ? (free.undo(), freeView.redraw()) : inner.undo()),
+    onRedo: () => (tools.mode() === "free" ? (free.redo(), freeView.redraw()) : inner.redo()),
+    canUndo: () => (tools.mode() === "free" ? free.canUndo() : inner.canUndo()),
+    canRedo: () => (tools.mode() === "free" ? free.canRedo() : inner.canRedo()),
     hasStraightRuns: () => {
       const alignment = ctx.alignment();
       return alignment ? hasStraightRuns(alignment) : false;
@@ -327,6 +329,13 @@ export function createPanelTools(ctx: PanelToolsContext): PanelTools {
     // 한 줄 되돌리기(346-4) — 평면 · 종단 · 횡단 · 관 · 구조물을 만진 차례 거꾸로.
     if (isCtrlKey(event, "z") || isCtrlKey(event, "y")) {
       event.preventDefault();
+      // 자유지정 동안은 자유지정 안만 — 되돌릴 것 없어도 큰 이력으로 안 감(367-3)
+      if (tools.mode() === "free") {
+        if (event.shiftKey || isCtrlKey(event, "y")) free.redo();
+        else free.undo();
+        freeView.redraw();
+        return;
+      }
       flushHold();
       if (event.shiftKey || isCtrlKey(event, "y")) history.redo();
       else history.undo();
diff --git a/B05_Profile/B05_Profile_UI_Profile_Render.ts b/B05_Profile/B05_Profile_UI_Profile_Render.ts
index ad3b09227..36095813d 100644
--- a/B05_Profile/B05_Profile_UI_Profile_Render.ts
+++ b/B05_Profile/B05_Profile_UI_Profile_Render.ts
@@ -71,7 +71,6 @@ export interface ProfileRenderContext {
   callbacks: RouteProfilePanelCallbacks | undefined;
   massHaul: {
     draw: (params: RouteMassHaulDrawParams) => void;
-    drawWindow: (params: RouteMassHaulDrawParams) => void;
   };
   tableOverlay: {
     isOpen: () => boolean;
@@ -362,8 +361,6 @@ export function renderProfile(ctx: ProfileRenderContext): void {
   });
   // 세로 창 갱신기 — 가로로 스크롤할 때마다 패널이 이것을 부른다. 도형은 그대로 두고
   // 겹 하나의 변환만 갈아 끼우므로 매 프레임 불러도 된다(2026-09-04 사용자 확정).
-  // 유토곡선 갱신기 — 아래에서 유토곡선을 그린 뒤 채워진다(그리기 순서상 여기서는 아직 없다).
-  let massHaulUpdater: ((fromM: number, toM: number) => void) | null = null;
   ctx.setElevationWindowUpdater(() => {
     const from = Math.max(0, toChainage(body.scrollLeft));
     const to = Math.min(maxChainageM, toChainage(body.scrollLeft + body.clientWidth));
@@ -374,7 +371,6 @@ export function renderProfile(ctx: ProfileRenderContext): void {
         to,
       ) ?? null,
     );
-    massHaulUpdater?.(from, to);
     return applyElevationWindow(chartWrap, next);
   });
 
@@ -477,15 +473,5 @@ export function renderProfile(ctx: ProfileRenderContext): void {
       onSelectStation: ctx.selectStation,
     };
     massHaul.draw(massHaulParams);
-    // 유토곡선도 **같은 창**을 본다(2026-09-04 사용자 확정) — 스크롤할 때마다 곡선만 다시
-    // 그린다. 종단처럼 변환으로 옮기지 않는 이유: 곡선 위에 앉는 말풍선·EP 표·측점 점이
-    // 세로로 늘어나면 안 되는 것들이라, 그것만 따로 옮기는 값이 곡선 자체를 다시 그리는
-    // 값보다 크다(요소 수가 종단의 1/3). 열림 · 분배 맞춤 아닐 때만 · 한 틀 한 번 · 다시 셈 없음(354-3).
-    massHaulUpdater = (fromM, toM) => {
-      massHaul.drawWindow({
-        ...massHaulParams,
-        axis: { ...massHaulParams.axis, viewRange: { fromM, toM } },
-      });
-    };
   }
 }
diff --git a/B05_Profile/B05_Profile_UI_RouteEdit.ts b/B05_Profile/B05_Profile_UI_RouteEdit.ts
index 3d05ffc66..540c6e57a 100644
--- a/B05_Profile/B05_Profile_UI_RouteEdit.ts
+++ b/B05_Profile/B05_Profile_UI_RouteEdit.ts
@@ -56,7 +56,6 @@ import {
   captureView,
   createViewMemory,
   fitCanvas,
-  fitView,
   openingView,
   restoreSavedView,
   screenToMetric,
@@ -92,6 +91,7 @@ import {
 import type { DesignPageHost } from "../A00_Common/design/design_page";
 import * as draftLink from "./B05_Profile_UI_RouteEdit_Draft";
 import { bindRouteShift } from "./B05_Profile_UI_RouteEdit_Shift";
+import * as fit from "./logic/B05_Profile_RouteEdit_StationFit";
 import "./B05_Profile_UI_Style_RouteEdit.css";
 
 /** 등고선 눈금을 고를 때 쓸 라벨 예산 — B04 지도 기본값(350)보다 **넉넉히** 둔다
@@ -160,7 +160,7 @@ export async function mountRouteEditor(
   let apexLock: boolean[] = [];
   /** 지금 고른 꺾임점 — 곡선 편집줄이 이 자리를 만진다. 없으면 -1. */
   let picked = -1;
-  /** [측점 스냅](요구 224-2) — 보기 모드라 되돌리기 밖 · 열 때 서버 값 · [확인] 때 저장. */
+  /** [측점 스냅](224-2 · 366-3) — 켬 = 곡선 MC 를 일반측점에 · 켬끔 자체는 되돌리기 밖 · [저장] 때 저장. */
   let stationSnap = false;
   let savedStationSnap = false;
   /** 편집 창 측점 한 곳 — 끔이면 null(간격마다) · 켬이면 호 안 하나를 곡선 중점으로.
@@ -195,7 +195,7 @@ export async function mountRouteEditor(
   /** 등고선 자물쇠(353-2) — 잠긴 동안 빈 곳 · 다른 가닥을 눌러도 고른 것이 안 바뀜. */
   const contourLock = createContourLock(
     canvas,
-    () => contours && { layer: contours.layer, view, stepM: contourStepM(), rotation },
+    () => contours && { ...contours, view, rotation, stepM: contourStepM(), picked: pickedContour },
     (index) => ((pickedContour = index), draw()),
   );
   /** 측점 횡단 미리보기 창 — 측점 눈금을 누르면 뜬다(계획서 0-9 ⑧). */
@@ -266,7 +266,7 @@ export async function mountRouteEditor(
   const showMinorContours = bindMinorContourToggle(minorContourButton, () => draw());
   stationSnapButton.addEventListener("click", () => {
     setStationSnap(!stationSnap);
-    void crossPreview.refresh(); // 떠 있는 횡단도 옮긴 측점 규칙으로.
+    if (stationSnap && history) applyEdit("곡선 가운데(MC)를 일반측점에 맞췄습니다."); // 전체 · 한 걸음
     draw();
   });
   /** 보던 화면 기억(계획서 18 ③) — 자료를 읽고 화면을 되살린 **뒤부터** 적는다. */
@@ -318,13 +318,6 @@ export async function mountRouteEditor(
     rotation.set(opening.rotationRad);
     viewReady = true;
   }
-  // [맞춤] — 처음 그림과 같은 등고 영역 맞춤(회전 0 · 349-0). 셈은 `_View` 몫.
-  overlay.querySelector('[data-act="fit"]')!.addEventListener("click", () => {
-    if (!meta || view.width <= 0 || !planned.length) return;
-    view = fitView(meta, view, planned, contours?.layer ?? null);
-    rotation.set(0);
-    draw();
-  });
 
   const toScreen = (vertex: Vertex): [number, number] =>
     meta ? metricToScreen(meta, view, vertex[0], vertex[1]) : [0, 0];
@@ -423,6 +416,7 @@ export async function mountRouteEditor(
       violationCount: nodeInfo.filter((node) => node.violations.length).length,
       minRadiusM,
       fresh: nodeInfo.length === 0,
+      offStation: stationSnap ? fit.offStationCount(plannedLine, curveInfo, stationIntervalM) : 0,
     });
 
   // ── 곡선 라벨 — 고른 꺾임점 옆에 뜨는 조작 패널. 배선은 `_CurveBar` 몫 ──
@@ -453,8 +447,12 @@ export async function mountRouteEditor(
   const curveLabelBox = curveBar.label;
   const syncCurveBar = curveBar.sync;
 
-  /** 한 번의 편집을 마무리한다 — 다시 그리고, 라벨·상태줄을 맞추고, 되돌리기에 쌓는다. */
-  function applyEdit(message: string, record = true): void {
+  /** 한 번의 편집을 마무리한다 — 다시 그리고, 라벨·상태줄을 맞추고, 되돌리기에 쌓는다.
+   *  측점 스냅 켬이면 고친 자리 앞 곡선부터 MC 를 일반측점에(366-3 · 되살림 `fitting=false` 은 안 맞춤). */
+  function applyEdit(message: string, record = true, fitting = true): void {
+    const limits = { minRadiusM, limitRadiusM, limitArcM, intervalM: stationIntervalM };
+    const from = fit.fitStart(history?.current?.(), snapshotNow());
+    if (stationSnap && fitting) planned = fit.fitCurveStations(snapshotNow(), limits, from);
     markEdited();
     writeRouteLocks(projectId, planned, apexLock); // 고정은 [취소] · 다시 열기에도 남는다(22-5).
     syncCurveBar();
@@ -484,7 +482,7 @@ export async function mountRouteEditor(
     const locks = record ? routeLocksOf(planned, apexLock) : null;
     ({ planned, curveOn, curveRadius, curveLock, curveArc, apexLock, picked } = snapshot);
     if (locks) apexLock = lockColumn(planned, locks);
-    applyEdit(message, record);
+    applyEdit(message, record, false); // 되돌리기 · 추천 [적용] · 초안 되살림은 안 맞춤(366-3)
   }
 
   const historyControls = bindHistoryControls({
@@ -540,6 +538,7 @@ export async function mountRouteEditor(
     curveHint,
     contourHint,
     commit: () => {
+      if (stationSnap) return applyEdit("곡선 가운데(MC)를 일반측점에 맞췄습니다."); // 놓을 때(366-3)
       history?.commit(snapshotNow());
       historyControls.sync();
     },
@@ -684,7 +683,6 @@ export async function mountRouteEditor(
         useBackground(background);
         measure.clear();
         slope.refresh();
-        void crossPreview.refresh();
         showStatus();
         draw();
       });
diff --git a/B05_Profile/B05_Profile_UI_RouteEdit_Apply.ts b/B05_Profile/B05_Profile_UI_RouteEdit_Apply.ts
index 8e19191ef..796b9022a 100644
--- a/B05_Profile/B05_Profile_UI_RouteEdit_Apply.ts
+++ b/B05_Profile/B05_Profile_UI_RouteEdit_Apply.ts
@@ -128,7 +128,6 @@ export function routeSaveSummary(saved: RouteReplanResponse, outside = 0): strin
     `구조물 옮김 ${saved.structures?.moved ?? 0}`,
     `멀어짐 ${saved.structures?.far ?? 0}`,
   ];
-  if (saved.pipes?.concave) parts.splice(2, 0, `오목 보충 관 ${saved.pipes.concave}`);
   const dropped = (saved.cross_dropped ?? 0) + outside;
   if (dropped) parts.push(`노선 밖 고침 ${dropped} 건`);
   if (saved.drainage_stale) parts.push("배수유역 낡음");
diff --git a/B05_Profile/B05_Profile_UI_RouteEdit_Chrome.ts b/B05_Profile/B05_Profile_UI_RouteEdit_Chrome.ts
index 211b0658a..13021c9e8 100644
--- a/B05_Profile/B05_Profile_UI_RouteEdit_Chrome.ts
+++ b/B05_Profile/B05_Profile_UI_RouteEdit_Chrome.ts
@@ -11,6 +11,7 @@ import { bindFootprintToggle } from "./B05_Profile_UI_RouteEdit_Footprint";
  * **배치**(352-1) — 지도가 칸 전체 · 머리 줄 · 테두리 없음. 도구는 3D 와 같은 떠 있는 유리 단추
  * (지도 왼쪽 위 · ☰ 비킴), [?] 조작 설명은 도구줄 아래 2열, 상태·범례는 왼쪽 아래, 잰 값은 오른쪽
  * 아래. 횡단 두 판은 지도 오른쪽을 덮는 판(아래 종단 판이 그 위).
+ * 도구줄 차례(366-2) — [?] | ↶ ↷ | 3D | ⟲ ⟳ · 1m 등고선 · 절/성토선 · 거리 재기 | 측점 스냅 · 분석 지형.
  *
  * 자리(345-3) — 모달이 아니라 종단 보기 가운데 위 본문(옛 3D 자리)에 붙는다. 덮개 · 전체 화면 ·
  * 닫기 단추는 걷었다 · [취소] · [확인] · [노선 반영] · [저장 전으로]는 없앰(346-3 · 352-2 — 노선은 페이지
@@ -60,8 +61,31 @@ export function createRouteEditChrome(
     <div class="b05-routeedit__canvas-wrap" aria-label="계획노선 편집">
         <canvas class="b05-routeedit__canvas"></canvas>
         <div class="b05-route__view-controls b05-routeedit__tools">
+          <button type="button" class="ui-btn ui-btn--glass b05-routeedit__hint-toggle"
+            data-act="hint-toggle" aria-expanded="false" title="조작 도움말 펼치기 · 접기">?</button>
+          <i class="b05-route__view-separator" aria-hidden="true"></i>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="undo"
+            title="되돌리기 (Ctrl+Z)" aria-label="되돌리기" disabled>↶</button>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="redo"
+            title="다시하기 (Ctrl+Y)" aria-label="다시하기" disabled>↷</button>
+          <i class="b05-route__view-separator" aria-hidden="true"></i>
           <span data-slot="tools"></span>
           <i class="b05-route__view-separator" aria-hidden="true"></i>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="rotate-ccw"
+            title="반시계로 돌리기" aria-label="반시계로 돌리기">${HALF_TURN_ICON.ccw}</button>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="rotate-cw"
+            title="시계로 돌리기" aria-label="시계로 돌리기">${HALF_TURN_ICON.cw}</button>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="contour-minor"
+            aria-pressed="false" disabled
+            title="1m 간격 등고선을 얇고 옅게 겹칩니다 (확대하면 보임)">1m 등고선</button>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="footprint"
+            title="도로 끝 · 비탈 끝(깎기 붉음 · 쌓기 파랑)을 평면에 겹칩니다">절/성토선</button>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="measure"
+            title="노선 위 두 점을 눌러 거리·기울기를 잽니다 (Shift+클릭도 같음)">거리 재기</button>
+          <i class="b05-route__view-separator" aria-hidden="true"></i>
+          <button type="button" class="ui-btn ui-btn--glass" data-act="station-snap"
+            aria-pressed="false"
+            title="켜면 곡선 가운데(MC)를 가까운 일반측점에 맞춥니다 — 놓을 때 고친 자리부터 교각점을 간격 절반 안에서 밂 · 고정 교각점은 그대로 · 못 맞춘 곡선은 상태줄 「측점 밖 곡선」 · [저장] 때 저장">측점 스냅</button>
           <label class="b05-routeedit__terrain" hidden
             title="노선 편집 분석(등고선 · 지반고 · 기울기 · 횡단 미리보기 · 추천)에 쓸 지형 — 확정 지표면 · 종횡단은 안 바뀝니다">분석 지형
             <select class="ui-select ui-select--sm" data-act="terrain">
@@ -69,27 +93,8 @@ export function createRouteEditChrome(
               <option value="sheet">수치지형도</option>
             </select>
           </label>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="fit"
-            title="등고 영역(등고선 범위 · 노선)을 평면 가운데 알맞게 맞춥니다 (회전은 풂)">맞춤</button>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="contour-minor"
-            aria-pressed="false" disabled
-            title="1m 간격 등고선을 얇고 옅게 겹칩니다 (확대하면 보임)">1m 등고선</button>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="measure"
-            title="노선 위 두 점을 눌러 거리·기울기를 잽니다 (Shift+클릭도 같음)">거리 재기</button>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="station-snap"
-            aria-pressed="false"
-            title="곡선(호) 안 측점 하나를 곡선 중점(MC)으로 옮깁니다 — [저장] 때 저장">측점 스냅</button>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="footprint"
-            title="도로 끝 · 비탈 끝(깎기 붉음 · 쌓기 파랑)을 평면에 겹칩니다">절/성토선</button>
-          <i class="b05-route__view-separator" aria-hidden="true"></i>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="undo"
-            title="되돌리기 (Ctrl+Z)" aria-label="되돌리기" disabled>↶</button>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="redo"
-            title="다시하기 (Ctrl+Y)" aria-label="다시하기" disabled>↷</button>
         </div>
         <div class="b05-routeedit__hint">
-          <button type="button" class="ui-btn ui-btn--glass b05-routeedit__hint-toggle"
-            data-act="hint-toggle" aria-expanded="false" title="조작 도움말 펼치기 · 접기">?</button>
           <div class="b05-routeedit__hint-body">
           <span>노드 끌기 = 옮기기</span><span>노드 클릭 = R 라벨</span>
           <span>선 두 번 클릭 = 노드 추가</span><span>노드 오른쪽 클릭 = 삭제</span>
@@ -97,12 +102,6 @@ export function createRouteEditChrome(
           <span>가운데(휠) 버튼 끌기 = 지도 이동</span><span>휠 = 확대</span>
           </div>
         </div>
-        <div class="b05-routeedit__spin">
-          <button type="button" class="ui-btn ui-btn--glass" data-act="rotate-ccw"
-            title="반시계로 돌리기" aria-label="반시계로 돌리기">${HALF_TURN_ICON.ccw}</button>
-          <button type="button" class="ui-btn ui-btn--glass" data-act="rotate-cw"
-            title="시계로 돌리기" aria-label="시계로 돌리기">${HALF_TURN_ICON.cw}</button>
-        </div>
         <div class="b05-routeedit__measure" hidden>
           <span class="b05-routeedit__measure-text"></span>
           <span data-slot="measure-close"></span>
@@ -142,7 +141,7 @@ export function createRouteEditChrome(
 
   // 도움말 = 기본 접힘 · [?] 한 번에 펼침(345-5 덧 3).
   const hint = overlay.querySelector<HTMLElement>(".b05-routeedit__hint")!;
-  const hintToggle = hint.querySelector<HTMLButtonElement>('[data-act="hint-toggle"]')!;
+  const hintToggle = overlay.querySelector<HTMLButtonElement>('[data-act="hint-toggle"]')!;
   const setHint = (open: boolean): void => {
     hintOpen = open;
     hint.classList.toggle("is-open", open);
diff --git a/B05_Profile/B05_Profile_UI_RouteEdit_ContourLock.ts b/B05_Profile/B05_Profile_UI_RouteEdit_ContourLock.ts
index e8e52b173..146717a3c 100644
--- a/B05_Profile/B05_Profile_UI_RouteEdit_ContourLock.ts
+++ b/B05_Profile/B05_Profile_UI_RouteEdit_ContourLock.ts
@@ -1,10 +1,11 @@
 /* =============================================================================
  * B05_Profile_UI_RouteEdit_ContourLock.ts
- * 평면 등고선 자물쇠(353-2) — 등고선 위를 지나거나 고른 가닥 위에 뜨는 작은 단추.
+ * 평면 등고선 자물쇠(353-2) — 가닥을 고른 때만 누른 자리 옆에 뜨는 작은 단추(366-1 · 지나기만 = 안 뜸).
  *
- * 누르면 그 높이를 고정(빈 곳 · 다른 가닥을 눌러도 고른 것이 안 바뀜) · 다시 누르면 풂.
+ * 누르면 그 높이를 고정(빈 곳 · 다른 가닥을 눌러도 고른 것이 안 바뀜) · 잠근 높이 가닥을 다시
+ * 누르면 풀기 단추 · 다음 클릭 · 휠 · 떠남(0.7 s)에 숨김.
  * 높이값으로 쥐어 지형을 바꿔도 같은 높이를 다시 짚음 · 페이지 동안만(저장 안 함).
- * 규칙은 `logic/B05_Profile_ContourLock` · 호버 판정은 집기와 같은 `hitPreparedLayer`.
+ * 규칙은 `logic/B05_Profile_ContourLock` · 누름 판정은 집기와 같은 `hitPreparedLayer`.
  * ========================================================================== */
 
 import { pickPx } from "../A00_Common/touch_bridge";
@@ -22,8 +23,10 @@ import {
 import "./B05_Profile_UI_Style_RouteEdit_ContourLock.css";
 
 /** 집기(`_Pointer` CONTOUR_HIT_PX)와 같은 거리(px). */
-const HOVER_HIT_PX = 6;
-/** 커서가 선을 떠난 뒤 단추가 남는 시간(ms) — 단추로 옮겨 갈 틈. */
+const HIT_PX = 6;
+/** 누름 ~ 뗌 사이 이만큼(px) 넘게 움직이면 끌기 — 고르기 아님. */
+const MOVE_PX = 4;
+/** 커서가 지도를 떠난 뒤 단추가 남는 시간(ms) — 단추로 옮겨 갈 틈. */
 const HIDE_DELAY_MS = 700;
 /** 단추는 커서 오른쪽 위로 이만큼(px) — 선과 커서를 안 가림. */
 const OFFSET_PX = 12;
@@ -33,12 +36,14 @@ const LOCK_SVG = `<svg viewBox="0 0 16 16" width="14" height="14" aria-hidden="t
   <path class="b05-contourlock__shackle" d="M5 7V5a3 3 0 0 1 6 0v2" fill="none"
     stroke="currentColor" stroke-width="1.6"/></svg>`;
 
-/** 호버 판정에 쓰는 지금 화면 — 등고선이 없으면 null. */
+/** 누름 판정에 쓰는 지금 화면 — 등고선이 없으면 null. */
 export interface ContourLockScene {
   layer: PreparedLayer;
   view: ViewState;
-  /** 지금 화면 등고선 간격 — 그리지 않은 줄은 호버도 안 됨. */
+  /** 지금 화면 등고선 간격 — 그리지 않은 줄은 안 잡힘. */
   stepM: number;
+  /** 고른 가닥 번호(없으면 -1) — 안 잠김이면 이 가닥을 누를 때만 뜸. */
+  picked: number;
   rotation: { unrotate: (px: number, py: number) => [number, number] };
 }
 
@@ -68,8 +73,8 @@ export function createContourLock(
   /** 단추가 가리키는 가닥 — 누르면 이 가닥을 잠금. */
   let target = -1;
   let hideTimer = 0;
-  let frame = 0;
-  let last: PointerEvent | null = null;
+  let downX = 0;
+  let downY = 0;
 
   const levelOf = (index: number): number | null =>
     index >= 0 ? (scene()?.layer.features[index]?.labelValue ?? null) : null;
@@ -96,17 +101,24 @@ export function createContourLock(
     hideTimer = 0;
   };
 
-  const hover = (event: PointerEvent): void => {
+  const hide = (): void => {
+    keep();
+    button.hidden = true;
+  };
+
+  /** 누름을 뗀 자리 — 고른 가닥(잠김이면 잠근 높이 가닥)일 때만 그 옆에 띄움. */
+  const showAt = (event: PointerEvent): void => {
     const now = scene();
-    // 단추를 누른 채(노드 · 손잡이 끌기 · 화면 이동) 지나가면 안 봄
-    if (!now || event.buttons !== 0) return hideLater();
+    // 끌기 · 화면 이동 · 재기(Shift)는 고르기가 아님
+    const moved = Math.hypot(event.clientX - downX, event.clientY - downY) > MOVE_PX;
+    if (!now || event.button !== 0 || event.shiftKey || moved) return;
     const rect = canvas.getBoundingClientRect();
     const [px, py] = now.rotation.unrotate(event.clientX - rect.left, event.clientY - rect.top);
-    const hitPx = pickPx(HOVER_HIT_PX);
+    const hitPx = pickPx(HIT_PX);
     const index = hitPreparedLayer(now.layer, now.view, px, py, hitPx, now.stepM);
-    const state = lockButtonState(levelOf(index), lockedLevel);
-    if (!state.visible) return hideLater();
-    keep();
+    if (!lockButtonState(levelOf(index), lockedLevel, index >= 0 && index === now.picked).visible) {
+      return;
+    }
     target = index;
     const origin = wrap.getBoundingClientRect();
     button.style.left = `${Math.round(event.clientX - origin.left + OFFSET_PX)}px`;
@@ -115,17 +127,14 @@ export function createContourLock(
     paint();
   };
 
-  // 한 프레임에 한 번만 잼 — 도엽 등고선은 수천 가닥.
-  canvas.addEventListener("pointermove", (event) => {
-    last = event;
-    if (frame) return;
-    frame = requestAnimationFrame(() => {
-      frame = 0;
-      if (last) hover(last);
-    });
+  // 다음 클릭 · 휠에 숨김 — 집기(`_Pointer`)보다 먼저 달려 있어 고른 뒤 pointerup 이 다시 띄움.
+  canvas.addEventListener("pointerdown", (event) => {
+    downX = event.clientX;
+    downY = event.clientY;
+    hide();
   });
-  // 고른 직후(누름을 뗀 자리)에도 띄움 — 터치는 호버가 없음.
-  canvas.addEventListener("pointerup", hover);
+  canvas.addEventListener("pointerup", showAt);
+  canvas.addEventListener("wheel", hide, { passive: true });
   canvas.addEventListener("pointerleave", hideLater);
   button.addEventListener("pointerenter", keep);
   button.addEventListener("pointerleave", hideLater);
diff --git a/B05_Profile/B05_Profile_UI_RouteEdit_Cross.ts b/B05_Profile/B05_Profile_UI_RouteEdit_Cross.ts
index c0b491141..c93d4d2b9 100644
--- a/B05_Profile/B05_Profile_UI_RouteEdit_Cross.ts
+++ b/B05_Profile/B05_Profile_UI_RouteEdit_Cross.ts
@@ -2,22 +2,24 @@
  * B05_Profile_UI_RouteEdit_Cross.ts
  * 계획노선 편집 중 **측점 횡단** — 메인 창 오른쪽 세로 칸에 **붙박이 두 판**(계획서 0-9 ⑱⑲).
  *
- *   · 위 판 = **지금 횡단**. 측점 눈금을 누르면 그 측점을 셈해 여기에 낸다.
+ *   · 위 판 = **지금 횡단**. 측점 눈금을 누르면 그 측점 횡단을 여기에 낸다.
  *   · 아래 판 = **이전 횡단**. 평소에는 빈 화면이고, 노선을 고쳐 **노드를 놓는 순간**
- *     위 판의 것이 이리로 내려오고 새로 셈한 것이 위로 올라간다 — 전후를 나란히 본다.
+ *     위 판의 것이 이리로 내려오고 새 횡단이 위로 올라간다 — 전후를 나란히 본다.
  *
- * 보이는 것은 셋뿐이다(2026-09-12 사용자 확정) — **원지반 횡단선 · 기본 계획 횡단선 ·
+ * 보이는 것은 셋뿐이다(2026-09-12 사용자 확정) — **원지반 횡단선 · 계획 횡단선 ·
  * 계획 횡단의 성토사면 길이**. 구조물은 그리지 않는다.
  *
- * ⚠ **계획고는 편집 중에 없다** — [확인] 뒤 전 체인이 낳는 값이다. 그래서 서버가 그 측점의
- * 지반고를 그대로 계획고로 놓고(지반 추종) 사면만 세운 「기본 계획 횡단」을 낸다.
- *
- * 셈은 **B05·B06 정본을 그대로 재사용**한다 — 측점·지반 샘플은 `generate_sections`, 설계선은
- * `compute_cross_design`(서버), 성토사면 길이는 B06 화면이 쓰는 `fillSlopeLengths`.
+ * 값 = 계산 묶음 그 측점(365-3) — 측점 · 지반 표본 = ground 단계 · 계획고 · 설계선 = 종단 → cross 단계
+ * (B06 카드 · 새 노선 상세와 같은 함수 `stationSection`) · 노선 · 계획고가 바뀔 때마다(cross 차례) 다시 그림 ·
+ * 서버 왕복 없음. 성토사면 길이는 B06 화면이 쓰는 `fillSlopeLengths`.
  * ========================================================================== */
 
 import { attachSvgZoomPan, type ZoomPanState } from "../A00_Common/b_svg_zoom_pan";
-import { fetchCrossPreview, type CrossPreviewResponse } from "./B05_Profile_Api_Replan";
+import type { CrossPreviewResponse } from "./B05_Profile_Api_Replan";
+import { pagePipeline } from "../A00_Common/design/design_pipeline_page";
+import type { DesignPipeline } from "../A00_Common/design/logic/design_pipeline";
+import { useDesignStore } from "../A00_Common/design/design_store";
+import { stationSection } from "./logic/B05_Profile_Pipeline_Detail";
 import {
   buildCrossSvg,
   CROSS_PLOT_PAD,
@@ -30,7 +32,7 @@ export interface CrossPreviewParams {
   projectId: string;
   /** 두 판이 들어앉을 오른쪽 세로 칸. */
   side: HTMLElement;
-  /** 지금 편집값 — 셈을 부르는 순간에 읽는다. */
+  /** 지금 편집값 — 측점 표기 간격만 씀(횡단은 계산 묶음 몫 · 365-3). */
   request: () => {
     vertices: Array<{ x: number; y: number; curve: boolean; radius_m: number | null }>;
     min_radius_m: number;
@@ -51,7 +53,7 @@ export interface CrossWatch {
 export interface CrossPreviewWindow {
   /** 그 측점의 횡단을 위 판에 낸다. 아래 판은 비운다 — 전후 비교는 노선을 고쳤을 때만. */
   open: (chainageM: number) => Promise<void>;
-  /** 노선을 고쳤다 — 보던 측점을 **다시 셈해** 전후로 늘어놓는다. 보던 것이 없으면 아무 일도 없다. */
+  /** 다시 그림(묶음 지금 값) — 노선이 바뀌었으면 전후로. 보던 것이 없으면 아무 일도 없다. */
   refresh: () => Promise<void>;
   /** 위 판에 떠 있는 측점과 반폭. 떠 있지 않으면 null. */
   watched: () => CrossWatch | null;
@@ -158,54 +160,96 @@ function createPane(title: string, empty: string): CrossPane {
   };
 }
 
+/** 묶음 출력에서 그 누가거리에 가장 가까운 측점 횡단 — 묶음이 아직 안 셌으면 null. */
+export function pipelineCrossAt(
+  pipe: DesignPipeline | null,
+  chainageM: number,
+  intervalM: number,
+  halfWidthM: number | undefined,
+): CrossPreviewResponse | null {
+  const stations = pipe?.output("ground")?.stations ?? [];
+  if (!pipe || !stations.length) return null;
+  const station = stations.reduce((best, next) =>
+    Math.abs(next.chainageM - chainageM) < Math.abs(best.chainageM - chainageM) ? next : best,
+  );
+  const section = stationSection(station, pipe.output("cross"), {}, intervalM);
+  const reach = Math.max(0, ...section.samples.map((sample) => Math.abs(sample.offset_m ?? 0)));
+  return {
+    status: "success",
+    chainage_m: section.chainage_m,
+    label: section.label ?? null,
+    uphill_side: section.uphill_side ?? null,
+    plan_radius_m: section.plan_radius_m ?? null,
+    curve_widening_m: section.curve_widening_m ?? null,
+    cross_half_width_m: halfWidthM ?? reach,
+    samples: section.samples,
+    design: (section.design as CrossPreviewResponse["design"] | undefined) ?? null,
+  };
+}
+
 export function createCrossPreview(params: CrossPreviewParams): CrossPreviewWindow {
   const current = createPane("횡단", "측점 눈금을 누르면 그 측점 횡단이 뜹니다.");
   const previous = createPane("이전 횡단", "노선을 고치면 고치기 전 횡단이 여기 남습니다.");
   params.side.append(current.root, previous.root);
+  const interval = (): number => params.request().station_interval_m;
 
   /** 지금 보고 있는 측점(누가거리). 아직 없으면 null. */
   let watching: number | null = null;
-  /** 위 판에 그려 둔 것 — 다음 번에 아래로 내릴 재료. */
+  /** 위 판에 그려 둔 것 — 다음 번에 아래로 내릴 재료 · 그때 노선 초안(바뀌면 전후로). */
   let shown: CrossPreviewResponse | null = null;
-  /** 지금 부른 셈 — 늦게 온 응답을 새 자리에 적지 않으려고 든다. */
-  let ticket = 0;
+  let drawnRoute: unknown = null;
 
-  async function load(chainageM: number, keepPrevious: boolean): Promise<void> {
-    const mine = ++ticket;
-    const request = params.request();
-    if (keepPrevious && shown) previous.show(shown, request.station_interval_m);
-    current.wait("읽는 중…");
-    try {
-      const preview = await fetchCrossPreview(params.projectId, {
-        ...request,
-        chainage_m: chainageM,
-        cross_half_width_m: appliedHalfWidth(params.projectId),
-      });
-      if (mine !== ticket) return; // 그 사이 다른 측점을 눌렀다.
-      shown = preview;
-      current.show(preview, request.station_interval_m);
-    } catch (error) {
-      if (mine !== ticket) return;
-      shown = null;
-      current.wait(error instanceof Error ? error.message : "횡단을 읽지 못했습니다.");
-    }
+  function redraw(): void {
+    if (watching === null) return;
+    const route = pipe?.input("route") ?? null;
+    if (route !== drawnRoute && shown) previous.show(shown, interval());
+    drawnRoute = route;
+    shown = pipelineCrossAt(pipe, watching, interval(), appliedHalfWidth(params.projectId));
+    if (shown) current.show(shown, interval());
+    else current.wait("계산 중…");
     params.onShown?.();
   }
 
+  // 묶음 cross 차례마다 다시 그림(노선 · 계획고) — 묶음은 페이지가 세우므로 차례 번호가 날 때 붙음
+  let pipe: DesignPipeline | null = null;
+  let stopPipe = (): void => undefined;
+  let connected = false;
+  const attach = (): void => {
+    if (current.root.isConnected) connected = true;
+    else if (connected) return stop(); // 편집 창이 닫혔다
+    const now = pagePipeline(params.projectId);
+    if (now === pipe) return;
+    stopPipe();
+    pipe = now;
+    stopPipe =
+      now?.subscribe((event) => {
+        if (event.kind === "stage" && event.stage === "cross") redraw();
+      }, "평면 횡단 판") ?? ((): void => undefined);
+  };
+  const stopStore = useDesignStore(params.projectId, null).subscribe("generation", attach);
+  const stop = (): void => {
+    stopStore();
+    stopPipe();
+  };
+  attach();
+
   return {
     async open(chainageM) {
       // 아래 판은 **노선을 고쳤을 때만** 채운다(2026-09-12 사용자 지시 ⑤). 예전에는 같은
       // 측점을 두 번 누르면 위·아래에 **같은 그림 두 장**이 떠 전후 비교가 되지 않았다.
-      previous.show(null, params.request().station_interval_m);
+      previous.show(null, interval());
       watching = chainageM;
-      await load(chainageM, false);
+      attach();
+      drawnRoute = pipe?.input("route") ?? null;
+      shown = null;
+      redraw();
     },
     async refresh() {
-      if (watching === null) return;
-      await load(watching, true);
+      attach();
+      redraw();
     },
     // 자리는 보던 측점 그대로 — 노선을 끄는 동안 평면도가 그 누가거리로 다시 짚는다.
-    // 반폭은 마지막으로 셈한 횡단이 덮은 폭 — 좌·우 같고, 원지반 선 범위와 한 값이다.
+    // 반폭 = 적용해 둔 「횡단 반폭」 · 없으면 그린 원지반 선 범위 — 좌·우 같음.
     watched: () =>
       watching === null || !shown
         ? null
diff --git a/B05_Profile/B05_Profile_UI_Style_MassHaul.css b/B05_Profile/B05_Profile_UI_Style_MassHaul.css
index 59cc32b50..1d458de7c 100644
--- a/B05_Profile/B05_Profile_UI_Style_MassHaul.css
+++ b/B05_Profile/B05_Profile_UI_Style_MassHaul.css
@@ -88,8 +88,9 @@
   pointer-events: auto;
 }
 
+/* 접음 = 판 높이 0 · 손잡이만 판 위 경계에 매달림(배수유역 접힘 꼴 · 367-2). */
 .b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) {
-  height: auto;
+  height: 0;
 }
 
 .b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) > :not(.b05-profile__masshaul-head) {
@@ -97,10 +98,13 @@
 }
 
 .b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) > .b05-profile__masshaul-head {
-  position: relative;
-  top: 0;
-  left: 0;
-  padding: 2px var(--spacing-8);
+  top: auto;
+  bottom: 100%;
+}
+
+/* [창 분할]은 펼친 때만(367-2) — 새 창으로 뗀 [창 결합]은 그대로. */
+.b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) .b05-subpanel__popout {
+  display: none;
 }
 
 /* 종단 패널을 접으면 판도 함께 숨는다(배수유역도와 같음). */
@@ -129,14 +133,12 @@
   background: var(--color-surface);
 }
 
-/* 곡선 가로 스크롤러 — 종단 스크롤러와 scrollLeft를 동기화한다(JS). 세로는 잘라낸다.
-   스크롤바는 항상 표시(scroll) — auto면 생겼다 없어질 때 곡선 높이가 널뛰고,
-   clientHeight 기반 높이 계산도 함께 흔들린다. */
+/* 곡선 칸 — 늘 전체 맞춤이라 스크롤 없음(367-1). */
 .b05-profile__masshaul-scroll {
   position: relative;
   flex: 1 1 auto;
   min-height: 0;
-  overflow-x: scroll;
+  overflow-x: hidden;
   overflow-y: hidden;
 }
 
diff --git a/B05_Profile/B05_Profile_UI_Style_RouteEdit.css b/B05_Profile/B05_Profile_UI_Style_RouteEdit.css
index 1e6c5420b..2698017ad 100644
--- a/B05_Profile/B05_Profile_UI_Style_RouteEdit.css
+++ b/B05_Profile/B05_Profile_UI_Style_RouteEdit.css
@@ -15,9 +15,9 @@
   --b05-side-open: 460px;
 }
 
-/* 도구줄 — 3D 도구줄 규격 그대로 · 오른쪽 회전 단추 · 횡단 판을 비켜 줄바꿈. */
+/* 도구줄 — 3D 도구줄 규격 그대로 · 회전 단추도 이 줄(366-2) · 넘치면 줄바꿈. */
 .b05-routeedit__tools {
-  right: calc(var(--spacing-12) + 112px); /* 오른쪽 위 회전 단추 자리 */
+  right: var(--spacing-12);
   flex-wrap: wrap;
   pointer-events: none; /* 빈 자리는 지도 조작을 통과 */
 }
diff --git a/B05_Profile/B05_Profile_UI_Style_Table.css b/B05_Profile/B05_Profile_UI_Style_Table.css
index 1806537e8..3f1dedf96 100644
--- a/B05_Profile/B05_Profile_UI_Style_Table.css
+++ b/B05_Profile/B05_Profile_UI_Style_Table.css
@@ -352,8 +352,9 @@
   stroke-width: 1.5;
 }
 
+/* 지나온 선 · 미리 보기 · 점 = 녹색(367-4) — 범위 띠 · 경계는 보라 그대로. */
 .b05-profile-freemark__line {
-  stroke: var(--color-primary);
+  stroke: var(--color-success);
   stroke-width: 2;
   stroke-dasharray: 6 4;
 }
@@ -368,7 +369,7 @@
 
 .b05-profile-freemark__dot {
   fill: var(--color-surface);
-  stroke: var(--color-primary);
+  stroke: var(--color-success);
   stroke-width: 1.5;
 }
 
diff --git a/B05_Profile/logic/B05_Profile_ContourLock.ts b/B05_Profile/logic/B05_Profile_ContourLock.ts
index 85fffd545..62242854a 100644
--- a/B05_Profile/logic/B05_Profile_ContourLock.ts
+++ b/B05_Profile/logic/B05_Profile_ContourLock.ts
@@ -21,13 +21,15 @@ export function featureOfLevel(levels: ContourLevels, level: number | null): num
   return levels.findIndex((value) => value === level);
 }
 
-/** 커서 아래 가닥 높이 · 잠근 높이 → 단추 — 안 잠김 = 높이 있는 가닥 위에서 · 잠김 = 그 높이 위에서만. */
+/** 누른 가닥 높이 · 잠근 높이 · 고른 가닥인지 → 단추(366-1) — 안 잠김 = 높이 있는 고른 가닥을
+ *  누를 때만 · 잠김 = 잠근 높이의 아무 가닥을 누를 때(풀기). 지나가기만 하면 안 뜸. */
 export function lockButtonState(
-  hoverLevel: number | null,
+  hitLevel: number | null,
   lockedLevel: number | null,
+  selected: boolean,
 ): LockButtonState {
-  if (lockedLevel !== null) return { visible: hoverLevel === lockedLevel, pressed: true };
-  return { visible: hoverLevel !== null, pressed: false };
+  if (lockedLevel !== null) return { visible: hitLevel === lockedLevel, pressed: true };
+  return { visible: hitLevel !== null && selected, pressed: false };
 }
 
 /** 단추 누름 — 잠김이면 풂(null) · 아니면 그 가닥 높이로 잠금. */
diff --git a/B05_Profile/logic/B05_Profile_Drainage_Suggest.ts b/B05_Profile/logic/B05_Profile_Drainage_Suggest.ts
index 891d4e695..28497e164 100644
--- a/B05_Profile/logic/B05_Profile_Drainage_Suggest.ts
+++ b/B05_Profile/logic/B05_Profile_Drainage_Suggest.ts
@@ -1,11 +1,12 @@
 /* =============================================================================
  * B05_Profile/logic/B05_Profile_Drainage_Suggest.ts
- * 배수유역 제안(347-3) — 관경 · 시설 종류 · 관 자리 후보를 모으고 [적용] 때 관 초안에 한 번에 얹음.
+ * 배수유역 제안(347-3) — 관경 · 시설 종류 · 관 자리 후보를 모으고 [적용] 때 관경 · 시설만 관 초안에 얹음.
  * 순수 함수만(화면 = `B05_Profile_UI_Drainage_Suggest.ts`).
  *
  *   - 관경 = 유역 추천이 배관이고 추천 관경이 지금 관경과 다를 때(「Ø→Ø 배관 제안」).
  *   - 시설 = 유역 추천이 BOX암거 · 세월교이고 지금 관이 그 종류가 아닐 때.
- *   - 관 자리 = 서버 `suggest_pipe_positions`(간격 보충 규칙 · 기존 관에서 먼 곳).
+ *   - 관 자리 = 서버 `suggest_pipe_positions`(간격 보충 규칙 · 기존 관에서 먼 곳) — 보이기만 · 더하기는
+ *     [자동 제안] ②(369 · 서버가 새 관에 등록부 기본값).
  *   - 자동 바꿈 없음 — 모으기만 하고 바꾸는 것은 `applySuggestions`([적용])뿐.
  * ========================================================================== */
 
@@ -60,7 +61,7 @@ export function collectSuggestions(
   return found.sort((a, b) => a.chainageM - b.chainageM);
 }
 
-/** [적용] — 제안을 관 초안에 한 번에(관 더함 · 관경 · 시설 바꿈). 입력 목록은 안 고침. */
+/** [적용] — 제안을 관 초안에 한 번에(관경 · 시설 바꿈 · 관 자리는 안 더함 · 369). 입력 목록은 안 고침. */
 export function applySuggestions<P extends PipeLike>(
   pipes: ReadonlyArray<P>,
   suggestions: ReadonlyArray<Suggestion>,
@@ -69,15 +70,11 @@ export function applySuggestions<P extends PipeLike>(
     (pipe) => ({ ...pipe, options: pipe.options && { ...pipe.options } }) as P,
   );
   suggestions.forEach((item) => {
-    if (item.kind === "position") {
-      if (!next.some((pipe) => near(pipe.chainage_m, item.chainageM)))
-        next.push({ chainage_m: item.chainageM, source: "spacing" } as P);
-      return;
-    }
+    if (item.kind === "position") return;
     const pipe = next.find((candidate) => near(candidate.chainage_m, item.chainageM));
     if (!pipe) return;
     if (item.kind === "facility") pipe.facility = item.to;
     else pipe.options = { ...(pipe.options ?? {}), pipe_diameter_mm: item.to };
   });
-  return next.sort((a, b) => a.chainage_m - b.chainage_m);
+  return next;
 }
diff --git a/B05_Profile/logic/B05_Profile_Pipeline_Detail.ts b/B05_Profile/logic/B05_Profile_Pipeline_Detail.ts
index 53f7ec7cd..9ddf421bf 100644
--- a/B05_Profile/logic/B05_Profile_Pipeline_Detail.ts
+++ b/B05_Profile/logic/B05_Profile_Pipeline_Detail.ts
@@ -102,6 +102,80 @@ function atChainage(own: SectionSpecs, chainageM: number): SectionSpecs {
   return out as SectionSpecs;
 }
 
+/** 저장 상세 → 묶음 cross 출력(365-4 · 저장 노선 = 다시 셈 창구 한 벌이 고친 설계 그대로) — 측점이 상세와
+ *  다르면(갈아끼움 전) null. */
+export function detailCross(
+  detail: SectionDetailResponse,
+  stations: ReadonlyArray<PipelineStation>,
+): CrossOutput | null {
+  const sections = detail.cross_sections;
+  const same =
+    sections.length === stations.length &&
+    stations.every((station, i) => Math.abs(station.chainageM - sections[i].chainage_m) < 1e-3);
+  if (!same) return null;
+  const byKey: CrossOutput["byKey"] = {};
+  stations.forEach((station, i) => {
+    const { design, samples } = sections[i];
+    if (!design) return;
+    byKey[station.key] = {
+      key: station.key,
+      chainageM: station.chainageM,
+      cutAreaM2: design.cut_area_m2,
+      fillAreaM2: design.fill_area_m2,
+      detail: design,
+      ...(samples ? { samples } : {}),
+    } as CrossOutput["byKey"][string];
+  });
+  return { byKey };
+}
+
+/** 묶음 측점 하나 → 횡단(머리 · 지반 표본 · 설계) — 새 노선 상세 · B05 오른쪽 횡단 판(365-3)이 같은 값. */
+export function stationSection(
+  station: PipelineStation,
+  cross: CrossOutput | null,
+  own: SectionSpecs,
+  intervalM: number,
+): CrossSection {
+  const center = station.ground?.centerZ ?? null;
+  const head: SectionStation = {
+    station_id: stationIdOf(station.chainageM),
+    chainage_m: station.chainageM,
+    label: stationLabel(station.chainageM, intervalM),
+    kind: kindOf(station),
+    ...(own.structure ? { structure: own.structure } : {}),
+    center_z: center,
+    azimuth_deg: station.azimuthDeg,
+    plan_radius_m: station.planRadiusM,
+    curve_outer_side: station.curveOuterSide,
+    curve_widening_m: station.curveWideningM,
+    center_x: station.x,
+    center_y: station.y,
+    uphill_side: uphillSide(station),
+    frame: { left_xy: station.left },
+  };
+  const sample = (offset: number, z: number | null) => ({
+    offset_m: offset,
+    elevation_m: z,
+    valid: z !== null && Number.isFinite(z),
+  });
+  const samples = [
+    ...[...(station.ground?.right ?? [])].reverse().map((s) => sample(-s.offsetM, s.z)),
+    sample(0, center),
+    ...(station.ground?.left ?? []).map((s) => sample(s.offsetM, s.z)),
+  ];
+  const entry = cross?.byKey[station.key] as { detail?: unknown; samples?: unknown[] } | undefined;
+  const design = entry?.detail as CrossSection["design"] | undefined;
+  // 설계는 사본 — 구조물 면적 얹기(`applyStructureAreaRows`)가 cross 단계 기억을 안 고침(349-0j)
+  return {
+    ...head,
+    ...own,
+    // 넓힌 표본(서버 [저장]도 넓힌 표본을 상세에 남김 — 구조물 면적이 그 지반으로 닫힘 · 349-0n)
+    samples: (entry?.samples as CrossSection["samples"] | undefined) ?? samples,
+    ...(design ? { design: { ...design } } : {}),
+    preview: true,
+  };
+}
+
 /** 묶음 출력 → 상세. 저장 상세의 종단 머리(이름 · 계획선 묶음)는 그대로 · 측점 · 지반 · 횡단은 새 노선. */
 export function draftSectionDetail(
   saved: SectionDetailResponse,
@@ -111,48 +185,14 @@ export function draftSectionDetail(
   specs: ReadonlyMap<string, SectionSpecs>,
   intervalM: number,
 ): SectionDetailResponse {
-  const sections: CrossSection[] = ground.stations.map((station) => {
-    const own = atChainage(specs.get(station.key) ?? {}, station.chainageM);
-    const center = station.ground?.centerZ ?? null;
-    const head: SectionStation = {
-      station_id: stationIdOf(station.chainageM),
-      chainage_m: station.chainageM,
-      label: stationLabel(station.chainageM, intervalM),
-      kind: kindOf(station),
-      ...(own.structure ? { structure: own.structure } : {}),
-      center_z: center,
-      azimuth_deg: station.azimuthDeg,
-      plan_radius_m: station.planRadiusM,
-      curve_outer_side: station.curveOuterSide,
-      curve_widening_m: station.curveWideningM,
-      center_x: station.x,
-      center_y: station.y,
-      uphill_side: uphillSide(station),
-      frame: { left_xy: station.left },
-    };
-    const sample = (offset: number, z: number | null) => ({
-      offset_m: offset,
-      elevation_m: z,
-      valid: z !== null && Number.isFinite(z),
-    });
-    const samples = [
-      ...[...(station.ground?.right ?? [])].reverse().map((s) => sample(-s.offsetM, s.z)),
-      sample(0, center),
-      ...(station.ground?.left ?? []).map((s) => sample(s.offsetM, s.z)),
-    ];
-    const entry = cross?.byKey[station.key] as
-      { detail?: unknown; samples?: unknown[] } | undefined;
-    const design = entry?.detail as CrossSection["design"] | undefined;
-    // 설계는 사본 — 구조물 면적 얹기(`applyStructureAreaRows`)가 cross 단계 기억을 안 고침(349-0j)
-    return {
-      ...head,
-      ...own,
-      // 넓힌 표본(서버 [저장]도 넓힌 표본을 상세에 남김 — 구조물 면적이 그 지반으로 닫힘 · 349-0n)
-      samples: (entry?.samples as CrossSection["samples"] | undefined) ?? samples,
-      ...(design ? { design: { ...design } } : {}),
-      preview: true,
-    };
-  });
+  const sections: CrossSection[] = ground.stations.map((station) =>
+    stationSection(
+      station,
+      cross,
+      atChainage(specs.get(station.key) ?? {}, station.chainageM),
+      intervalM,
+    ),
+  );
   const { chainageM, z } = ground.longitudinal;
   return {
     longitudinal: {
diff --git a/B05_Profile/logic/B05_Profile_RouteEdit_StationFit.ts b/B05_Profile/logic/B05_Profile_RouteEdit_StationFit.ts
new file mode 100644
index 000000000..c2e1da9ea
--- /dev/null
+++ b/B05_Profile/logic/B05_Profile_RouteEdit_StationFit.ts
@@ -0,0 +1,171 @@
+/* =============================================================================
+ * B05_Profile/logic/B05_Profile_RouteEdit_StationFit.ts
+ * 측점 스냅 켬 = 곡선 가운데(MC)를 일반측점에(366-3 · 요구 240-11) — 손 편집 평면.
+ *
+ * 추천 노선 맞춤(`B05_Profile_Engine_RouteInitial_Station.py` `_try` · `_solve`)을 줄인 꼴:
+ *   · `from`(`fitStart` = 고친 자리 앞)부터 끝까지 차례로 — 고정 아닌 교각점(IP)을 들어오는 접선 따라 ±간격/2 안에서
+ *     밀어 MC(BC · EC 누가거리 가운데)를 가까운 일반측점(앞 MC 측점 + 간격 이상 · No.1 이상)에 둠.
+ *   · 곡선 하한을 새로 깨거나(`shortfallCrossed`) 앞 곡선 MC 를 흔들면 버림 → 그 곡선은 그대로.
+ *   · 반지름 · 켬끔은 안 바꿈 — IP 자리만. 합치기 · 곡선 끄기 · 되돌아가기 없음.
+ * 파이썬 짝 아님 — [저장] 때 서버가 저장된 IP 로 선을 다시 짬(`buildEditedPolyline` 짝)이라 MC 그대로.
+ * 순수 계산 — 화면 · fetch · sessionStorage 없음. 부르는 쪽은 `B05_Profile_UI_RouteEdit`.
+ * ========================================================================== */
+
+import {
+  buildEditedPolyline,
+  type EditedCurve,
+  type EditedPolyline,
+  type Vertex,
+} from "./B05_Profile_UI_RouteEdit_Curve";
+import {
+  applyArcLocks,
+  applyCurveLimits,
+  curveShortfalls,
+  shortfallCrossed,
+  type NodeColumns,
+} from "./B05_Profile_UI_RouteEdit_Edits";
+import { curveSpans } from "./B05_Profile_UI_RouteEdit_Frame";
+
+/** MC 가 측점에서 이만큼 안이면 「위」(m) — 파이썬 `MC_TOL_M` 과 같은 값. */
+export const MC_TOL_M = 0.05;
+
+/** 선을 짜는 값 — 편집 창이 쥔 하한 · 간격. */
+export interface FitLimits {
+  minRadiusM: number;
+  limitRadiusM: number;
+  limitArcM: number;
+  intervalM: number;
+}
+
+type Columns = Pick<NodeColumns, "curveOn" | "curveRadius" | "curveLock" | "curveArc" | "apexLock">;
+
+/** 편집 창 `markEdited` 와 같은 길(길이 고정 R · 하한 끌어올림 → 선) — 값은 사본에. */
+function build(cols: Columns, planned: Vertex[], limits: FitLimits): EditedPolyline {
+  const radius = [...cols.curveRadius];
+  applyArcLocks(planned, cols.curveLock, cols.curveArc, radius);
+  applyCurveLimits(planned, cols.curveOn, radius, limits.limitRadiusM, limits.limitArcM);
+  return buildEditedPolyline(planned, cols.curveOn, radius, limits.minRadiusM);
+}
+
+/** 꺾임점 `k` 곡선의 MC 누가거리 — 곡선이 없으면 null. */
+function mcOf(built: EditedPolyline, k: number): number | null {
+  const curve = built.curves.find((item) => item.node_first === k);
+  const span = curve ? curveSpans(built.vertices, [curve])[0] : undefined;
+  return span ? (span[0] + span[1]) / 2 : null;
+}
+
+/** 측점 밖 곡선 수 — MC 가 일반측점(No.1 이상) 위가 아닌 곡선 · 한 측점에 둘이면 하나만 위. */
+export function offStationCount(
+  line: ReadonlyArray<Vertex>,
+  curves: ReadonlyArray<EditedCurve>,
+  intervalM: number,
+): number {
+  if (!(intervalM > 0)) return 0;
+  const spans = curveSpans(line, curves);
+  const hits = new Set<number>();
+  for (const [start, end] of spans) {
+    const mc = (start + end) / 2;
+    const n = Math.round(mc / intervalM);
+    if (n >= 1 && Math.abs(mc - n * intervalM) <= MC_TOL_M) hits.add(n);
+  }
+  return spans.length - hits.size;
+}
+
+/** 맞춤을 시작할 꺾임점 — 지난 걸음과 처음 다른 자리 바로 앞(그 곡선 끝 접선도 바뀜) · 같으면 1. */
+export function fitStart(
+  before: (Columns & Pick<NodeColumns, "planned">) | null | undefined,
+  now: Columns & Pick<NodeColumns, "planned">,
+): number {
+  if (!before) return 1;
+  const keys = ["curveOn", "curveRadius", "curveLock", "curveArc", "apexLock"] as const;
+  const at = now.planned.findIndex(
+    (vertex, i) =>
+      vertex[0] !== before.planned[i]?.[0] ||
+      vertex[1] !== before.planned[i]?.[1] ||
+      keys.some((key) => now[key][i] !== before[key][i]),
+  );
+  const changed =
+    at < 0 && now.planned.length !== before.planned.length ? now.planned.length - 1 : at;
+  return Math.max(1, changed - 1);
+}
+
+const round4 = (value: number): number => Math.round(value * 1e4) / 1e4;
+
+/** 곡선 하나 맞춤 — IP `k` 를 들어오는 접선 따라 d 밀어 MC = target(할선법 · 기울기 ≈ 1). */
+function solve(
+  cols: Columns,
+  limits: FitLimits,
+  planned: Vertex[],
+  k: number,
+  target: number,
+  mc: number,
+): { planned: Vertex[]; built: EditedPolyline; mc: number } | null {
+  const base = planned[k];
+  const before = planned[k - 1];
+  const length = Math.hypot(base[0] - before[0], base[1] - before[1]);
+  if (!(length > 1e-9)) return null;
+  const ux = (base[0] - before[0]) / length;
+  const uy = (base[1] - before[1]) / length;
+  const reach = limits.intervalM / 2;
+  const clamp = (d: number): number => Math.max(-reach, Math.min(reach, d));
+  const at = (d: number) => {
+    const next = planned.slice();
+    next[k] = [round4(base[0] + ux * d), round4(base[1] + uy * d)];
+    const built = build(cols, next, limits);
+    const found = mcOf(built, k);
+    return found === null ? null : { planned: next, built, mc: found };
+  };
+  let d0 = 0;
+  let f0 = mc - target;
+  let d1 = clamp(-f0);
+  for (let step = 0; step < 10; step += 1) {
+    const tried = at(d1);
+    if (!tried || d1 === d0) return null;
+    const f1 = tried.mc - target;
+    if (Math.abs(f1) <= MC_TOL_M / 5) return tried;
+    const slope = (f1 - f0) / (d1 - d0);
+    if (Math.abs(slope) < 0.2) return null;
+    d0 = d1;
+    f0 = f1;
+    d1 = clamp(d1 - f1 / slope);
+  }
+  return null;
+}
+
+/** `from` 꺾임점부터 끝까지 곡선 MC 를 일반측점에 — 새 IP 목록(못 놓은 곡선 IP 는 그대로). */
+export function fitCurveStations(
+  cols: Columns & Pick<NodeColumns, "planned">,
+  limits: FitLimits,
+  from: number,
+): Vertex[] {
+  let planned = cols.planned.map((vertex): Vertex => [vertex[0], vertex[1]]);
+  const interval = limits.intervalM;
+  if (!(interval > 0) || planned.length < 3) return planned;
+  let built = build(cols, planned, limits);
+  const floor = curveShortfalls(built.nodes, limits.limitRadiusM, limits.limitArcM);
+  let lastStation = 0; // 앞 곡선이 놓인 측점 번호(없으면 0 = 시점)
+  let previous = -1; // 앞 곡선 꺾임점
+  for (let k = 1; k < planned.length - 1; k += 1) {
+    const mc = mcOf(built, k);
+    if (mc === null) continue;
+    const near = Math.max(lastStation + 1, Math.round(mc / interval));
+    const onStation = Math.abs(mc - near * interval) <= MC_TOL_M;
+    const fitted =
+      onStation || k < from || cols.apexLock[k] || Math.abs(near * interval - mc) > interval / 2
+        ? null
+        : solve(cols, limits, planned, k, near * interval, mc);
+    const keep =
+      fitted &&
+      !shortfallCrossed(
+        floor,
+        curveShortfalls(fitted.built.nodes, limits.limitRadiusM, limits.limitArcM),
+      ) &&
+      (previous < 0 ||
+        Math.abs((mcOf(fitted.built, previous) ?? Infinity) - (mcOf(built, previous) ?? 0)) <=
+          MC_TOL_M / 5);
+    if (fitted && keep) ({ planned, built } = fitted);
+    if (onStation || keep) lastStation = near;
+    previous = k;
+  }
+  return planned;
+}
diff --git a/B05_Profile/logic/B05_Profile_UI_RouteEdit_Edits.ts b/B05_Profile/logic/B05_Profile_UI_RouteEdit_Edits.ts
index 1106aa610..30fdf4ddd 100644
--- a/B05_Profile/logic/B05_Profile_UI_RouteEdit_Edits.ts
+++ b/B05_Profile/logic/B05_Profile_UI_RouteEdit_Edits.ts
@@ -168,6 +168,8 @@ export interface CurveSummaryInput {
   minRadiusM: number;
   /** 아직 한 번도 안 그렸나(막 열었을 때). */
   fresh: boolean;
+  /** 측점 스냅 켬 때 MC 가 일반측점 밖인 곡선 수(366-3) — 끔이면 0. */
+  offStation?: number;
 }
 
 /** 상태줄 꼬리 — 곡선 수·기준 미달·사용자가 손댄 자리를 한 줄로. */
@@ -192,6 +194,7 @@ export function curveSummary(input: CurveSummaryInput): string {
   return (
     `곡선 ${input.curveCount}곳(하한 R ${input.minRadiusM}m)` +
     `${input.violationCount ? ` · 기준 미달 ${input.violationCount}곳` : ""}` +
+    `${input.offStation ? ` · 측점 밖 곡선 ${input.offStation}개` : ""}` +
     `${edits ? ` · ${edits}` : ""}`
   );
 }
diff --git a/B06_Section/B06_Section_Cross_Refresh.ts b/B06_Section/B06_Section_Cross_Refresh.ts
index d71763f7c..2f72e8c68 100644
--- a/B06_Section/B06_Section_Cross_Refresh.ts
+++ b/B06_Section/B06_Section_Cross_Refresh.ts
@@ -435,7 +435,7 @@ function refreshLocally(input: CrossRefreshInput): number[] | null {
       paved: pavedBySpecs(section),
       // 물넘이 자리 = 측구 없음 · 지대 낮은 쪽 한 경사(286-2 · 287-4 · 서버 `tilt_ranges` 짝 = 얹힌 제원)
       tilted: Boolean(section.ford_pavement || section.underdrain),
-      tiltPct: section.ford_pavement?.slope_pct ?? section.underdrain?.slope_pct ?? null,
+      tiltPct: section.ford_pavement?.slope_pct ?? null, // 맹암거 = 표준 경사(371-3)
       standard,
       berm: bermAt(section.chainage_m, design),
       rockBoundaryOffsetM,
diff --git a/B06_Section/B06_Section_Engine_Design_Geometry.py b/B06_Section/B06_Section_Engine_Design_Geometry.py
index e19dffc10..abd91a5f2 100644
--- a/B06_Section/B06_Section_Engine_Design_Geometry.py
+++ b/B06_Section/B06_Section_Engine_Design_Geometry.py
@@ -103,6 +103,16 @@ class _SectionGeometry:
             low_left = ground_at(self.left_extent) < ground_at(-self.right_extent)
             self.slope_per_offset = -slope if low_left else slope
 
+        # 설계선 쉬프트 = 쪽마다 사면 이동(≥ 0 · 139-6 · 151-2) — 노견(폭 고정) · 측구 · 사면이
+        # 같이 바깥으로 · 늘어난 폭은 차도 · 단면유형 · 측구 판정은 **옮긴 뒤** 노견에서(아래 ·
+        # 370-1 — 마루를 넘으면 그 쪽 사면 기울기로 원지반까지). ⚠ TS 짝 `SectionGeometry`.
+        self.shoulder_extend_left = max(shoulder_extend_left_m, 0.0)
+        self.shoulder_extend_right = max(shoulder_extend_right_m, 0.0)
+        self.half_road_left += self.shoulder_extend_left
+        self.half_road_right += self.shoulder_extend_right
+        self.left_extent += self.shoulder_extend_left
+        self.right_extent += self.shoulder_extend_right
+
         # 단면 유형 자동 판정(D-2): 각 측 절/성토 역할을 노면 끝 지반이 설계면보다
         # 높은지(절토)/낮은지(성토)로 결정한다. 좌절/우절/양절/양성이 모두 지형에서
         # 자연 도출된다. 사용자 입력 section_mode는 측구 방향(ditch_side) 기본값에만 쓰고
@@ -156,16 +166,6 @@ class _SectionGeometry:
         if tilted:
             self.has_ditch = False
 
-        # 설계선 쉬프트 = 쪽마다 사면 이동(≥ 0 · 139-6 · 151-2) — 단면유형 · 측구 판정은 **옮기기 전**
-        # 노견에서(위) · 노견(폭 고정) · 측구 · 사면이 같이 바깥으로 · 늘어난 폭은 차도.
-        # ⚠ TS 짝 `SectionGeometry`.
-        self.shoulder_extend_left = max(shoulder_extend_left_m, 0.0)
-        self.shoulder_extend_right = max(shoulder_extend_right_m, 0.0)
-        self.half_road_left += self.shoulder_extend_left
-        self.half_road_right += self.shoulder_extend_right
-        self.left_extent += self.shoulder_extend_left
-        self.right_extent += self.shoulder_extend_right
-
         # 측구 꼭짓점(측구측 노면 끝 기준, 바깥 방향 부호 적용).
         self.ditch_points: list[tuple[float, float]] = []
         edge_offset = self.left_extent if ditch_side == "left" else -self.right_extent
diff --git a/B06_Section/B06_Section_Engine_Tilt.py b/B06_Section/B06_Section_Engine_Tilt.py
index e67df46af..d0bd3b129 100644
--- a/B06_Section/B06_Section_Engine_Tilt.py
+++ b/B06_Section/B06_Section_Engine_Tilt.py
@@ -1,7 +1,7 @@
 """구조물 자리 기울기 — 물넘이포장 · 맹암거 측점의 노면(287-4 · 288-1).
 
 그 자리 횡단 설계 = 측구 없음 · 노면 = 한 경사로 지대 낮은 쪽(`compute_cross_design(tilted=…,
-tilt_pct=…)`). 경사 = 물넘이 경사각도(%) · 맹암거 암거 경사(%) · 비면 표준 횡단경사.
+tilt_pct=…)`). 경사 = 물넘이 경사각도(%) · 맹암거 = 표준 횡단경사(암거 경사는 형상 하단 · 371-3).
   · 물넘이포장 = 관 지점 정본(pipe_points) 범위(기준 ± 월류 폭/2).
   · 맹암거 = 구조물 정본(structures.json) A군 점형 · 기준 측점 한 곳 — 횡단 dict 에
     `underdrain`(높이 · 경사)을 얹어 횡단도가 돌 무늬 형상을 그림(TS 짝
@@ -78,7 +78,8 @@ def tilt_ranges(project_root: Path | None) -> list[TiltRange]:
             half = float(spec.get("span_m") or 0.0) / 2.0
             out.append((at - half, at + half, spec.get("slope_pct")))
     for drain in load_underdrains(project_root):
-        out.append((drain["chainage_m"], drain["chainage_m"], drain["slope_pct"]))
+        # 노면 = 표준 경사 · 암거 경사는 맹암거 하단 경계만(371-3 · TS `facilityRanges` 짝)
+        out.append((drain["chainage_m"], drain["chainage_m"], None))
     return out
 
 
diff --git a/B06_Section/B06_Section_Section_Store.ts b/B06_Section/B06_Section_Section_Store.ts
index 8b95f0752..a5ac2ca76 100644
--- a/B06_Section/B06_Section_Section_Store.ts
+++ b/B06_Section/B06_Section_Section_Store.ts
@@ -19,6 +19,7 @@
 
 import { clearState, readState, writeState } from "../A00_Common/b_page_state";
 import { PIPE_MATCH_M } from "../A00_Common/design/design_selection";
+import { useDesignStore } from "../A00_Common/design/design_store";
 import { setGeneralStations, setPlusStations } from "../common_util/common_util_structure_station";
 import { loadSavedPlusStations, plusStationsOf } from "../B05_Profile/B05_Profile_Api_PlusStations";
 import {
@@ -160,7 +161,9 @@ export async function swapSectionStations(
   if (swap.moved) carryStationKeys(projectId, routeId, nextKeys);
   else useStationKeyList(projectId, routeId, nextKeys);
   cache.set(key, swap.detail);
-  writeState("section-detail", swap.detail, projectId, routeId);
+  // 노선 초안 동안 = 메모리만(365-1) — 세션 상세는 저장 노선 그대로(새로고침 · B06 바로 열기 = 묶음이 초안 다시 셈)
+  if (!useDesignStore(projectId, null).get("routeDraft"))
+    writeState("section-detail", swap.detail, projectId, routeId);
   await withDraftShapes(swap.detail, projectId); // 새 측점에도 구조물 그림 자료(323-4)
   withStructureAreas(swap.detail);
   if (cache.get(key) !== swap.detail) return null; // 그 사이 다른 갈아끼움 · 새로 받음
diff --git a/B06_Section/B06_Section_UI_Cross_Card_Chrome.ts b/B06_Section/B06_Section_UI_Cross_Card_Chrome.ts
index 4cdc67dd1..777744dba 100644
--- a/B06_Section/B06_Section_UI_Cross_Card_Chrome.ts
+++ b/B06_Section/B06_Section_UI_Cross_Card_Chrome.ts
@@ -158,17 +158,23 @@ export function appendCardHeader(
   card.append(header);
 }
 
-/** 하단 정보행 — 중심고와 (암 지반일 때) 암 경계선·암 절토 경사 제어. */
+/** 하단 정보행 — 왼쪽 = 선 공용 칸(370-3 · 안 고르면 암 경계선) · 오른쪽 = (암 지반일 때) 암 절토 경사. */
 export function appendCardFooter(
   card: HTMLElement,
   section: CrossSection,
   rockBoundary?: RockBoundaryControl,
   cutSlope?: CutSlopeControl,
+  /** 설계선 고름 공용 칸(370-3 · `_Cross_Line_Cell`) — 있으면 왼쪽 칸(안 고르면 암 · 고르면 그 선). */
+  lineCell?: HTMLElement,
 ): void {
   // 중심고는 그래프 Y축 라벨 상자로 옮김(318-2 · `_Cross_Axes`) — 하단 띠는 암 제어만 · 비어도 띠 높이 그대로
   const footer = document.createElement("footer");
-  // 암 경계선 제어는 하단 정보 행 왼쪽(318-2) — 암 지반만.
-  if (rockBoundary && section.design?.geometry_preset === "rock") {
+  if (lineCell) {
+    lineCell.classList.add("b06-cross-card__rockb");
+    footer.append(lineCell);
+  }
+  // 암 경계선 제어는 하단 정보 행 왼쪽(318-2) — 암 지반만 · 설계선 고름이 없는 카드.
+  else if (rockBoundary && section.design?.geometry_preset === "rock") {
     const rockControl = buildRockBoundaryControl(section, rockBoundary);
     rockControl.classList.add("b06-cross-card__rockb");
     footer.append(rockControl);
diff --git a/B06_Section/B06_Section_UI_Cross_Center.ts b/B06_Section/B06_Section_UI_Cross_Center.ts
index e97f7a88c..1eddda6e2 100644
--- a/B06_Section/B06_Section_UI_Cross_Center.ts
+++ b/B06_Section/B06_Section_UI_Cross_Center.ts
@@ -5,6 +5,7 @@
  *   · 판정 원 = 중심 십자 자리 · 노면 판정보다 위(`stackPickTargets`) · 다른 고름과 같은 칸(하나만)
  *   · 고르면 ▲▼ = 종단 계획고(지금 길 · 종단도 듣개) · ◀▶ · 가로 끌기 = 그 측점 노선을 좌우로
  *   · 끄는 동안 · 키를 잇는 동안은 십자만 옮겨 보이고 · 놓을 때(키는 멈춘 뒤) 한 번 보냄
+ *   · 한 축 끌기(`bindAxisDrag`)는 암 경계선 세로 끌기(370-3)도 씀
  *   · 좌우 = 노선 편집기가 등록한 host(`setRouteShiftHost` · B05 `_RouteEdit_Shift`) — B06 을 바로 열어
  *     편집기가 없으면 종단 보기를 숨긴 채 세움(`setRouteShiftOpener` · 페이지가 닮 · 알림도 페이지 것)
  * ========================================================================== */
@@ -107,26 +108,14 @@ export function bindCenterShift(input: {
     if (!deltaM) return preview(0);
     void shiftRouteAt(chainageM, deltaM).then((moved) => moved || preview(0));
   };
-  hit.addEventListener("pointerdown", (event) => {
-    const ctm = layer.getScreenCTM();
-    if (event.button !== 0 || !active() || !ctm) return;
-    event.preventDefault();
-    event.stopPropagation(); // 카드 팬으로 안 번짐
-    const startX = event.clientX;
-    let deltaM = 0;
-    const move = (next: PointerEvent): void => {
-      deltaM = snapStep((next.clientX - startX) / (ctm.a * kx));
-      preview(deltaM);
-    };
-    const up = (): void => {
-      window.removeEventListener("pointermove", move);
-      window.removeEventListener("pointerup", up);
-      window.removeEventListener("pointercancel", up);
-      send(deltaM);
-    };
-    window.addEventListener("pointermove", move);
-    window.addEventListener("pointerup", up);
-    window.addEventListener("pointercancel", up);
+  bindAxisDrag({
+    hit,
+    layer,
+    axis: "x",
+    pxPerM: kx,
+    active,
+    preview,
+    send,
   });
   let pending = 0;
   let timer = 0;
@@ -144,6 +133,50 @@ export function bindCenterShift(input: {
   };
 }
 
+/**
+ * 고른 판정을 한 축으로 끌기(356-3 중심점 가로 · 370-3 암 경계선 세로) — 고른 뒤에만(안 고른 것을 끌면 카드
+ * 팬 그대로) · 걸음 0.1 m · 끄는 동안 `preview` · 놓을 때 움직였으면 한 번 `send`(안 움직이면 `preview(0)`) ·
+ * 놓은 자리 click 은 한 번 막음(같은 것 다시 누름 = 풂으로 안 번짐). `pxPerM` = 그 축 화면 px / m(layer 좌표).
+ */
+export function bindAxisDrag(input: {
+  hit: SVGElement;
+  layer: SVGGraphicsElement;
+  axis: "x" | "y";
+  pxPerM: number;
+  active: () => boolean;
+  preview: (deltaM: number) => void;
+  send: (deltaM: number) => void;
+}): void {
+  const { hit, layer, axis, pxPerM, active } = input;
+  const at = (event: PointerEvent): number => (axis === "x" ? event.clientX : event.clientY);
+  hit.addEventListener("pointerdown", (event) => {
+    const ctm = layer.getScreenCTM();
+    if (event.button !== 0 || !active() || !ctm) return;
+    event.preventDefault();
+    event.stopPropagation(); // 카드 팬으로 안 번짐
+    const start = at(event);
+    const scale = (axis === "x" ? ctm.a : ctm.d) * pxPerM;
+    let deltaM = 0;
+    const move = (next: PointerEvent): void => {
+      deltaM = snapStep((at(next) - start) / scale);
+      input.preview(deltaM);
+    };
+    const up = (): void => {
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", up);
+      window.removeEventListener("pointercancel", up);
+      if (!deltaM) return input.preview(0);
+      const swallow = (click: Event): void => click.stopPropagation();
+      window.addEventListener("click", swallow, { capture: true, once: true });
+      setTimeout(() => window.removeEventListener("click", swallow, { capture: true }), 0);
+      input.send(deltaM);
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", up);
+    window.addEventListener("pointercancel", up);
+  });
+}
+
 /** 조정창 읽기 글 — 미리 볼 이동(m · 0 = 안내). */
 export function centerPreviewText(deltaM: number): string {
   if (!deltaM) return "▲▼ = 종단 계획고 · ◀▶ · 끌기 = 이 측점 노선 좌우";
diff --git a/B06_Section/B06_Section_UI_Cross_Culvert.ts b/B06_Section/B06_Section_UI_Cross_Culvert.ts
index 9d53cf141..ee2e95d3c 100644
--- a/B06_Section/B06_Section_UI_Cross_Culvert.ts
+++ b/B06_Section/B06_Section_UI_Cross_Culvert.ts
@@ -313,12 +313,12 @@ export function appendCulvertOverlay(
 
   const kindLabel = culvert.pipe_kind ? `${culvert.pipe_kind} ` : "";
   const wallThickness = pipeWallThicknessM(culvert.pipe_kind, diameter);
-  const pipeInfo = `관매설 ${kindLabel}Φ${Math.round(diameter * 1000)}m/m, L=${pipeLengthText(pipe.lengthM)}`;
+  // 관 기울기 = L 뒤 소수 한 자리 · 역경사는 0.0(371-2)
+  const pipeInfo = `관매설 ${kindLabel}Φ${Math.round(diameter * 1000)}m/m, L=${pipeLengthText(pipe.lengthM)}, S=${Math.max(pipe.slopePct, 0).toFixed(1)}%`;
   // 관 정보 글 = 노폭 · 노견 라벨 위 줄(225-1 · B06 카드만 — 그 라벨 없는 덧그림엔 안 그림)
   if (!hidePipe) appendPipeInfoText(layer, pipeInfo, null);
   const tip =
     pipeInfo +
-    ` · 매설 경사 ${pipe.slopePct.toFixed(1)}%(수평 가능)` +
     ` · 관 두께 ${(wallThickness * 1000).toFixed(1)}㎜(외경선 기준)` +
     ` · 최소 토피 ${culvert.min_cover_m.toFixed(1)}m(별표2 복토 교차 참조)`;
   // 외경(관 두께 바깥) → 내경 순으로 2겹. 도면처럼 관벽 두께가 보이게 한다(사용자 ③).
diff --git a/B06_Section/B06_Section_UI_Cross_Culvert_Extra.ts b/B06_Section/B06_Section_UI_Cross_Culvert_Extra.ts
index 406e38e33..facb70214 100644
--- a/B06_Section/B06_Section_UI_Cross_Culvert_Extra.ts
+++ b/B06_Section/B06_Section_UI_Cross_Culvert_Extra.ts
@@ -6,8 +6,8 @@
  * (2026-08-22 사용자 확정 규칙):
  *   · 기슭막이 사이 성토사면은 **정확히 1:1.2** · 자동 자리 = 사면 1.0 m 뒤 벽 상단(원지반 무관 · 91-3).
  *   · 아랫단 벽 상단은 윗단 벽 **하단(수평 기초선)을 뚫고 올라갈 수 없다**.
- *   · 다음 단 성토선 시작점 = 윗단 벽 **하단 수평선 +0.5m와 전면 경사선(1:n · 표준경사)의
- *     교차점**(배관 기슭막이의 관 하단 꼭짓점과 같은 자리 — 배관만 없다).
+ *   · 다음 단 성토선 시작점 = 윗단 벽 **발끝**(하단 수평선 ∩ 전면 경사선 · 원지반 무관 · 371-1).
+ *     마지막 벽 → 끝 구간만 하단 수평선 +0.5m ∩ 전면(관 하단 꼭짓점과 같은 자리) · 뜬 벽은 발끝.
  * ========================================================================== */
 
 import {
@@ -19,6 +19,7 @@ import {
   materialFromForm,
   revetFormOf,
   REVET_EMBED_DEPTH_M,
+  REVET_FILL_TOP_M,
   REVET_LEAN_RATIO,
   REVET_THICKNESS_M,
   WALL_MIN_PURE_HEIGHT_M,
@@ -208,11 +209,25 @@ export function inletGroundConnector(
   return null;
 }
 
-/** 벽 중심(하단 중점)에서 이음선 상단점까지의 수평거리 — 높이·기울기에 따라 커진다. */
+/** 벽 중심(하단 중점)에서 성토 위 이음까지의 수평거리 — 높이·기울기에 따라 커진다(371-1). */
 function jointRunOf(height: number, lean: number): number {
-  return 0.25 * REVET_THICKNESS_M + (lean / 2) * height;
+  return 0.75 * REVET_THICKNESS_M - REVET_FILL_TOP_M + (lean / 2) * height;
 }
 
+/** 벽 아래 성토 시작점(371-1) — 아래 단이 있으면(`tiered`) 늘 발끝(전면 ∩ 하단 수평선 ·
+ *  원지반 무관) · 끝 구간은 발끝이 원지반 위에 뜬 벽만 발끝 · 땅에 선 · 묻힌 벽은 `grounded`
+ *  (기준선 ∩ 전면 · 묻힘 판정 그대로). */
+export const floatFillStart = (
+  wall: WallLayout,
+  grounded: OffsetPoint,
+  groundAt: (offset: number) => number,
+  tiered: boolean,
+): OffsetPoint =>
+  tiered ||
+  (wall.floatGapM > 1e-6 && groundAt(wall.bottomFront.offset) < wall.bottomFront.elevation - 0.01)
+    ? wall.bottomFront
+    : grounded;
+
 /** 끝 성토부선 — src에서 1:1.2로 내려가며 원지반을 만나면 끝(지반이 높으면 지반 따름). */
 function trailingFill(
   src: OffsetPoint,
@@ -359,22 +374,28 @@ export function buildOutletExtras(input: OutletExtrasInput): OutletExtrasResult
           ? { offset: src.offset + outward * shelfRun, elevation: src.elevation }
           : null;
       const slopeFrom = shelf ?? src;
-      const run = Math.abs(wall.topJoint.offset - slopeFrom.offset);
-      const rise = slopeFrom.elevation - wall.topJoint.elevation;
+      const run = Math.abs(wall.fillTop.offset - slopeFrom.offset);
+      const rise = slopeFrom.elevation - wall.fillTop.elevation;
       segments.push({
-        points: shelf ? [src, shelf, wall.topJoint] : [src, wall.topJoint],
+        points: shelf ? [src, shelf, wall.fillTop] : [src, wall.fillTop],
         lengthM: Math.hypot(run, rise),
         ratio: rise > 1e-9 ? run / rise : FILL_SLOPE_RATIO_MIN,
         overLimit: Math.hypot(run, rise) >= FILL_SLOPE_MAX_LENGTH_M - 1e-6,
       });
-      // 다음 단 시작점 = 이 벽 바닥 +0.5m(= 기준선) 수평선과 전면
-      // 경사선(1:0.3)의 교차점(2026-08-22 사용자 — 관 끝점 규칙과 동일 기준).
+      // 다음 단 시작점 = 벽 발끝(전면 경사 ∩ 하단 수평선 · 원지반 무관 · 371-1). 마지막 벽 →
+      // 끝 구간은 바닥 +0.5m(= 기준선) ∩ 전면(2026-08-22 사용자) · 뜬 벽만 발끝.
       const startElevation = wall.bottomBack.elevation + REVET_EMBED_DEPTH_M;
-      src = {
-        offset:
-          wall.points[2].offset + outward * wall.lean * (wall.topJoint.elevation - startElevation),
-        elevation: startElevation,
-      };
+      src = floatFillStart(
+        wall,
+        {
+          offset:
+            wall.points[2].offset +
+            outward * wall.lean * (wall.topJoint.elevation - startElevation),
+          elevation: startElevation,
+        },
+        groundAt,
+        i < input.adjusts.length - 1,
+      );
       prevBottom = wall.bottomBack.elevation;
     }
 
diff --git a/B06_Section/B06_Section_UI_Cross_Culvert_Geom.ts b/B06_Section/B06_Section_UI_Cross_Culvert_Geom.ts
index dee524084..cab7ffa11 100644
--- a/B06_Section/B06_Section_UI_Cross_Culvert_Geom.ts
+++ b/B06_Section/B06_Section_UI_Cross_Culvert_Geom.ts
@@ -57,7 +57,7 @@ import {
   BASIN_INNER_WIDTH_M,
   inletChoiceAvailability,
 } from "./logic/B06_Section_UI_Cross_Culvert_Basin";
-import { inletGroundConnector } from "./B06_Section_UI_Cross_Culvert_Extra";
+import { floatFillStart, inletGroundConnector } from "./B06_Section_UI_Cross_Culvert_Extra";
 import { withBackCut } from "./logic/B06_Section_UI_Cross_Structure_Cut";
 import {
   buildCulvertTiers,
@@ -377,17 +377,17 @@ export function computeCulvertLayout(
       lean,
       roadElevation: side.elevation_m,
     });
-    const topJoint = wall.topJoint.offset;
-    const topElevation = wall.topJoint.elevation;
+    const fillTop = wall.fillTop.offset;
+    const topElevation = wall.fillTop.elevation;
     const topFront = wall.points[2].offset;
     const bottomFront = wall.bottomFront;
     walls.push(wall);
-    // 성토 사면선은 **이음선 상단점**에서 끊고, 끝단 표고도 그 점에 맞춘다(사용자 ②).
+    // 성토 사면선은 **성토 위 이음**에서 끊고, 끝단 표고도 그 점에 맞춘다(사용자 ② · 371-1).
     if (outward > 0) {
-      trimMax = topJoint;
+      trimMax = fillTop;
       trimMaxElevation = topElevation;
     } else {
-      trimMin = topJoint;
+      trimMin = fillTop;
       trimMinElevation = topElevation;
     }
     // 관 끝단 마감면 = 기슭막이의 **계류측 변**(전면)을 그대로 복사(사용자 ③).
@@ -507,11 +507,24 @@ export function computeCulvertLayout(
   // 다단 흙막이(유출측 · 집수정 계류측) — `_Culvert_Tiers` 가 푼다.
   const { extras, basinExtras, extrasForArea, basinExtrasForArea } = buildCulvertTiers({
     section,
-    outletStart: outletWall ? pipeCorners.outlet.bottom : null,
+    outletStart: outletWall
+      ? floatFillStart(
+          outletWall,
+          pipeCorners.outlet.bottom,
+          groundAt,
+          (revetShift?.extras ?? []).length > 0,
+        )
+      : null,
     outletBottom: outletWall?.bottomBack.elevation ?? 0,
     basinStart: culvert.hidden_pipe
       ? inletWall
-        ? (guardFloorStart(section, body, inletWall) ?? pipeCorners.inlet.bottom)
+        ? (guardFloorStart(section, body, inletWall) ??
+          floatFillStart(
+            inletWall,
+            pipeCorners.inlet.bottom,
+            groundAt,
+            (revetShift?.basinExtras ?? []).length > 0,
+          ))
         : null
       : basinFillStart,
     basinBottom: culvert.hidden_pipe ? (inletWall?.bottomBack.elevation ?? 0) : basinFillBottom,
diff --git a/B06_Section/B06_Section_UI_Cross_Culvert_Tiers.ts b/B06_Section/B06_Section_UI_Cross_Culvert_Tiers.ts
index 06c103e63..234def22d 100644
--- a/B06_Section/B06_Section_UI_Cross_Culvert_Tiers.ts
+++ b/B06_Section/B06_Section_UI_Cross_Culvert_Tiers.ts
@@ -9,7 +9,7 @@ import type { CrossSection } from "./B06_Section_Api_Fetch";
 import {
   GUARD_CUT_BERM_M,
   REVET_EMBED_DEPTH_M,
-  REVET_TRAP_TOP_M,
+  REVET_FILL_TOP_M,
 } from "./logic/B06_Section_UI_Cross_Culvert_Const";
 import type { OutletExtrasResult } from "./B06_Section_UI_Cross_Culvert_Extra";
 import { buildExtrasAt } from "./B06_Section_UI_Cross_Culvert_Extra";
@@ -26,7 +26,7 @@ export const slopeZeroAnchor = (
   outward: number,
   wallHeight: number,
   lean: number,
-): number => edge.offset_m + outward * (fillWallBaseWidth(wallHeight, lean) / 2 - REVET_TRAP_TOP_M);
+): number => edge.offset_m + outward * (fillWallBaseWidth(wallHeight, lean) / 2 - REVET_FILL_TOP_M);
 
 /** 유출 관 하단 끝점 목표 = 벽 바닥 기준 0.5m 상단(기준선)과 **전면 경사선의
  *  교차점**(2026-08-22 사용자 ① — 성토부선 시작 규칙과 같은 자리). */
@@ -106,7 +106,7 @@ export function buildCulvertTiers(input: {
   };
   const extras = buildExtrasAt(input.outletStart, outletInput);
   // 독립 기슭막이(관 숨김)는 집수정이 없어 이 채널이 **유입측 벽의 성토부선·다단**이다 —
-  // 유출측(`extras`)과 같은 시작점(관 하단 꼭짓점)·같은 `bextra` 키(2026-08-29 사용자).
+  // 유출측(`extras`)과 같은 시작점(`floatFillStart` · 371-1)·같은 `bextra` 키(2026-08-29 사용자).
   const basinInput = {
     cutBerm: cutBerm(culvert?.body ? (culvert.inlet.revet_berm_m ?? GUARD_CUT_BERM_M) : 0),
     startBottomElevation: input.basinBottom,
diff --git a/B06_Section/B06_Section_UI_Cross_Culvert_Types.ts b/B06_Section/B06_Section_UI_Cross_Culvert_Types.ts
index 65c5dae08..ac4aec3d0 100644
--- a/B06_Section/B06_Section_UI_Cross_Culvert_Types.ts
+++ b/B06_Section/B06_Section_UI_Cross_Culvert_Types.ts
@@ -123,8 +123,10 @@ export interface WallLayout {
   points: OffsetPoint[];
   /** 상단 배면 꼭짓점 — 성토 사면선과의 접점(설계선 트림 경계). */
   topBack: OffsetPoint;
-  /** 이음선 상단점(평행사변형↔사다리꼴 상단 교차점) — 성토 사면선이 여기서 끝난다. */
+  /** 이음선 상단점(평행사변형↔사다리꼴 상단 교차점) — 안 무늬 이음선 자리. */
   topJoint: OffsetPoint;
+  /** 성토 위 이음 — 윗면 사면 쪽 끝에서 0.1 m 안(371-1). 성토 사면선이 여기서 끝난다. */
+  fillTop: OffsetPoint;
   /** 하단선 양 끝 — **수평 기초**(2026-08-22 사용자 확정): 발자국 최저 지반(또는 관
    *  invert) − 0.5m 표고의 수평선. 전면 발끝은 1:0.3 경사선을 하단까지 연장한 자리다. */
   bottomBack: OffsetPoint;
diff --git a/B06_Section/B06_Section_UI_Cross_Design.ts b/B06_Section/B06_Section_UI_Cross_Design.ts
index 2fc78b270..5b43ca31a 100644
--- a/B06_Section/B06_Section_UI_Cross_Design.ts
+++ b/B06_Section/B06_Section_UI_Cross_Design.ts
@@ -28,6 +28,7 @@ export {
 } from "./B06_Section_UI_Cross_Design_Surface";
 export { appendCrossDesignOverlay } from "./B06_Section_UI_Cross_Design_Line";
 import { openCrossDetail, refreshCrossDetail } from "./B06_Section_UI_Cross_Detail";
+import { buildLineCell, rockCellState, type RockCellSpec } from "./B06_Section_UI_Cross_Line_Cell";
 
 /** 넘침 정리 한 장 몫 — 쓰기·읽기·쓰기 세 토막으로 갈라 두어 프레임 단위로 묶는다. */
 interface ReflowCard {
@@ -205,112 +206,29 @@ function toggle(
   return { wrap, button };
 }
 
-/**
- * 길게 누르는 동안 같은 동작을 반복한다(B05 종단 선 제어 패턴 재사용). 0.5초 유지하면
- * 0.1초 간격(0.1m씩) 반복이 시작된다. 버튼이 재빌드로 사라져도 반복이 끊기지 않도록
- * 타이머·종료 감지를 버튼이 아니라 window 이벤트로 들고 있는다.
- */
-function createHoldRepeater(): { start: (action: () => void) => void; stop: () => void } {
-  let delayTimer = 0;
-  let repeatTimer = 0;
-  function stop(): void {
-    window.clearTimeout(delayTimer);
-    window.clearInterval(repeatTimer);
-    delayTimer = 0;
-    repeatTimer = 0;
-    window.removeEventListener("pointerup", stop);
-    window.removeEventListener("pointercancel", stop);
-    window.removeEventListener("blur", stop);
-  }
-  function start(action: () => void): void {
-    stop();
-    delayTimer = window.setTimeout(() => {
-      repeatTimer = window.setInterval(action, 100);
-    }, 500);
-    window.addEventListener("pointerup", stop);
-    window.addEventListener("pointercancel", stop);
-    window.addEventListener("blur", stop);
-  }
-  return { start, stop };
-}
-
-/** 암 경계선 상/하/리셋 컨트롤(B05 측점 선 제어 ▲/▼/↺ 버튼 패턴 재활용). E-7: X축 행 배치용 export. */
+/** 암 경계선 상/하/리셋 컨트롤 — 아래 띠 공용 칸(370-3 · `_Cross_Line_Cell`)의 「안 고름」 꼴. 설계선 고름이
+ *  없는 카드(설계 없음)에서 띠 왼쪽 칸으로 씀. */
 export function buildRockBoundaryControl(
   section: CrossSection,
   control: RockBoundaryControl,
 ): HTMLElement {
-  const wrap = document.createElement("div");
-  wrap.className = "b06-design__seg b06-design__rockb";
-  const legendEl = document.createElement("span");
-  legendEl.className = "b06-design__seg-legend";
-  legendEl.textContent = L("B06_Design_RockBoundary_Legend");
-  wrap.append(legendEl);
+  const cell = buildLineCell();
+  cell.show(rockCellState(rockCellSpec(section, control)));
+  return cell.root;
+}
 
-  const group = document.createElement("div");
-  group.className = "b06-design__seg-buttons";
-  const readout = document.createElement("span");
-  readout.className = "b06-design__rockb-readout";
-  const currentOffset = control.offsetFor(section);
-  readout.textContent = `${currentOffset >= 0 ? "+" : ""}${currentOffset.toFixed(1)}m`;
-
-  const repeater = createHoldRepeater();
-  const makeButton = (
-    label: string,
-    title: string,
-    className: string,
-    onClick: () => void,
-    hold = false,
-  ): HTMLButtonElement => {
-    const button = document.createElement("button");
-    button.type = "button";
-    button.className = `b06-design__rockb-btn ${className}`;
-    button.textContent = label;
-    button.title = hold ? `${title}\n(길게 누르면 0.5초 뒤부터 연속 조정)` : title;
-    if (hold) {
-      // 포인터로 누르면 즉시 1회 반응하고 반복을 예약한다. 이어지는 click은 중복이라 삼킨다.
-      let swallowClick = false;
-      button.addEventListener("pointerdown", (event) => {
-        event.stopPropagation();
-        swallowClick = true;
-        onClick();
-        repeater.start(onClick);
-      });
-      button.addEventListener("click", (event) => {
-        event.stopPropagation();
-        if (swallowClick) {
-          swallowClick = false;
-          return;
-        }
-        onClick();
-      });
-    } else {
-      button.addEventListener("click", onClick);
-    }
-    return button;
+/** 암 경계선 칸 제원 — 공용 칸(안 고름 · 암 고름)이 같이 씀. */
+export function rockCellSpec(section: CrossSection, control: RockBoundaryControl): RockCellSpec {
+  return {
+    legend: L("B06_Design_RockBoundary_Legend"),
+    offsetM: control.offsetFor(section),
+    stepM: control.stepM,
+    upTitle: L("B06_Design_RockBoundary_Up"),
+    downTitle: L("B06_Design_RockBoundary_Down"),
+    resetTitle: L("B06_Design_RockBoundary_Reset"),
+    adjust: (deltaM) => control.adjust(section.chainage_m, deltaM),
+    reset: () => control.reset(section.chainage_m),
   };
-
-  group.append(
-    makeButton(
-      "▲",
-      `${L("B06_Design_RockBoundary_Up")} (+${control.stepM}m)`,
-      "is-up",
-      () => control.adjust(section.chainage_m, control.stepM),
-      true,
-    ),
-    makeButton(
-      "▼",
-      `${L("B06_Design_RockBoundary_Down")} (-${control.stepM}m)`,
-      "is-down",
-      () => control.adjust(section.chainage_m, -control.stepM),
-      true,
-    ),
-    makeButton("↺", L("B06_Design_RockBoundary_Reset"), "is-reset", () =>
-      control.reset(section.chainage_m),
-    ),
-    readout,
-  );
-  wrap.append(group);
-  return wrap;
 }
 
 /**
diff --git a/B06_Section/B06_Section_UI_Cross_Design_Pick.ts b/B06_Section/B06_Section_UI_Cross_Design_Pick.ts
index 355e83579..a6a4c892d 100644
--- a/B06_Section/B06_Section_UI_Cross_Design_Pick.ts
+++ b/B06_Section/B06_Section_UI_Cross_Design_Pick.ts
@@ -4,14 +4,18 @@
  *
  * 그려진 보라 선(`b06-chart__design-cross`)을 화면 좌표에서 m 로 되돌려 같은 방향 토막을
  * 직선 조각 하나로 합치고, 벽 · 본체 폴리곤에 가린 부분을 뺀 **보이는 조각**마다 투명 판정
- * 선을 구조물 판정면 아래에 깐다. 고르면 그 조각을 강조하고 [+ − ⤢] 왼쪽에 치수를 두 줄로 적는다.
+ * 선을 구조물 판정면 아래에 깐다. 고르면 그 조각을 강조하고 아래 띠 공용 칸(370-3 · `_Cross_Line_Cell`)에
+ * 제목 · 축에 맞는 버튼 · 치수 한 줄을 적는다(안 고르면 암 경계선 칸 · 떠 있는 선 조정창 · 우측 위 라벨 걷음).
  * 구역 판정(`crossZoneAt` · 도로 · 절토 · 성토)은 설계선 쉬프트(139-6)도 쓴다.
  * 고름 상태는 페이지에 한 칸(측점 + 조각 번호) — 카드를 다시 그려도 되살아난다.
- * 고른 조각 쪽 사면을 노견째 이동 패널(◀ ↺ ▶ · 방향키 · 0.1 m)로 옮김(139-6 쉬프트 · 151-3 ·
+ * 고른 조각 쪽 사면을 노견째 ◀ ↺ ▶ · 방향키 · 0.1 m 로 옮김(139-6 쉬프트 · 151-3 ·
  * 노폭 안쪽 금지 = 0 에서 멈춤). 축 제약(193-1) — 절 · 성토측 = 그 쪽 바깥 가로만(반대측 고정 ·
  * 구조물은 노견 끝에 서서 한 벌로 감) · 도로측(노면 · 노견) = 높이만(▲▼ = 종단 계획고).
  * 소단 수평 단(194) = 그 쪽 깊이만(▲▼ · ◀▶ 막음 · 노면 끝 위 금지) · 좌측 소단 상자 켬.
  * 고름은 조각 키(갈래 + 쪽 + 차례)로 기억 — 옮겨 다시 그려도 같은 조각(194-2).
+ * 교차점 손잡이(370-2) — 쪽마다 설계선 ∩ 원지반 원(키 `toe:left|right` · 늘 보임 · ◀▶) · ◀▶ 가 노견 끝 =
+ * 원지반 자리를 지나면 한 번 섬(`extendStop`) · 사면 키가 절 ↔ 성으로 바뀌면 같은 쪽 손잡이가 이어받음.
+ * 암 경계선(370-3) — 점선 위 판정 선(키 `rock`) · ▲▼↺ · ◀▶ 막음 · 방향키 = 암만 · 세로 끌기(놓을 때 한 번).
  * ========================================================================== */
 
 import type { CrossDesign, CrossSection } from "./B06_Section_Api_Fetch";
@@ -19,18 +23,30 @@ import type { CrossDesignChange } from "./B06_Section_UI_Cross_Design";
 import { clipSegment, type XY } from "../A00_Common/b_polygon_clip";
 import { sideRole } from "@util/common_util_cross_design_geometry";
 import { BERM_DEFAULT_DEPTH_M } from "@util/common_util_cross_berm";
+import { arrowsBelongToProfile, bindArrowKeys } from "./B06_Section_UI_Cross_Panel_Base";
 import {
-  arrowsBelongToProfile,
-  bindArrowKeys,
-  buildPanelShell,
-  dpadButton,
-  makeRow,
-} from "./B06_Section_UI_Cross_Panel_Base";
-import { bindCenterShift, centerHit, centerPreviewText } from "./B06_Section_UI_Cross_Center";
+  bindAxisDrag,
+  bindCenterShift,
+  centerHit,
+  centerPreviewText,
+} from "./B06_Section_UI_Cross_Center";
+import {
+  buildLineCell,
+  rockCellState,
+  rockValueText,
+  type LineCellState,
+  type RockCellSpec,
+} from "./B06_Section_UI_Cross_Line_Cell";
+import { extendStop, toePoints } from "./logic/B06_Section_UI_Cross_Fit";
 
 const SVG_NS = "http://www.w3.org/2000/svg";
 const DESIGN_CLASS = "b06-chart__design-cross";
 const HIT_CLASS = "b06-chart__design-hit";
+/** 교차점 손잡이 원(370-2) — 중심점 판정 원 클래스에 덧붙임(고르기 차례 같음). */
+const TOE_CLASS = "b06-chart__toe-hit";
+/** 암 경계선 점선 · 그 위 판정 선(370-3 · 판정 선은 보라 선 판정 클래스에 덧붙임). */
+const ROCK_LINE_CLASS = "b06-chart__rock-boundary";
+export const ROCK_HIT_CLASS = "b06-chart__rock-hit";
 /** 설계선 오버레이가 그린 선 표시(구조물 트림 선과 가름) — 카드가 그린 직후 단다. */
 export const DESIGN_LINE_ATTR = "data-design-line";
 /** 보라 선을 덮는 벽 · 본체 폴리곤. */
@@ -114,7 +130,7 @@ export const pieceMoveAxis = (design: ZoneDesign, piece: DesignPiece): MoveAxis
   isBermPiece(design, piece) ? "depth" : pieceZone(design, piece).zone === "road" ? "y" : "x";
 /** x = 사면 가로 · y = 노면 높이(종단 계획고) · depth = 소단 높이(그 쪽 깊이 · 194-1) ·
  *  center = 중심점(▲▼ 종단 계획고 · ◀▶ 노선 좌우 · 356-3). */
-export type MoveAxis = "x" | "y" | "depth" | "center";
+export type MoveAxis = "x" | "y" | "depth" | "center" | "rock";
 
 /** 그 쪽 소단 깊이(노면 끝 아래 m) — 옮긴 값 → 구간 값 → 기본 1.0(194-1). */
 export const bermDepthOf = (design: ZoneDesign, side: CrossSide): number =>
@@ -282,7 +298,10 @@ const keysByStation = new Map<string, string[]>();
 export function pickedLineAt(stationId: string): number | null {
   if (picked?.stationId !== stationId) return null;
   const keys = keysByStation.get(stationId);
-  const index = keys ? keys.indexOf(picked.key) : Number(picked.key);
+  let index = keys ? keys.indexOf(picked.key) : Number(picked.key);
+  // 사면이 절 ↔ 성으로 넘어가 키가 바뀌거나 길이 0 으로 사라지면 같은 쪽 교차점 손잡이(370-2)
+  const slope = /^(?:cut|fill)(?:\+s)?:(left|right):/.exec(picked.key);
+  if (index < 0 && keys && slope) index = keys.indexOf(`toe:${slope[1]}`);
   return index >= 0 ? index : null;
 }
 export function setPickedLine(stationId: string, index: number | null): void {
@@ -312,7 +331,12 @@ const pointsOf = (element: Element): XY[] => {
 export interface ShoulderShift {
   valueOf: (side: CrossSide) => number;
   set: (side: CrossSide, valueM: number) => void;
+  /** 한 걸음 now → next 사이 노견 끝 = 원지반 자리가 있으면 그 값(370-2 · 없으면 next). */
+  stopAt?: (side: CrossSide, now: number, next: number) => number;
 }
+/** 이동값 글 — 0.1 m 눈금이면 한 자리 · 멈춤 자리(370-2)면 두 자리. */
+const extendText = (valueM: number): string =>
+  valueM.toFixed(Math.abs(valueM * 10 - Math.round(valueM * 10)) < 1e-6 ? 1 : 2);
 /** 쉬프트 걸음(m). */
 export const SHIFT_STEP_M = 0.1;
 
@@ -345,11 +369,22 @@ function tellBermHost(chainageM: number | null): void {
 
 /** 카드 → 고름 이동 창구 — 노견 확장(139-6) · 소단 깊이(194-1) 둘 다 카드 버튼과 같은 창구. */
 export function designLineMoves(
-  section: Pick<CrossSection, "station_id" | "chainage_m" | "design">,
+  section: Pick<CrossSection, "station_id" | "chainage_m" | "design" | "samples">,
   onDesignChange?: (chainageM: number, change: CrossDesignChange) => void,
-): { stationId: string; shift?: ShoulderShift; berm?: BermDepthControl; center?: number } {
+  /** 암 경계선 칸 제원(`rockCellSpec`) — 암 지반일 때만 씀(370-3). */
+  rockSpec?: RockCellSpec,
+): {
+  stationId: string;
+  shift?: ShoulderShift;
+  berm?: BermDepthControl;
+  center?: number;
+  toes?: ReturnType<typeof toePoints>;
+  rock?: RockCellSpec;
+} {
   const design = section.design;
-  if (!onDesignChange || !design) return { stationId: section.station_id };
+  // 암 경계선 = 암 지반만(370-3 · 띠 칸과 같은 창구)
+  const rock = design?.geometry_preset === "rock" ? rockSpec : undefined;
+  if (!onDesignChange || !design) return { stationId: section.station_id, rock };
   const send = (change: Partial<CrossDesignChange>) =>
     onDesignChange(section.chainage_m, {
       ...(design as unknown as CrossDesignChange),
@@ -357,11 +392,14 @@ export function designLineMoves(
     });
   return {
     stationId: section.station_id,
+    rock,
     center: section.chainage_m, // 중심점 좌우 = 이 측점 노선(356-3)
     shift: {
       valueOf: (side) => design[`shoulder_extend_${side}_m`] ?? 0,
       set: (side, valueM) => send({ shoulder_extend: { side, valueM } }),
+      stopAt: (side, now, next) => extendStop(section.samples, design.road_edges, side, now, next),
     },
+    toes: toePoints(section), // 교차점 손잡이(370-2)
     berm: {
       set: (side, valueM) => send({ berm_depth: { side, valueM } }),
       // 끔은 이 측점이 켠 때만 — 다른 카드 소단을 고르며 옛 카드가 풀릴 때 새 켬을 안 지움
@@ -375,10 +413,8 @@ export function designLineMoves(
 
 export interface DesignLinePick {
   pieces: DesignPiece[];
-  /** 치수 칸 — 카드가 [+ − ⤢] 앞에 붙임 · 고름 없으면 숨김. */
-  label: HTMLElement;
-  /** 사면 이동 패널(151-3) — 카드가 그림 칸에 붙임 · `shift` 없거나 고름 없으면 숨김. */
-  panel: HTMLElement;
+  /** 아래 띠 왼쪽 공용 칸(370-3) — 카드가 띠에 붙임 · 고른 선 제목 · 버튼 · 값 한 줄(안 고르면 암). */
+  cell: HTMLElement;
   setActive: (index: number | null) => void;
 }
 
@@ -400,6 +436,10 @@ export function attachDesignLinePick(input: {
   stationId?: string;
   /** 있으면 중심점 고름(끝 조각 · 키 `center`) — 그 측점 누가거리(356-3). */
   center?: number;
+  /** 있으면 쪽마다 교차점 손잡이(설계선 ∩ 원지반 · 키 `toe:left|right` · 늘 보임 · 370-2). */
+  toes?: ReturnType<typeof toePoints>;
+  /** 있으면 암 경계선 고름(키 `rock` · ▲▼↺ · 세로 끌기) · 안 고른 때 공용 칸 = 암(370-3). */
+  rock?: RockCellSpec;
 }): DesignLinePick {
   const { layer, design, x, toDisplayY } = input;
   const x0 = x(0);
@@ -429,7 +469,14 @@ export function attachDesignLinePick(input: {
       : edges.right.elevation_m -
         ((edges.left.elevation_m - edges.right.elevation_m) * edges.right.offset_m) /
           (edges.left.offset_m - edges.right.offset_m);
-  const keys = [...pieceKeys(design, pieces), ...(centerZ === null ? [] : ["center"])];
+  const toeSides = (["left", "right"] as const).filter((at) => input.toes?.[at]);
+  const rockLines = input.rock ? kids.filter((el) => el.classList.contains(ROCK_LINE_CLASS)) : [];
+  const keys = [
+    ...pieceKeys(design, pieces),
+    ...(centerZ === null ? [] : ["center"]),
+    ...toeSides.map((at) => `toe:${at}`),
+    ...(rockLines.length ? ["rock"] : []),
+  ];
   if (input.stationId) keysByStation.set(input.stationId, keys);
 
   // 판정 선은 구조물 판정면 아래에 꽂음 — 카드가 끝에 `stackPickTargets` 로 맨 위에 다시 세움(295-1).
@@ -448,6 +495,26 @@ export function attachDesignLinePick(input: {
   // 중심점(356-3) = 끝 조각 · 판정 원은 고르기 차례가 보라 선 위로(`stackPickTargets`)
   const center = centerZ === null ? null : centerHit(x0, toDisplayY(centerZ));
   if (center) hits.push(center);
+  // 교차점 손잡이(370-2) — 쪽마다 원 · 늘 보임 · 고르면 그 쪽 사면 ◀▶(중심점 원과 같은 고르기 차례)
+  for (const at of toeSides) {
+    const toe = input.toes?.[at] as { offset_m: number; elevation_m: number };
+    const hit = centerHit(x(toe.offset_m), toDisplayY(toe.elevation_m));
+    hit.classList.add(TOE_CLASS);
+    hit.setAttribute("r", "5");
+    hits.push(hit);
+  }
+  // 암 경계선(370-3) — 점선(`appendRockBoundaryOverlay`) 위 판정 선 하나(끊긴 토막도 한 path) · 키 rock
+  let rockHit: SVGElement | null = null;
+  if (rockLines.length) {
+    rockHit = document.createElementNS(SVG_NS, "path");
+    const path = (el: Element) =>
+      `M${pointsOf(el)
+        .map(([px, py]) => `${px},${py}`)
+        .join(" L")}`;
+    rockHit.setAttribute("d", rockLines.map(path).join(" "));
+    rockHit.setAttribute("class", `${HIT_CLASS} ${ROCK_HIT_CLASS}`);
+    hits.push(rockHit);
+  }
   hits.forEach((hit, index) => {
     hit.addEventListener("click", (event) => {
       event.stopPropagation(); // 카드 고름 · 면적 띠로 번지지 않음
@@ -456,23 +523,10 @@ export function attachDesignLinePick(input: {
     layer.insertBefore(hit, firstStructureHit ?? null);
   });
 
-  const label = document.createElement("span");
-  label.className = "b06-cross-card__line-dims";
-  label.hidden = true;
+  const cell = buildLineCell();
   let side: CrossSide | null = null;
   let axis: MoveAxis = "x";
-  let active: number | null = null;
-  const { shift, berm } = input;
-
-  // 사면 이동 패널(151-3) — B06 공용 조정창 꼴(머리 · 「이동」 줄 십자 · 방향키 ←→).
-  // ✕ = 같은 조각 다시 고름(카드가 풂) · ↺ = 그 쪽 0.
-  const shell = buildPanelShell(() => {
-    if (active !== null) input.onPick(active);
-  });
-  const readout = document.createElement("div");
-  readout.className = "b06-structure-panel__value";
-  const move = makeRow("이동");
-  move.controls.classList.add("b06-structure-panel__buttons");
+  const { shift, berm, rock } = input;
   const centerShift =
     center && input.center !== undefined
       ? bindCenterShift({
@@ -481,28 +535,44 @@ export function attachDesignLinePick(input: {
           chainageM: input.center,
           kx,
           active: () => axis === "center",
-          preview: (deltaM) => (readout.textContent = centerPreviewText(deltaM)),
+          preview: (deltaM) => cell.setValue(centerPreviewText(deltaM)),
         })
       : null;
+  // 암 경계선 세로 끌기(370-3) — 고른 뒤에만 · 걸음 0.1 m · 끄는 동안 점선만 옮겨 보이고 놓을 때 한 번
+  if (rockHit && rock)
+    bindAxisDrag({
+      hit: rockHit,
+      layer: layer as SVGGraphicsElement,
+      axis: "y",
+      pxPerM: ky,
+      active: () => axis === "rock",
+      preview: (deltaM) => {
+        for (const el of [rockHit, ...rockLines])
+          (el as SVGElement).style.setProperty("translate", deltaM ? `0px ${deltaM * ky}px` : "");
+        const next = rockValueText(Math.min(rock.offsetM + deltaM, 0));
+        cell.setValue(deltaM ? `${next} — 놓으면 반영` : rockValueText(rock.offsetM));
+      },
+      send: (deltaM) => rock.adjust(deltaM),
+    });
   const step = (dir: -1 | 1) => () => {
     if (axis === "center") return centerShift?.step(dir);
-    if (side && shift) shift.set(side, shiftedExtend(shift.valueOf(side), side, dir, kx));
+    if (!side || !shift) return;
+    // 노견 끝 = 원지반(절도 성도 아닌 점)을 지나면 그 자리에 한 번 섬(370-2)
+    const now = shift.valueOf(side);
+    const next = shiftedExtend(now, side, dir, kx);
+    shift.set(side, shift.stopAt?.(side, now, next) ?? next);
   };
   // 툴팁 = 고른 것의 실제 동작(364-7 · 사면 = 노견째 이동 · 중심점 = 그 측점 노선)
   const stepTitle = (screen: "왼쪽" | "오른쪽"): string =>
     axis === "center"
       ? `이 측점 노선을 화면 ${screen}으로 0.1 m`
       : `고른 사면을 화면 ${screen}으로 0.1 m(노견째 · 노폭 안쪽은 못 감)`;
-  move.controls.append(
-    dpadButton("◀", "left", stepTitle("왼쪽"), step(-1)),
-    dpadButton("↺", "reset", "이 쪽 이동 0", () => {
-      if (side && shift) shift.set(side, 0);
-    }),
-    dpadButton("▶", "right", stepTitle("오른쪽"), step(1)),
-  );
-  // 소단 높이 줄(194-1) — ▲ = 얕게(노면 끝 위 금지 = 0 에서 멈춤) · ▼ = 깊게(사면 끝 앞에서 멈춤)
-  const lift = makeRow("높이");
-  lift.controls.classList.add("b06-structure-panel__buttons");
+  const sideways = (reset: boolean): LineCellState["buttons"] => ({
+    left: { title: stepTitle("왼쪽"), act: step(-1) },
+    ...(reset && { reset: { title: "이 쪽 이동 0", act: () => side && shift?.set(side, 0) } }),
+    right: { title: stepTitle("오른쪽"), act: step(1) },
+  });
+  // 소단 높이(194-1) — ▲ = 얕게(노면 끝 위 금지 = 0 에서 멈춤) · ▼ = 깊게(사면 끝 앞에서 멈춤)
   const toeZ = (at: CrossSide): number =>
     Math.min(
       ...pieces
@@ -517,23 +587,23 @@ export function attachDesignLinePick(input: {
     if (dir > 0 && edgeZ !== undefined && edgeZ - next < toeZ(side) + SHIFT_STEP_M) return;
     if (next !== now) berm.set(side, next);
   };
-  lift.controls.append(
-    dpadButton("▲", "up", "고른 소단을 0.1 m 위로(노면 끝보다 높을 수 없음)", deepen(-1)),
-    dpadButton("↺", "reset", "이 쪽 소단 = 구간 기본 깊이", () => {
-      if (side && berm) berm.set(side, design.berm?.depth_m ?? BERM_DEFAULT_DEPTH_M);
-    }),
-    dpadButton("▼", "down", "고른 소단을 0.1 m 아래로", deepen(1)),
-  );
-  shell.root.append(readout, move.row, lift.row);
-  const arrows = bindArrowKeys(shell.root, () => [move.controls, lift.controls]);
-  // 못 가는 축의 방향키는 먹어 막음(193-1) — 사면 ▲▼ 가 종단 계획고로 새지 않고 · 노면 ◀▶ 는 안 감.
-  // 노면 ▲▼ 는 그대로 종단도(계획고 · 종단 함께)로 넘김.
+  const lift: LineCellState["buttons"] = {
+    up: { title: "고른 소단을 0.1 m 위로(노면 끝보다 높을 수 없음)", act: deepen(-1) },
+    reset: {
+      title: "이 쪽 소단 = 구간 기본 깊이",
+      act: () => side && berm?.set(side, design.berm?.depth_m ?? BERM_DEFAULT_DEPTH_M),
+    },
+    down: { title: "고른 소단을 0.1 m 아래로", act: deepen(1) },
+  };
+  const arrows = bindArrowKeys(cell.root, () => [cell.buttons]);
+  // 못 가는 축의 방향키는 먹어 막음(193-1) — 사면 ▲▼ 가 종단 계획고로 새지 않고 · 노면 ◀▶ 는 안 감 ·
+  // 암 ◀▶ 막음(370-3). 노면 ▲▼ 는 그대로 종단도(계획고 · 종단 함께)로 넘김.
   const blockOffAxis = (event: KeyboardEvent): void => {
-    if (!shell.root.isConnected) {
+    if (!cell.root.isConnected) {
       document.removeEventListener("keydown", blockOffAxis);
       return;
     }
-    if (shell.root.classList.contains("is-hidden") || arrowsBelongToProfile()) return;
+    if (arrowsBelongToProfile()) return;
     const focus = event.target as HTMLElement | null;
     if (focus && (focus.tagName === "SELECT" || focus.tagName === "INPUT")) return;
     const vertical = event.key === "ArrowUp" || event.key === "ArrowDown";
@@ -543,53 +613,55 @@ export function attachDesignLinePick(input: {
 
   return {
     pieces,
-    label,
-    panel: shell.root,
+    cell: cell.root,
     setActive: (index) => {
-      const onCenter = !!centerShift && index === pieces.length;
-      const piece = index === null ? undefined : pieces[index];
-      hits.forEach((hit, i) =>
-        hit.classList.toggle("is-active", (!!piece || onCenter) && i === index),
-      );
-      label.hidden = !piece && !onCenter;
-      active = piece || onCenter ? index : null;
-      side = piece ? pieceZone(design, piece).side : null;
-      axis = onCenter ? "center" : piece ? pieceMoveAxis(design, piece) : "x";
+      const key = index === null ? undefined : keys[index];
+      const onCenter = !!centerShift && key === "center";
+      const onRock = !!rockHit && key === "rock";
+      const toeSide = key?.startsWith("toe:") ? (key.slice(4) as CrossSide) : null;
+      const piece = index === null || index >= pieces.length ? undefined : pieces[index];
+      const chosen = !!piece || onCenter || onRock || !!toeSide;
+      hits.forEach((hit, i) => hit.classList.toggle("is-active", chosen && i === index));
+      side = piece ? pieceZone(design, piece).side : toeSide;
+      axis = onRock ? "rock" : onCenter ? "center" : piece ? pieceMoveAxis(design, piece) : "x";
       const extend = side && shift && axis === "x" ? shift.valueOf(side) : 0;
-      label.textContent = onCenter
-        ? "중심점"
-        : piece
-          ? pieceLabel(design, piece) + (extend > 0 ? ` · 이동 +${extend.toFixed(1)}m` : "")
-          : "";
-      const open = onCenter || !!(piece && (axis === "depth" ? berm : shift));
-      shell.root.classList.toggle("is-hidden", !open);
-      // 이동 셋 분리(194-2) — 사면 = 이동 줄(◀▶) · 소단 = 높이 줄(▲▼) · 노면 = 둘 다 숨김(▲▼ 종단)
-      // 중심점 = 이동 줄 ◀▶(노선 좌우 · ↺ 없음) · ▲▼ 는 종단도로(356-3)
-      const sideways = axis === "x" || axis === "center";
-      move.row.classList.toggle("is-hidden", !sideways);
-      move.controls.classList.toggle("is-hidden", !sideways);
-      move.controls.children[1]?.classList.toggle("is-hidden", axis === "center");
-      const [toLeft, , toRight] = move.controls.children as unknown as HTMLElement[];
-      [toLeft.title, toRight.title] = [stepTitle("왼쪽"), stepTitle("오른쪽")];
-      lift.row.classList.toggle("is-hidden", axis !== "depth");
-      lift.controls.classList.toggle("is-hidden", axis !== "depth");
       const sideName = side === "left" ? "(좌)" : "(우)";
-      shell.title.textContent =
-        axis === "center"
-          ? "중심점"
-          : axis === "y"
-            ? "노면 높이"
-            : axis === "depth"
-              ? `소단 높이 ${sideName}`
-              : `사면 이동 ${sideName}`;
-      readout.textContent =
-        axis === "center"
-          ? centerPreviewText(0)
-          : axis === "y"
-            ? "방향키 ▲▼ = 종단 계획고(종단도 함께)"
-            : axis === "depth" && side
-              ? `도로 아래 ${bermDepthOf(design, side).toFixed(1)}m`
-              : `이동 ${extend.toFixed(1)}m`;
+      const moved = extend > 0 ? ` · 이동 +${extendText(extend)}m` : "";
+      const toe = toeSide ? input.toes?.[toeSide] : null;
+      const dims = piece ? pieceLabel(design, piece).replace("\n", " · ") : "";
+      // 아래 띠 공용 칸(370-3) — 안 고르면 암(암 지반만) · 고르면 그 선 제목 · 버튼 · 값 한 줄
+      const state: LineCellState | null =
+        onRock || (!chosen && rock)
+          ? rockCellState(rock as RockCellSpec)
+          : onCenter
+            ? { title: "중심점", value: centerPreviewText(0), buttons: sideways(false) }
+            : toe
+              ? {
+                  title: `교차점 이동 ${sideName}`,
+                  value: `노선에서 ${Math.abs(toe.offset_m).toFixed(2)}m${moved}`,
+                  buttons: shift ? sideways(true) : {},
+                }
+              : !piece
+                ? null
+                : axis === "y"
+                  ? { title: "노면 높이", value: `${dims} · ▲▼ = 종단 계획고`, buttons: {} }
+                  : axis === "depth" && side
+                    ? {
+                        title: `소단 높이 ${sideName}`,
+                        value: `도로 아래 ${bermDepthOf(design, side).toFixed(1)}m · ${dims}`,
+                        buttons: berm ? lift : {},
+                      }
+                    : {
+                        title: `사면 이동 ${sideName}`,
+                        value: dims + moved,
+                        buttons: shift ? sideways(true) : {},
+                      };
+      cell.show(state);
+      const open =
+        onCenter ||
+        onRock ||
+        (!!toeSide && !!shift) ||
+        !!(piece && (axis === "depth" ? berm : shift));
       berm?.focus(axis === "depth" && !!piece); // 좌측 소단 상자 켬 · 끔(194-2)
       arrows.detach();
       document.removeEventListener("keydown", blockOffAxis);
diff --git a/B06_Section/B06_Section_UI_Cross_Detail_Cad.ts b/B06_Section/B06_Section_UI_Cross_Detail_Cad.ts
index a61eb785d..d7fd17bed 100644
--- a/B06_Section/B06_Section_UI_Cross_Detail_Cad.ts
+++ b/B06_Section/B06_Section_UI_Cross_Detail_Cad.ts
@@ -7,7 +7,7 @@
  *   (`_Engine_Cad_Table.cross_note_cad_entities`).
  * 처음 열 때 칸이 없으면 — 옛 글(`structure_note`)이 있으면 줄마다 Text 로 옮김 · 없으면 미리 넣음
  *   (265-2 · 관 주인 측점 = 원형 마크 · 그 측점 구조물마다 지정된 구조물 조합 이름 줄 · 미지정 =
- *   「이름 조합 미지정」 · 이어서 좌측 패널 옵션 줄 = `structureOptionLines` · 166-1) · 그 밖 = 빈 도면.
+ *   종류 이름만(같은 측점 같은 종류 한 줄) · 이어서 좌측 패널 옵션 줄 = `structureOptionLines` · 166-1) · 그 밖 = 빈 도면.
  * ⚠ 짝(①) = `B07_DesignDetail/B07_DesignDetail_Engine_Cad_CulvertNote.py` — `noteEntities` ·
  *   `structureNoteLines` · `stationNoLabel` 와 같은 입력 → 같은 엔티티(id 만 다름) · 모달을 안 연
  *   측점은 B07 이 그것으로 그림 · 거울 시험 `test_260_note_cad.py` · `test_265_note_cad.py`.
@@ -158,10 +158,11 @@ export const thingsAt = (things: readonly NoteThing[], chainageM: number): NoteT
 
 /**
  * 구조물 조합 줄 — 구조물마다 지정된 조합(본체 → 그룹 차례) 이름 한 줄씩(이름 = 일위대가 이름 +
- * 조합 경로 옵션 값) · 같은 구조물의 같은 이름은 한 줄 · 미지정 = 「{구조물 이름} 조합 미지정」 ·
+ * 조합 경로 옵션 값) · 같은 구조물의 같은 이름은 한 줄 · 미지정 = 종류 이름만(같은 측점 같은 종류는 한 줄) ·
  * 배관은 본체 줄 없음(원형 마크) — 보호공 · 흙막이 · 도수로 조합만 · 이어서 그 구조물 좌측 패널 옵션 줄(166-1).
  */
 export function structureNoteLines(things: readonly NoteThing[], chainageM: number): string[] {
+  const kinds = new Set<string>();
   return thingsAt(things, chainageM).flatMap((thing) => {
     const own = readSummaryItem(thing.summary_item);
     const slots: Array<[string, SummaryItem]> = Object.entries(readGroupItems(thing.group_items));
@@ -171,9 +172,10 @@ export function structureNoteLines(things: readonly NoteThing[], chainageM: numb
       .map(([, item]) => summaryLabel(item));
     const combos = slots.length
       ? [...new Set(names)]
-      : thing.pipe
+      : thing.pipe || kinds.has(thing.name)
         ? []
-        : [`${thing.name} 조합 미지정`];
+        : [thing.name];
+    if (!slots.length) kinds.add(thing.name);
     return [...combos, ...(thing.optionLines ?? [])];
   });
 }
diff --git a/B06_Section/B06_Section_UI_Cross_Detail_Pick.ts b/B06_Section/B06_Section_UI_Cross_Detail_Pick.ts
index f76ffb8cf..0ef41df87 100644
--- a/B06_Section/B06_Section_UI_Cross_Detail_Pick.ts
+++ b/B06_Section/B06_Section_UI_Cross_Detail_Pick.ts
@@ -53,15 +53,17 @@ function targetsOf(svg: Element, design: CrossDesign | undefined, key: string):
   const ppm = Number(svg.getAttribute("data-px-per-m"));
   if (!design || !center || !(ppm > 0)) return [];
   const x0 = Number(center.getAttribute("x1"));
-  return [...svg.querySelectorAll(".b06-chart__design-hit")].filter((hit) => {
-    const xs = (hit.getAttribute("points") ?? "")
-      .trim()
-      .split(/\s+/)
-      .map((pair) => Number(pair.split(",")[0]));
-    const mid = (xs[0] + xs[xs.length - 1]) / 2;
-    // x = 왼쪽 여백 + (최대 offset − offset) × ppm → offset = (x(0) − x) ÷ ppm
-    return lineZone(design, (x0 - mid) / ppm) === target.zone;
-  });
+  return [...svg.querySelectorAll(".b06-chart__design-hit:not(.b06-chart__rock-hit)")].filter(
+    (hit) => {
+      const xs = (hit.getAttribute("points") ?? "")
+        .trim()
+        .split(/\s+/)
+        .map((pair) => Number(pair.split(",")[0]));
+      const mid = (xs[0] + xs[xs.length - 1]) / 2;
+      // x = 왼쪽 여백 + (최대 offset − offset) × ppm → offset = (x(0) − x) ÷ ppm
+      return lineZone(design, (x0 - mid) / ppm) === target.zone;
+    },
+  );
 }
 
 /** 그림 복제 안 강조 — 묻어 온 `.is-active` 를 지우고 `key` 대상만 켬(null = 모두 끔). */
diff --git a/B06_Section/B06_Section_UI_Cross_Line_Cell.ts b/B06_Section/B06_Section_UI_Cross_Line_Cell.ts
new file mode 100644
index 000000000..3e7f6d6ee
--- /dev/null
+++ b/B06_Section/B06_Section_UI_Cross_Line_Cell.ts
@@ -0,0 +1,172 @@
+/* =============================================================================
+ * B06_Section_UI_Cross_Line_Cell.ts
+ * 횡단 카드 아래 띠 왼쪽 **공용 칸**(370-3) — 고른 선의 제목 · 축에 맞는 버튼 · 값 한 줄.
+ *
+ *   · 안 고르면 암 경계선 ▲▼↺ · 값(암 지반만 · 토사는 빈 칸 · 띠 높이 그대로)
+ *   · 고르면 그 선(노면 · 사면 · 소단 · 중심점 · 교차점 · 암) — `_Cross_Design_Pick` 이 상태를 넣음
+ *   · 버튼 다섯 칸(◀ ▲ ↺ ▼ ▶)은 한 벌 · 상태마다 보임 · 툴팁 · 동작만 바꿈 · 방향키는 보이는 슬롯만 찾음
+ *   · ▲▼ 길게 누름 = 0.5 초 뒤 0.1 초마다 반복(암 · B05 종단 선 제어 꼴)
+ * ========================================================================== */
+
+export type CellSlot = "left" | "up" | "reset" | "down" | "right";
+const SLOTS: Array<[CellSlot, string]> = [
+  ["left", "◀"],
+  ["up", "▲"],
+  ["reset", "↺"],
+  ["down", "▼"],
+  ["right", "▶"],
+];
+
+export interface CellButton {
+  title: string;
+  act: () => void;
+  /** 길게 누르면 반복. */
+  hold?: boolean;
+}
+export interface LineCellState {
+  title: string;
+  buttons: Partial<Record<CellSlot, CellButton>>;
+  value: string;
+}
+export interface LineCell {
+  root: HTMLElement;
+  /** 버튼 줄 — 방향키 묶음(`bindArrowKeys`)이 슬롯 버튼을 찾는 그릇. */
+  buttons: HTMLElement;
+  /** null = 빈 칸(자리는 남음). */
+  show: (state: LineCellState | null) => void;
+  /** 값 글만 바꿈(끄는 동안 미리 보기). */
+  setValue: (text: string) => void;
+}
+
+/**
+ * 길게 누르는 동안 같은 동작을 반복한다(B05 종단 선 제어 패턴 재사용). 0.5초 유지하면
+ * 0.1초 간격 반복이 시작된다. 버튼이 재빌드로 사라져도 반복이 끊기지 않도록
+ * 타이머·종료 감지를 버튼이 아니라 window 이벤트로 들고 있는다.
+ */
+function createHoldRepeater(): { start: (action: () => void) => void; stop: () => void } {
+  let delayTimer = 0;
+  let repeatTimer = 0;
+  function stop(): void {
+    window.clearTimeout(delayTimer);
+    window.clearInterval(repeatTimer);
+    delayTimer = 0;
+    repeatTimer = 0;
+    window.removeEventListener("pointerup", stop);
+    window.removeEventListener("pointercancel", stop);
+    window.removeEventListener("blur", stop);
+  }
+  function start(action: () => void): void {
+    stop();
+    delayTimer = window.setTimeout(() => {
+      repeatTimer = window.setInterval(action, 100);
+    }, 500);
+    window.addEventListener("pointerup", stop);
+    window.addEventListener("pointercancel", stop);
+    window.addEventListener("blur", stop);
+  }
+  return { start, stop };
+}
+
+/** 버튼 칸 표시(보임과 무관 · 시험이 찾음) — 슬롯 클래스(`b06-structure-panel__btn--*`)는 보일 때만. */
+export const CELL_BTN = "b06-cross-card__cell-btn--";
+const HOLD_HINT = "\n(길게 누르면 0.5초 뒤부터 연속 조정)";
+
+export function buildLineCell(): LineCell {
+  const root = document.createElement("div");
+  root.className = "b06-design__seg b06-design__rockb b06-cross-card__linecell";
+  root.addEventListener("click", (event) => event.stopPropagation()); // 카드 고름 · 팬으로 안 번짐
+  const legend = document.createElement("span");
+  legend.className = "b06-design__seg-legend";
+  const group = document.createElement("div");
+  group.className = "b06-design__seg-buttons";
+  const readout = document.createElement("span");
+  readout.className = "b06-design__rockb-readout";
+  const repeater = createHoldRepeater();
+  let current: LineCellState | null = null;
+  const run = (slot: CellSlot) => current?.buttons[slot]?.act();
+  const buttons = SLOTS.map(([slot, text]) => {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = `b06-design__rockb-btn ${CELL_BTN}${slot}`;
+    if (slot === "reset") button.classList.add("is-reset");
+    button.textContent = text;
+    // 길게 누름 — 누르면 즉시 1회 · 반복 예약 · 이어지는 click 은 삼킴
+    let swallowClick = false;
+    button.addEventListener("pointerdown", (event) => {
+      if (!current?.buttons[slot]?.hold) return;
+      event.stopPropagation();
+      swallowClick = true;
+      run(slot);
+      repeater.start(() => run(slot));
+    });
+    button.addEventListener("click", (event) => {
+      event.stopPropagation();
+      if (swallowClick) {
+        swallowClick = false;
+        return;
+      }
+      run(slot);
+    });
+    group.append(button);
+    return [slot, button] as const;
+  });
+  group.append(readout);
+  root.append(legend, group);
+  const cell: LineCell = {
+    root,
+    buttons: group,
+    show: (state) => {
+      current = state;
+      root.classList.toggle("is-empty", !state);
+      legend.textContent = state?.title ?? "";
+      readout.textContent = state?.value ?? "";
+      readout.title = state?.value ?? "";
+      for (const [slot, button] of buttons) {
+        const spec = state?.buttons[slot];
+        button.hidden = !spec;
+        // 방향키 묶음은 슬롯 클래스로 찾음 — 숨은 버튼은 슬롯을 떼어 키를 안 삼킴(노면 ▲▼ = 종단도)
+        button.classList.toggle(`b06-structure-panel__btn--${slot}`, !!spec);
+        button.title = spec ? spec.title + (spec.hold ? HOLD_HINT : "") : "";
+      }
+    },
+    setValue: (text) => {
+      readout.textContent = text;
+      readout.title = text;
+    },
+  };
+  cell.show(null);
+  return cell;
+}
+
+/** 암 경계선 칸 상태(안 고름 · 암 고름 둘 다) — ▲ = 위로 · ▼ = 아래로 · ↺ = 기본. */
+export interface RockCellSpec {
+  legend: string;
+  offsetM: number;
+  stepM: number;
+  upTitle: string;
+  downTitle: string;
+  resetTitle: string;
+  adjust: (deltaM: number) => void;
+  reset: () => void;
+}
+export const rockValueText = (offsetM: number): string =>
+  `${offsetM >= 0 ? "+" : ""}${offsetM.toFixed(1)}m`;
+export function rockCellState(rock: RockCellSpec): LineCellState {
+  return {
+    title: rock.legend,
+    value: rockValueText(rock.offsetM),
+    buttons: {
+      up: {
+        title: `${rock.upTitle} (+${rock.stepM}m)`,
+        act: () => rock.adjust(rock.stepM),
+        hold: true,
+      },
+      down: {
+        title: `${rock.downTitle} (-${rock.stepM}m)`,
+        act: () => rock.adjust(-rock.stepM),
+        hold: true,
+      },
+      reset: { title: rock.resetTitle, act: rock.reset },
+    },
+  };
+}
diff --git a/B06_Section/B06_Section_UI_Cross_Revetment.ts b/B06_Section/B06_Section_UI_Cross_Revetment.ts
index d664d6bdd..7164088df 100644
--- a/B06_Section/B06_Section_UI_Cross_Revetment.ts
+++ b/B06_Section/B06_Section_UI_Cross_Revetment.ts
@@ -22,7 +22,7 @@ import {
   FILL_SLOPE_RATIO_MIN,
   PIPE_WALL_DEFAULT_RUN_M,
   REVET_EMBED_DEPTH_M,
-  REVET_THICKNESS_M,
+  REVET_FILL_TOP_M,
   WALL_MIN_PURE_HEIGHT_M,
 } from "./logic/B06_Section_UI_Cross_Culvert_Const";
 import { outlineLeanOf } from "./logic/B06_Section_UI_Cross_Lean";
@@ -208,7 +208,7 @@ export function computeRevetmentLayout(
   });
   const roadSlope = roadSlopePerOutward(design, side, outward);
   const autoOffset =
-    edge.offset_m + outward * (fillWallBaseWidth(height, lean) / 2 - REVET_THICKNESS_M / 2);
+    edge.offset_m + outward * (fillWallBaseWidth(height, lean) / 2 - REVET_FILL_TOP_M);
   // x 원점 = 성토사면(1:1.2) 경사길이 4m 지점 — 저장된 x 의 절대 자리 그대로(79b).
   const autoRun = PIPE_WALL_DEFAULT_RUN_M;
   /**
@@ -285,7 +285,7 @@ export function computeRevetmentLayout(
   const walls: WallLayout[] = [tier1, ...extras.walls];
   // 물빼기 파이프 단면 = 표 형상칸.weep(322-1 · 옹벽)
   if (catalogRow(spec.type_id)?.shapeOpts.weep) for (const wall of walls) wall.retaining = true;
-  const jt = tier1.topJoint;
+  const jt = tier1.fillTop;
   // 노견 → (물매를 탄 노견 연장) → 벽 이음선 상단점. 연장 구간은 노면 물매 그대로 가고,
   // 꺾임점에서 성토 물매 1:1.2로 벽 상단에 닿는다(2026-08-29 사용자 확정).
   //   D  = 노견에서 벽 상단까지 바깥 방향 거리, R0 = 노견과 벽 상단의 낙차
diff --git a/B06_Section/B06_Section_UI_Cross_Underdrain.ts b/B06_Section/B06_Section_UI_Cross_Underdrain.ts
index cb41c0033..4b43d4798 100644
--- a/B06_Section/B06_Section_UI_Cross_Underdrain.ts
+++ b/B06_Section/B06_Section_UI_Cross_Underdrain.ts
@@ -2,8 +2,9 @@
  * B06_Section_UI_Cross_Underdrain.ts
  * 맹암거 횡단 형상(288-1 · 요구 183-3).
  *
- *   · 노면 = 설계 노면 — 서버 · TS 짝이 암거 경사로 지대 낮은 쪽 한 경사로 기울여 냄 · 측구 없음.
- *   · 옵셋선 = 노면을 암거 높이만큼 아래로 같은 각도.
+ *   · 노면 = 설계 노면 — 서버 · TS 짝이 표준 경사로 지대 낮은 쪽 한 경사로 기울여 냄 · 측구 없음.
+ *   · 옵셋선(하단 경계) = 높은 쪽 노면 끝에서 암거 높이 아래 · 암거 경사로 낮은 쪽으로 내림(371-3) ·
+ *     경사가 비면 노면과 같은 각도.
  *   · 성토 쪽 = 옵셋선을 성토 사면과 만날 때까지 · 절토 쪽 = 절토 사면을 아래로 늘여 옵셋선과 만남.
  *   · 양측절토(낮은 쪽 늘인 노면 `tilt_reach`) = 늘인 노면이 원지반과 만나는 점에서 수직으로 끊음(356-1).
  *   · 노면 · 양쪽 선 · 옵셋선이 둘러싼 안 = 돌 무늬(306-1) — 켜마다 반 칸 엇갈리고 이웃과 겹친 돌 ·
@@ -42,16 +43,18 @@ export function drawCrossedStones(group: SVGElement, frame: BandFrame, heightM:
 
 type Edge = { offset_m: number; elevation_m: number };
 
+/** 하단 경계(옵셋선) — 표고 = `z0 + grade · (o − o0)`. */
+type Bottom = { o0: number; z0: number; grade: number };
+
 /** 한쪽 둘레(노면 끝 → 옵셋선과 만나는 자리) — `outward` = 바깥 부호(+1 좌 · −1 우). */
 function sidePath(
   edge: Edge,
   outward: 1 | -1,
   line: readonly Edge[],
-  roadGrade: number,
-  heightM: number,
+  bottom: Bottom,
 ): OffsetPoint[] {
   const start = { offset: edge.offset_m, elevation: edge.elevation_m };
-  const offZ = (o: number) => edge.elevation_m + roadGrade * (o - edge.offset_m) - heightM;
+  const offZ = (o: number) => bottom.z0 + bottom.grade * (o - bottom.o0);
   const outside = line
     .filter((p) => (p.offset_m - edge.offset_m) * outward > 1e-6)
     .sort((a, b) => (a.offset_m - b.offset_m) * outward);
@@ -60,7 +63,8 @@ function sidePath(
   if (first.elevation_m >= edge.elevation_m) {
     // 절토 — 사면을 안쪽 아래로 늘여 옵셋선과 만남
     const k = (first.elevation_m - edge.elevation_m) / (first.offset_m - edge.offset_m);
-    const d = Math.abs(k - roadGrade) < 1e-9 ? 0 : -heightM / (k - roadGrade);
+    const g = bottom.grade;
+    const d = Math.abs(k - g) < 1e-9 ? 0 : (offZ(edge.offset_m) - edge.elevation_m) / (k - g);
     const offset = edge.offset_m + d;
     return [start, { offset, elevation: offZ(offset) }];
   }
@@ -83,25 +87,38 @@ function sidePath(
   return path;
 }
 
+/** 하단 경계 — 높은 쪽(상류) 노면 끝 − 높이에서 암거 경사로 낮은 쪽으로 내림(371-3) · 경사가 비면 노면과 평행. */
+function bottomOf(left: Edge, right: Edge, heightM: number, slopePct: number | null): Bottom {
+  const roadGrade = (left.elevation_m - right.elevation_m) / (left.offset_m - right.offset_m);
+  const high = left.elevation_m >= right.elevation_m ? left : right;
+  const low = high === left ? right : left;
+  const grade =
+    slopePct && slopePct > 0
+      ? (Math.sign(low.offset_m - high.offset_m) * -slopePct) / 100
+      : roadGrade;
+  return { o0: high.offset_m, z0: high.elevation_m - heightM, grade };
+}
+
 /** 맹암거 형상 둘레 — 좌 노면 끝 → 우 노면 끝 → 우 둘레 → 옵셋선 → 좌 둘레(위로). 높이 없으면 null. */
 export function underdrainOutline(
   design: CrossDesign,
   heightM: number | null,
+  slopePct: number | null = null,
 ): OffsetPoint[] | null {
   const edges = design.road_edges;
   if (!edges || !(heightM && heightM > 0)) return null;
   const { left, right } = edges;
   const span = left.offset_m - right.offset_m;
   if (!(Math.abs(span) > 1e-9)) return null;
-  const grade = (left.elevation_m - right.elevation_m) / span;
+  const bottom = bottomOf(left, right, heightM, slopePct);
   // 양측절토(356-1) — 낮은 쪽 늘인 노면이 원지반과 만나는 점(tilt_reach)에서 끊음 · 너머 점 거름 → 꼬리가 수직으로 닫음
   const reach = design.tilt_reach;
   const outward = reach?.side === "left" ? 1 : -1;
   const line = (design.design_line ?? []).filter(
     (p) => !reach || (p.offset_m - reach.offset_m) * outward <= 1e-6,
   );
-  const leftPath = sidePath(left, 1, line, grade, heightM);
-  const rightPath = sidePath(right, -1, line, grade, heightM);
+  const leftPath = sidePath(left, 1, line, bottom);
+  const rightPath = sidePath(right, -1, line, bottom);
   return [
     { offset: left.offset_m, elevation: left.elevation_m },
     ...rightPath,
@@ -117,7 +134,7 @@ export function appendUnderdrainOverlay(
   x: (offset: number) => number,
   y: (elevation: number) => number,
 ): SVGGElement | null {
-  const outline = spec ? underdrainOutline(design, spec.height_m) : null;
+  const outline = spec ? underdrainOutline(design, spec.height_m, spec.slope_pct) : null;
   if (!spec || !outline) return null;
   const px = (p: OffsetPoint): [number, number] => [x(p.offset), y(p.elevation)];
   const points = outline.map((p) => px(p).join(",")).join(" ");
@@ -136,15 +153,19 @@ export function appendUnderdrainOverlay(
   clip.append(clipShape);
   const stones = document.createElementNS(SVG_NS, "g");
   stones.setAttribute("clip-path", `url(#${clipId})`);
-  const height = spec.height_m!;
   const offsets = outline.map((p) => p.offset);
   const [lo, hi] = [Math.min(...offsets), Math.max(...offsets)];
   const { left, right } = design.road_edges;
   const grade = (left.elevation_m - right.elevation_m) / (left.offset_m - right.offset_m);
   const roadZ = (o: number) => left.elevation_m + grade * (o - left.offset_m);
+  const bottom = bottomOf(left, right, spec.height_m!, spec.slope_pct);
+  const bottomZ = (o: number) => bottom.z0 + bottom.grade * (o - bottom.o0);
+  // 돌 띠 = 노면 ~ 하단 경계(두께가 자리마다 다름 · 켜 수는 두꺼운 쪽)
+  const height = Math.max(roadZ(lo) - bottomZ(lo), roadZ(hi) - bottomZ(hi), spec.height_m!);
   const at = (u: number, v: number): OffsetPoint => {
     const offset = lo + (hi - lo) * u;
-    return { offset, elevation: roadZ(offset) - height * (v + 0.5) };
+    const top = roadZ(offset);
+    return { offset, elevation: top + (bottomZ(offset) - top) * (v + 0.5) };
   };
   const [ax, ay] = px(at(0, 0));
   const [bx, by] = px(at(1, 0));
diff --git a/B06_Section/B06_Section_UI_Cross_View.ts b/B06_Section/B06_Section_UI_Cross_View.ts
index 9cea10b17..c4acae6b0 100644
--- a/B06_Section/B06_Section_UI_Cross_View.ts
+++ b/B06_Section/B06_Section_UI_Cross_View.ts
@@ -32,6 +32,7 @@ import {
   appendCrossDesignOverlay,
   appendPavementOverlay,
   appendRockBoundaryOverlay,
+  rockCellSpec,
   type RockBoundaryControl,
 } from "./B06_Section_UI_Cross_Design";
 import { appendCardFooter, appendCardHeader } from "./B06_Section_UI_Cross_Card_Chrome";
@@ -202,6 +203,7 @@ export function createCrossSectionCard(
   const culvertState = emptyCardCulvertState();
   /** 보라 선 고름(137-2) — 고름은 페이지 한 칸(`_Cross_Design_Pick`) · 강조는 그린 뒤 붙음. */
   let setLineActive: (index: number | null) => void = () => undefined;
+  let linePick: DesignLinePick | null = null;
   const dropLine = (): void => {
     setPickedLine(section.station_id, null);
     setLineActive(null);
@@ -413,7 +415,6 @@ export function createCrossSectionCard(
     const toDisplayY = (elevation: number): number =>
       y(elevationMid + (elevation - elevationMid) * exaggeration);
     appendGroundProfile(plotLayer, drawSamples, x, toDisplayY);
-    let linePick: DesignLinePick | null = null;
 
     if (section.design) {
       // 면적 밴드는 지면선 위·설계선 아래에 깔아 선이 밴드에 가리지 않게 한다.
@@ -607,8 +608,12 @@ export function createCrossSectionCard(
         x,
         toDisplayY,
         onPick: pickLine,
-        // 고른 선 쪽 노견 확장(139-6) · 소단 높이(194-1) · 조각 키(194-2) — 카드 버튼과 같은 창구
-        ...designLineMoves(section, onDesignChange),
+        // 고른 선 쪽 노견 확장(139-6) · 소단 높이(194-1) · 조각 키(194-2) · 암(370-3) — 카드 버튼과 같은 창구
+        ...designLineMoves(
+          section,
+          onDesignChange,
+          rockBoundary && rockCellSpec(section, rockBoundary),
+        ),
       });
       setLineActive = linePick.setActive;
       setLineActive(pickedLineAt(section.station_id));
@@ -679,9 +684,7 @@ export function createCrossSectionCard(
       fit: () => stationWidth.request(section.chainage_m, crossHalfWidth ?? maxOffset),
     };
     const zoomBar = buildZoomControls(zoomPan, widthActions);
-    if (linePick) zoomBar.prepend(linePick.label); // 치수 = [+ − ⤢] 왼쪽(137-2)
     chartWrap.append(svg, readout.root, zoomBar, panel.root);
-    if (linePick) chartWrap.append(linePick.panel); // 사면 이동 패널(151-3)
     for (const panel of bodies.panels) chartWrap.append(panel.root);
     if (activeArea) {
       setBandActive(activeArea);
@@ -690,6 +693,6 @@ export function createCrossSectionCard(
     card.append(chartWrap);
   }
 
-  appendCardFooter(card, section, rockBoundary, cutSlope);
+  appendCardFooter(card, section, rockBoundary, cutSlope, linePick?.cell); // 왼쪽 = 선 공용 칸(370-3)
   return card;
 }
diff --git a/B06_Section/B06_Section_UI_Cross_Wall.ts b/B06_Section/B06_Section_UI_Cross_Wall.ts
index 2acbf3b55..ae56ba825 100644
--- a/B06_Section/B06_Section_UI_Cross_Wall.ts
+++ b/B06_Section/B06_Section_UI_Cross_Wall.ts
@@ -14,6 +14,7 @@ import {
   REVET_EMBED_DEPTH_M,
   REVET_LEAN_RATIO,
   REVET_THICKNESS_M,
+  WALL_FILL_TOP_INSET_M,
   WALL_MIN_PURE_HEIGHT_M,
 } from "./logic/B06_Section_UI_Cross_Culvert_Const";
 import type { RevetMaterial } from "./logic/B06_Section_UI_Cross_Culvert_Const";
@@ -104,6 +105,7 @@ export function buildRevetWallGeometry(input: RevetWallGeometryInput): WallLayou
     outward,
     topBack,
     topJoint: { offset: topJoint, elevation: topElevation },
+    fillTop: { offset: topFront - outward * WALL_FILL_TOP_INSET_M, elevation: topElevation },
     bottomBack,
     bottomFront,
     points: [bottomBack, topBack, { offset: topFront, elevation: topElevation }, bottomFront],
diff --git a/B06_Section/B06_Section_UI_Page_Design_Sync.ts b/B06_Section/B06_Section_UI_Page_Design_Sync.ts
index fa04f3326..590837950 100644
--- a/B06_Section/B06_Section_UI_Page_Design_Sync.ts
+++ b/B06_Section/B06_Section_UI_Page_Design_Sync.ts
@@ -7,6 +7,7 @@
  *   - `reconcileStaleDesigns`: 낡은 design 일괄 재계산(B05 와 같은 창구)
  *   - `syncBermSpans`        : 구조물 목록의 소단을 세션 사본으로 펴기
  *   - `applyPanelToAll`      : 표준 횡단면 설정 [전체 반영]
+ * 고친 뒤 계산 묶음 cross 입력도 다시(`pipelineCross` · 노선 초안 동안 카드 = 묶음 새 노선 상세 · 365-2).
  * ========================================================================== */
 
 import {
@@ -28,6 +29,7 @@ import type { CrossDesignChange, SectionViewController } from "./B06_Section_UI_
 import type { StructureInstance } from "../B05_Profile/B05_Profile_Api_Structures";
 import { setCrossDetailHost } from "./B06_Section_UI_Cross_Detail";
 import { useStructureIds } from "./B06_Section_Station_Keys";
+import { pipelineCross } from "../A00_Common/design/design_pipeline_page";
 
 export interface DesignSyncContext {
   projectId: string | null;
@@ -125,6 +127,7 @@ export function createDesignSync(ctx: DesignSyncContext): DesignSyncController {
       .detail()
       ?.cross_sections.find((section) => Math.abs(section.chainage_m - chainageM) < 0.01)?.design;
     if (design && design.ground_type !== "soil") void reconcileStaleDesigns({ force: true });
+    else if (projectId) pipelineCross(projectId);
   }
 
   /**
@@ -184,6 +187,7 @@ export function createDesignSync(ctx: DesignSyncContext): DesignSyncController {
       const detail = error instanceof Error ? ` ${error.message}` : "";
       showToast(`${L("B06_Design_Failed")}${detail}`, "error");
     }
+    pipelineCross(projectId); // 세션 고침 · 표준 → 묶음(같은 입력이면 안 셈)
   }
 
   /**
diff --git a/B06_Section/B06_Section_UI_Page_Station_Swap.ts b/B06_Section/B06_Section_UI_Page_Station_Swap.ts
index 9f9632cea..e3abf001b 100644
--- a/B06_Section/B06_Section_UI_Page_Station_Swap.ts
+++ b/B06_Section/B06_Section_UI_Page_Station_Swap.ts
@@ -6,6 +6,8 @@
  * 종단 보기도 같은 가게를 듣고 같은 함수를 부름 — 먼저 부른 쪽이 갈아끼우고 다음 쪽은 「같은 목록」.
  * 노선 초안 동안(346-2 덧 3) 카드 = 묶음 새 노선 상세(`pipelineDetail` · cross 단계 결과) — 새 상세가 오면
  * 같은 길로 다시 그림 · 초안을 버리면(상세 null) 저장 노선 카드로.
+ * 묶음 차례는 cross 뒤에만 다시 그림(profile 뒤 중간 상세는 안 그림 · 365-4) — 겹친 신호(갈아끼움 · 묶음 · 초안)는
+ * 횡단 보기 다시 읽기가 한 번으로 묶음(`design_view_cross` refreshDetailForStructures · 최신 차례만).
  * ========================================================================== */
 
 import { useDesignStore } from "../A00_Common/design/design_store";
@@ -42,7 +44,7 @@ export function followSwaps(
   };
 }
 
-/** 묶음 새 노선 상세가 바뀌면(profile · cross 단계 뒤) 부름 — 묶음은 종단 보기가 세우므로 차례 번호가 날 때 붙음. */
+/** 묶음 새 노선 상세가 바뀌면(cross 단계 뒤) 부름 — 묶음은 페이지가 세우므로 차례 번호가 날 때 붙음. */
 function followDraftDetail(projectId: string, changed: () => void): () => void {
   let pipe: DesignPipeline | null = null;
   let stopPipe = (): void => undefined;
@@ -54,8 +56,7 @@ function followDraftDetail(projectId: string, changed: () => void): () => void {
     pipe = now;
     stopPipe =
       now?.subscribe((event) => {
-        if (event.kind !== "stage" || (event.stage !== "profile" && event.stage !== "cross"))
-          return;
+        if (event.kind !== "stage" || event.stage !== "cross") return;
         const next = pipelineDetail(projectId);
         if (next === drawn) return;
         drawn = next;
diff --git a/B06_Section/B06_Section_UI_Style_Cross.css b/B06_Section/B06_Section_UI_Style_Cross.css
index 6db6dc2e9..7f6983c94 100644
--- a/B06_Section/B06_Section_UI_Style_Cross.css
+++ b/B06_Section/B06_Section_UI_Style_Cross.css
@@ -640,6 +640,38 @@ html.is-bm-route .b06-section__notice-bar {
   padding: 1px 4px;
 }
 
+/* 선 공용 칸(370-3) — 고른 선 제목 · 버튼 · 값 한 줄(넘치면 말줄임) · 빈 칸도 자리(띠 높이) 그대로. */
+.b06-cross-card__linecell {
+  flex: 0 1 auto;
+  min-width: 0;
+}
+
+.b06-cross-card__linecell.is-empty {
+  visibility: hidden;
+}
+
+.b06-cross-card__linecell .b06-design__seg-buttons {
+  min-width: 0;
+}
+
+.b06-cross-card__linecell .b06-design__rockb-readout {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.b06-cross-card__linecell .b06-design__rockb-btn {
+  flex: 0 0 auto;
+  border-left: none;
+}
+
+.b06-cross-card__linecell
+  .b06-design__rockb-btn:not([hidden])
+  ~ .b06-design__rockb-btn:not([hidden]) {
+  border-left: 1px solid var(--color-border);
+}
+
 /* 측점별 암 절토 경사(2026-09-07) — 행의 **오른쪽 끝**(암 경계 = 왼쪽). */
 .b06-cross-card__cutslope {
   margin-left: auto;
diff --git a/B06_Section/B06_Section_UI_Style_Cross_Areas.css b/B06_Section/B06_Section_UI_Style_Cross_Areas.css
index b3fff596b..0fe12440b 100644
--- a/B06_Section/B06_Section_UI_Style_Cross_Areas.css
+++ b/B06_Section/B06_Section_UI_Style_Cross_Areas.css
@@ -193,6 +193,24 @@
   cursor: ew-resize;
 }
 
+/* 교차점 손잡이(370-2) — 사면 ∩ 원지반 작은 원 · 늘 보임 · 고르면 채움. */
+.b06-chart__toe-hit {
+  fill: var(--color-surface);
+  stroke: var(--color-royal-amethyst);
+  stroke-width: 1.5;
+}
+
+.b06-chart__toe-hit.is-active {
+  fill: var(--color-royal-amethyst);
+  cursor: pointer;
+}
+
+/* 암 경계선 고름(370-3) — 점선 위 투명 판정 선 · 고르면 경고색 띠 · 세로 끌기. */
+.b06-chart__design-hit.b06-chart__rock-hit.is-active {
+  stroke: color-mix(in srgb, var(--color-warning) 40%, transparent);
+  cursor: ns-resize;
+}
+
 /* 차도·노견 경계 짧은 수직 틱(N-4-2) — 설계선과 같은 계열, 얇게. */
 .b06-chart__carriageway-tick {
   stroke: var(--color-royal-amethyst);
diff --git a/B06_Section/B06_Section_UI_Style_Cross_Controls.css b/B06_Section/B06_Section_UI_Style_Cross_Controls.css
index 778418876..ac2a795b3 100644
--- a/B06_Section/B06_Section_UI_Style_Cross_Controls.css
+++ b/B06_Section/B06_Section_UI_Style_Cross_Controls.css
@@ -223,7 +223,7 @@
   background: color-mix(in srgb, var(--color-surface-raised) 88%, transparent);
 }
 
-/* 고른 보라 선 치수(137-2) — 카드 폭 무관 늘 [+ − ⤢] 왼쪽(179-1) · 두 줄(151-1 · 길이 · 경사비율 / 수평 · 높이). */
+/* 고른 선 치수(137-2) — 상세 모달 줌 막대 왼쪽(179-1) · 두 줄(151-1) · 카드는 아래 띠 공용 칸(370-3). */
 .b06-cross-card__line-dims {
   align-self: center;
   padding: 1px var(--spacing-4);
diff --git a/B06_Section/logic/B06_Section_Cross_Enforce.ts b/B06_Section/logic/B06_Section_Cross_Enforce.ts
index 6eec745e3..8976ddb5b 100644
--- a/B06_Section/logic/B06_Section_Cross_Enforce.ts
+++ b/B06_Section/logic/B06_Section_Cross_Enforce.ts
@@ -63,8 +63,9 @@ export function facilityRanges(
     const depth = num(spec.overflow_depth_m) ?? 0;
     if (spec.type === "ford" && depth > 0) drops.push([at, depth]);
   }
+  // 노면 = 표준 경사 · 암거 경사는 맹암거 하단 경계만(371-3 · 파이썬 `tilt_ranges` 짝)
   for (const drain of underdrainSpecsFrom(structures))
-    tilt.push([drain.chainage_m, drain.chainage_m, drain.slope_pct]);
+    tilt.push([drain.chainage_m, drain.chainage_m, null]);
   return { paved, tilt, drops };
 }
 
diff --git a/B06_Section/logic/B06_Section_UI_Cross_Culvert_Const.ts b/B06_Section/logic/B06_Section_UI_Cross_Culvert_Const.ts
index 12191aff8..dcc50e510 100644
--- a/B06_Section/logic/B06_Section_UI_Cross_Culvert_Const.ts
+++ b/B06_Section/logic/B06_Section_UI_Cross_Culvert_Const.ts
@@ -31,6 +31,12 @@ export const REVET_LEAN_RATIO = 0.3;
 /** 사다리꼴(배면부) 상단 폭(m) — 띠 두께의 절반(2026-08-20 사용자 확정). */
 export const REVET_TRAP_TOP_M = REVET_THICKNESS_M / 2;
 
+/** 성토 위 이음 = 벽 윗면 사면 쪽 끝에서 이만큼 안(m · 371-1). */
+export const WALL_FILL_TOP_INSET_M = 0.1;
+
+/** 배면에서 성토 위 이음까지 수평거리(m) — 윗면 1.5t − 0.1(371-1). */
+export const REVET_FILL_TOP_M = REVET_THICKNESS_M * 1.5 - WALL_FILL_TOP_INSET_M;
+
 /**
  * 집수정 상부 여유(m) — 관 상단에서 집수정 벽 상단까지의 간격. 관 벽(유입·유출)은
  * 여유 없이 벽 윗면 = 관 윗면(139-1 · `revetTargetHeight`).
diff --git a/B06_Section/logic/B06_Section_UI_Cross_Culvert_Solve.ts b/B06_Section/logic/B06_Section_UI_Cross_Culvert_Solve.ts
index db9a03ed9..28bb3f116 100644
--- a/B06_Section/logic/B06_Section_UI_Cross_Culvert_Solve.ts
+++ b/B06_Section/logic/B06_Section_UI_Cross_Culvert_Solve.ts
@@ -11,7 +11,7 @@ import {
   FILL_SLOPE_RATIO_MIN,
   REVET_LEAN_RATIO,
   REVET_THICKNESS_M,
-  REVET_TRAP_TOP_M,
+  REVET_FILL_TOP_M,
 } from "./B06_Section_UI_Cross_Culvert_Const";
 import type {
   EndFace,
@@ -144,10 +144,10 @@ export interface FillSlopeSegment {
  * 접점이 다시 어긋난다.
  */
 export function fillSlopeOf(
-  wall: { role: "inlet" | "outlet" | "extra"; topJoint: OffsetPoint; outward: number },
+  wall: { role: "inlet" | "outlet" | "extra"; fillTop: OffsetPoint; outward: number },
   edge: { offset_m: number; elevation_m: number },
 ): FillSlopeSegment {
-  const to = wall.topJoint;
+  const to = wall.fillTop;
   const rise = edge.elevation_m - to.elevation;
   const edgePoint: OffsetPoint = { offset: edge.offset_m, elevation: edge.elevation_m };
   if (!(rise > 1e-6)) {
@@ -244,7 +244,7 @@ export function minShoulderWallOffset(
     const offset = edge.offset_m + outward * ((span * i) / steps);
     const rise = edge.elevation_m - (baseAt(offset) + height);
     if (rise < FILL_MIN_RISE_M) continue;
-    const joint = offset - outward * (fillWallBaseWidth(height, lean) / 2 - REVET_TRAP_TOP_M);
+    const joint = offset - outward * (fillWallBaseWidth(height, lean) / 2 - REVET_FILL_TOP_M);
     if (((joint - edge.offset_m) * outward) / rise < FILL_SLOPE_RATIO_MIN) continue;
     if ((offset - toeOffset) * outward > 1e-6) {
       const toeRise = edge.elevation_m - (baseAt(toeOffset) + height);
diff --git a/B06_Section/logic/B06_Section_UI_Cross_Fit.ts b/B06_Section/logic/B06_Section_UI_Cross_Fit.ts
index 305ab66ec..0b4250e69 100644
--- a/B06_Section/logic/B06_Section_UI_Cross_Fit.ts
+++ b/B06_Section/logic/B06_Section_UI_Cross_Fit.ts
@@ -10,6 +10,8 @@
  *
  * 설계선이 지반과 만나기 전에 끝나면(계산 반폭 밖) **추세로 외삽**한다 — 끝단의 사면
  * 기울기와 지반 기울기 차이로 만나는 자리를 추정한다.
+ *
+ * 교차점 손잡이 자리(`toePoints`) · 사면 이동 멈춤(`extendStop`)도 여기(370-2).
  * ========================================================================== */
 
 import type { CrossDesign, CrossSection } from "../B06_Section_Api_Fetch";
@@ -56,6 +58,60 @@ export function toeOffsets(section: CrossSection): { left: number | null; right:
   return out;
 }
 
+/** 교차점 손잡이 자리(370-2) — `toeOffsets` 자리 · 표고 = 원지반. 못 만난 쪽은 null. */
+export function toePoints(
+  section: Pick<CrossSection, "design" | "samples">,
+): Record<"left" | "right", { offset_m: number; elevation_m: number } | null> {
+  if (!section.samples?.length) return { left: null, right: null };
+  const toes = toeOffsets(section as CrossSection);
+  const groundAt = groundInterpolator(section.samples);
+  const at = (offset: number | null) =>
+    offset === null || !groundAt ? null : { offset_m: offset, elevation_m: groundAt(offset) };
+  return { left: at(toes.left), right: at(toes.right) };
+}
+
+/** 멈춤 탐색 간격(m) — 사면 이동 걸음(0.1 m)보다 촘촘하게. */
+const STOP_SCAN_M = 0.01;
+
+/**
+ * 사면 이동 멈춤(370-2) — 그 쪽 노견 확장 `now` → `next` 사이에서 옮긴 노견 끝이 원지반과 딱 만나는
+ * (절토도 성토도 아닌) 확장값. 원지반 − 노면 평면(`road_edges` 두 점을 이은 선) 부호가 바뀌는 자리를
+ * 보간 · 못 찾거나 지금 그 자리면 `next` 그대로. 0.001 m 반올림.
+ */
+export function extendStop(
+  samples: CrossSection["samples"],
+  edges: CrossDesign["road_edges"] | undefined,
+  side: "left" | "right",
+  now: number,
+  next: number,
+): number {
+  const groundAt = groundInterpolator(samples ?? []);
+  if (!groundAt || !edges || edges.left.offset_m === edges.right.offset_m) return next;
+  const { left, right } = edges;
+  const plane = (o: number) =>
+    right.elevation_m +
+    ((left.elevation_m - right.elevation_m) * (o - right.offset_m)) /
+      (left.offset_m - right.offset_m);
+  const sign = side === "left" ? 1 : -1;
+  const base = Math.abs(edges[side].offset_m) - now; // 확장 0 노견 끝 거리
+  const gapAt = (extend: number) => {
+    const o = sign * (base + extend);
+    return groundAt(o) - plane(o);
+  };
+  let previous = gapAt(now);
+  if (Math.abs(previous) < 1e-4) return next;
+  const steps = Math.max(1, Math.ceil(Math.abs(next - now) / STOP_SCAN_M));
+  for (let i = 1; i <= steps; i += 1) {
+    const a = now + ((next - now) * (i - 1)) / steps;
+    const b = now + ((next - now) * i) / steps;
+    const gap = gapAt(b);
+    if (gap === 0 || Math.sign(gap) !== Math.sign(previous))
+      return Math.round((a + ((b - a) * previous) / (previous - gap)) * 1000) / 1000;
+    previous = gap;
+  }
+  return next;
+}
+
 /**
  * 성토측 사면의 **본래** 경사길이(m) — 성토가 아닌 측은 null (2026-09-03 사용자 지시).
  *
diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_CulvertNote.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_CulvertNote.py
index d8f3038f4..2406f9922 100644
--- a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_CulvertNote.py
+++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_CulvertNote.py
@@ -7,7 +7,7 @@ B06 [상세] 모달을 한 번도 안 연 측점(칸 = 없음)에 B07 이 같은
 (빈 엔티티)은 덮지 않음 · 옛 글(`structure_note`)이 있으면 옛 글이 먼저
 (모달이 처음 열 때 옮기는 차례와 같음).
 그림 = 관 주인 측점 원형 마크(배수관 · Φ · L 정수) + 측점 · 그 측점 구조물마다 지정된
-구조물 조합 이름 줄(미지정 = 「이름 조합 미지정」) + 그 구조물 좌측 패널 옵션 줄(166-1).
+구조물 조합 이름 줄(미지정 = 종류 이름만) + 그 구조물 좌측 패널 옵션 줄(166-1).
 옵션 줄은 파이썬으로 다시 짜지 않음 — 화면과 같은 TS(`structureOptionLines`)를 Node
 진입점(`B07_DesignDetail_Note_Options_Node.ts` · CLAUDE.md 5장 ②)으로 돌려 받음 ·
 실패는 비치명(조합 줄만).
@@ -109,10 +109,11 @@ def things_at(things: list[Thing], chainage_m: float) -> list[Thing]:
 def structure_note_lines(things: list[Thing], chainage_m: float) -> list[str]:
     """구조물 조합 줄 — TS `structureNoteLines` 짝.
 
-    본체 → 그룹 차례 · 같은 이름 한 줄 · 미지정 = 「이름 조합 미지정」 · 배관 본체 뺌 ·
+    본체 → 그룹 차례 · 같은 이름 한 줄 · 미지정 = 종류 이름만(같은 측점 같은 종류 한 줄) · 배관 본체 뺌 ·
     이어서 그 구조물 좌측 패널 옵션 줄(`option_lines` · 166-1).
     """
     lines: list[str] = []
+    kinds: set[str] = set()
     for thing in things_at(things, chainage_m):
         own = _summary_item(thing.get("summary_item"))
         slots = ([("", own)] if own else []) + _group_items(thing.get("group_items"))
@@ -123,8 +124,9 @@ def structure_note_lines(things: list[Thing], chainage_m: float) -> list[str]:
         ]
         if slots:
             lines += list(dict.fromkeys(names))
-        elif not thing["pipe"]:
-            lines.append(f"{thing['name']} 조합 미지정")
+        elif not thing["pipe"] and thing["name"] not in kinds:
+            kinds.add(thing["name"])
+            lines.append(thing["name"])
         lines += [str(line) for line in thing.get("option_lines") or []]
     return lines
 
diff --git a/B08_Quantity/B08_Quantity_Milestone_Calc.ts b/B08_Quantity/B08_Quantity_Milestone_Calc.ts
index ece7882e5..8266f7ce6 100644
--- a/B08_Quantity/B08_Quantity_Milestone_Calc.ts
+++ b/B08_Quantity/B08_Quantity_Milestone_Calc.ts
@@ -125,8 +125,10 @@ export interface Leg {
   road: Road | null;
   /** 사용자 값 — 있으면 우선 */
   km: number | null;
-  /** [길찾기] 자동 값(km 만 저장 · 경로 좌표 · 응답은 저장 안 함) */
+  /** [길찾기] 자동 값 */
   auto_km?: number | null;
+  /** 마지막 [길찾기] 길 선 [위도, 경도](373 · 소수 5자리 · 점 줄임 · 구간 첫 줄만) — 수기 · 다시 이음 = 없음 */
+  path?: Array<[number, number]> | null;
 }
 
 export interface MilestoneRow {
diff --git a/B08_Quantity/B08_Quantity_Milestone_Layout.ts b/B08_Quantity/B08_Quantity_Milestone_Layout.ts
index a07c8f8c5..e7af11443 100644
--- a/B08_Quantity/B08_Quantity_Milestone_Layout.ts
+++ b/B08_Quantity/B08_Quantity_Milestone_Layout.ts
@@ -284,6 +284,15 @@ export function chainOf(data: MilestoneData, to: string): MilestoneBase[] {
   return out;
 }
 
+/** 시점까지 이어짐(373) — from(거래처 · 기준점 id)이 이어졌고 사슬 끝 기준점이 시점에 닿음 */
+export function reachesSite(data: MilestoneData, from: string): boolean {
+  const owner = ownerOf(data, from);
+  if (!owner || owner.linked === false) return false;
+  if (owner.to === TO_SITE) return true;
+  const chain = chainOf(data, owner.to);
+  return chain.length > 0 && chain[chain.length - 1].to === TO_SITE;
+}
+
 /** 돌기(254) — 기준점 from 을 to 에 이으면 to 사슬이 from 으로 돌아옴(A → B → A · 이음 여부 무관) */
 export function makesLoop(data: MilestoneData, from: string, to: string): boolean {
   const seen = new Set<string>();
diff --git a/B08_Quantity/B08_Quantity_Router_Milestone.py b/B08_Quantity/B08_Quantity_Router_Milestone.py
index 793e45621..1d6ec27d5 100644
--- a/B08_Quantity/B08_Quantity_Router_Milestone.py
+++ b/B08_Quantity/B08_Quantity_Router_Milestone.py
@@ -18,7 +18,8 @@
            지금 중점 측점(244-12 · 상자 작은 글씨)
     POST   /api/projects/{id}/quantity/milestone/directions      [길찾기](244-7) — 두 좌표 → 카카오
            길찾기 → km(소수 1자리) · 실패 · 키 없음 = 까닭 한 줄(서버 단독 · 키 서버만 · 저장 안 함)
-           + 경로 좌표 [위도, 경도] 목록(244-9 · 카카오 지도 길 선 · 그때그때 · 저장 안 함)
+           + 경로 좌표 [위도, 경도] 목록(244-9 · 카카오 지도 길 선 · 소수 5자리 · 점 줄임 ·
+           373 화면이 구간 `legs[].path` 로 캐시 → [저장])
     GET    /api/projects/{id}/quantity/milestone/reverse?lon=&lat=  지도에서 고른 소재지(244-13) →
            VWorld 주소 한 줄(서버 단독 · 저장 안 함 · 못 찾음 = null)
     GET    /api/projects/{id}/quantity/milestone/map-key         카카오 지도 JavaScript 키(244-9 ·
@@ -60,7 +61,7 @@ from uuid import UUID
 
 from fastapi import APIRouter, BackgroundTasks, File, HTTPException, Query, UploadFile
 from fastapi.responses import FileResponse
-from pydantic import BaseModel, Field, ValidationError, model_validator
+from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
 
 from B01_Dashboard.B01_Dashboard_Map import reverse_geocode
 from B02_ProjRegister.B02_ProjRegister_Repository import get_project_by_id
@@ -97,6 +98,7 @@ IMAGE_EXT = (".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp")
 ROUTE_ID = r"^[A-Za-z0-9_-]{1,40}$"
 BOX_IDS = {SITE, "start", "mid"}  # 다이어그램 공사지 상자 id — 기준점 · 경로 id 로 못 씀
 
+PATH_MAX = 500  # 구간 길 선 점 수 상한(점 줄인 뒤)
 Road = Literal["2차포장", "1차포장", "포장", "비포장"]  # 포장 = 기준점 안 거친 구간(244-13)
 Dir = Literal["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
 
@@ -104,7 +106,18 @@ Dir = Literal["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
 class Leg(BaseModel):
     road: Road | None = "2차포장"  # None = 사용자가 안 고름(244-7 · 표에 「도로 구분 고르기」)
     km: float | None = Field(default=None, ge=0, le=10000)  # 사용자 값 — 있으면 우선
-    auto_km: float | None = Field(default=None, ge=0, le=10000)  # [길찾기] 자동 값(km 만 저장)
+    auto_km: float | None = Field(default=None, ge=0, le=10000)  # [길찾기] 자동 값
+    # 373 마지막 [길찾기] 길 선 [위도, 경도](소수 5자리 · 점 줄임) — 구간 첫 줄만 · 수기 = 비움
+    path: list[tuple[float, float]] | None = Field(default=None, max_length=PATH_MAX)
+
+    @field_validator("path")
+    @classmethod
+    def _path(cls, value: list[tuple[float, float]] | None) -> list[tuple[float, float]] | None:
+        if not value:
+            return None
+        if any(not (-90 <= lat <= 90 and -180 <= lon <= 180) for lat, lon in value):
+            raise ValueError("길 선 좌표 범위")
+        return [(round(lat, 5), round(lon, 5)) for lat, lon in value]
 
 
 class Row(BaseModel):
@@ -616,10 +629,51 @@ def directions_km(origin: LonLat, destination: LonLat) -> dict[str, Any]:
     return {"km": math.floor(distance / 100 + 0.5) / 10, "reason": None, "path": path}
 
 
+def _rdp(points: list[tuple[float, float]], eps: float) -> list[tuple[float, float]]:
+    """Douglas-Peucker — 두 끝은 남기고 허용 오차(도) 안 점을 뺌."""
+    keep = [False] * len(points)
+    keep[0] = keep[-1] = True
+    stack = [(0, len(points) - 1)]
+    while stack:
+        a, b = stack.pop()
+        (ay, ax), (by, bx) = points[a], points[b]
+        dx, dy = bx - ax, by - ay
+        norm = math.hypot(dx, dy)
+        far, at = -1.0, -1
+        for i in range(a + 1, b):
+            py, px = points[i]
+            d = (
+                abs(dy * (px - ax) - dx * (py - ay)) / norm
+                if norm
+                else math.hypot(px - ax, py - ay)
+            )
+            if d > far:
+                far, at = d, i
+        if at >= 0 and far > eps:
+            keep[at] = True
+            stack += [(a, at), (at, b)]
+    return [p for p, k in zip(points, keep) if k]
+
+
+def thin_path(path: list[list[float]], limit: int = PATH_MAX) -> list[list[float]]:
+    """길 선 점 줄임 — 소수 5자리 · 같은 점 이어짐 뺌 · 상한 넘으면 허용 오차를 2배씩 키워 줄임."""
+    points: list[tuple[float, float]] = []
+    for lat, lon in path:
+        p = (round(lat, 5), round(lon, 5))
+        if not points or points[-1] != p:
+            points.append(p)
+    eps = 1e-5
+    while len(points) > limit:
+        points = _rdp(points, eps)
+        eps *= 2
+    return [[lat, lon] for lat, lon in points]
+
+
 @router.post(PATH + "/directions")
 async def milestone_directions(project_id: UUID, body: Directions) -> dict[str, Any]:
-    """[길찾기] 한 구간 — 단추 누를 때만(조작 중 자동 호출 없음)."""
-    return await asyncio.to_thread(directions_km, body.origin, body.destination)
+    """[길찾기] 한 구간 — 단추 누를 때만(조작 중 자동 호출 없음) · 길 선은 점 줄여 돌려줌(373)."""
+    got = await asyncio.to_thread(directions_km, body.origin, body.destination)
+    return {**got, "path": thin_path(got["path"])} if got.get("path") else got
 
 
 KAKAO_JS = "KAKAO_JS_KEY"
diff --git a/B08_Quantity/B08_Quantity_UI_Milestone.css b/B08_Quantity/B08_Quantity_UI_Milestone.css
index 09b24921d..7ba848e6b 100644
--- a/B08_Quantity/B08_Quantity_UI_Milestone.css
+++ b/B08_Quantity/B08_Quantity_UI_Milestone.css
@@ -261,7 +261,7 @@
   stroke: var(--color-surface);
   stroke-width: 2;
   cursor: crosshair;
-  opacity: 0.55;
+  opacity: 0.85;
 }
 
 .b08-milestone__box:hover .b08-milestone__connect {
diff --git a/B08_Quantity/B08_Quantity_UI_Milestone_Diagram.ts b/B08_Quantity/B08_Quantity_UI_Milestone_Diagram.ts
index ef0fa6f26..620055f02 100644
--- a/B08_Quantity/B08_Quantity_UI_Milestone_Diagram.ts
+++ b/B08_Quantity/B08_Quantity_UI_Milestone_Diagram.ts
@@ -212,9 +212,9 @@ export function createDiagram(
    *  (to = 기준점 id) · 공사지(시점 · 중점) = 시점으로 바로 · 빈 곳 · 자기 · 같은 연결 = 취소 · 기준점 돌기
    *  (A → B → A) = 취소 + 알림 · 바뀌면 그 구간 새로(km 비움) + 길찾기 한 번(km · 거래처 = 경로 그림) */
   const connectDot = (box: DiagramBox, shift: SVGGElement): SVGCircleElement => {
-    const cx = box.x + 10;
-    const cy = box.y + 10;
-    const dot = svg("circle", { class: "b08-milestone__connect", cx, cy, r: 6 });
+    const cx = box.x + 12;
+    const cy = box.y + 12;
+    const dot = svg("circle", { class: "b08-milestone__connect", cx, cy, r: 9 });
     dot.append(svg("title", {}, "끌어서 기준점 · 공사지에 놓으면 연결"));
     dot.addEventListener("click", (e) => e.stopPropagation()); // 상자 모달 안 뜸
     dot.addEventListener("pointerdown", (down) => {
diff --git a/B08_Quantity/B08_Quantity_UI_Milestone_LegModal.ts b/B08_Quantity/B08_Quantity_UI_Milestone_LegModal.ts
index 881dd86ca..2d873d60a 100644
--- a/B08_Quantity/B08_Quantity_UI_Milestone_LegModal.ts
+++ b/B08_Quantity/B08_Quantity_UI_Milestone_LegModal.ts
@@ -5,7 +5,7 @@
  *   값 = 도로 구분 ▾ · 거리(km) 구간 줄(빈칸 = [길찾기] 자동 값 · 사용자 값 우선 · 244-7)
  *   도로 구분(152 · 254) = 포장 종류는 선 자리로 정함 — → 기준점 = 2차포장 · 기준점 → 시점 = 1차포장 ·
  *     거래처 → 시점 · 시점 → 중점 = 포장 · ▾ 는 그 포장 · 비포장 둘(`roadOptions` · `roadOf`)
- *   아래 = 다음(카카오) 지도 경로(그 구간 두 끝 · 마지막 길찾기 길 선 · 없으면 열 때 한 번 받음 · 자동 그림 없음)
+ *   아래 = 다음(카카오) 지도 경로(그 구간 두 끝 · 저장된 길 선 `legs[0].path` · 없으면 열 때 한 번 받음 · 자동 그림 없음)
  *     거래처 · 기준점 표지 끌어 옮김 = 소재지 고침(좌표 → VWorld 주소) + 그 구간 다시 길찾기 · 시점 = 노선(고정)
  *   기준점 → 시점 = 도로가 안 이어질 수 있음 — 거리 손 입력 · 시점 → 중점 = 늘 손 입력(길찾기 · 지도 없음)
  *   자동 그림(244-11) = 거래처 쪽 구간 [길찾기] · 옮김 때만(`findSegmentKm`)
@@ -51,6 +51,7 @@ export function legsEditor(
     road: HTMLSelectElement;
     km: HTMLInputElement;
     auto: number | null;
+    path: Leg["path"]; // 길 선은 칸에 안 보임 · 그대로 가져감
     orig: number | null; // 안 고친 칸 = 원래 값 그대로(반올림 값으로 안 덮음)
     shown: string;
   }> = [];
@@ -68,7 +69,14 @@ export function legsEditor(
       dist.input.placeholder = fmtKm(auto); // 빈칸 = 자동 값 · 고치면 그 값 우선
       dist.input.title = `자동 값 ${fmtKm(auto)} km`;
     }
-    const ref = { road: road.select, km: dist.input, auto, orig: leg.km, shown: dist.input.value };
+    const ref = {
+      road: road.select,
+      km: dist.input,
+      auto,
+      path: leg.path,
+      orig: leg.km,
+      shown: dist.input.value,
+    };
     rows.push(ref);
     const drop = createButton({
       label: "×",
@@ -96,10 +104,11 @@ export function legsEditor(
   return {
     root: el("div", { children: [list, more] }),
     value: () =>
-      rows.map(({ road, km: dist, auto, orig, shown }) => ({
+      rows.map(({ road, km: dist, auto, path, orig, shown }) => ({
         road: (ROADS as readonly string[]).includes(road.value) ? (road.value as Road) : null,
         km: dist.value === shown ? orig : km(dist.value),
         auto_km: auto,
+        ...(path ? { path } : {}),
       })),
   };
 }
@@ -199,7 +208,7 @@ export function openLegInfo(projectId: string, from: string): void {
         return out;
       };
       const drawMap = (): void => {
-        const path = segmentPath(from);
+        const path = segmentPath(projectId, from);
         map.set(pins(), path.length >= 2 ? [path] : []);
       };
       const run = async (image = true): Promise<void> => {
@@ -268,7 +277,9 @@ export function openLegInfo(projectId: string, from: string): void {
         const fresh = liveMilestone(projectId);
         const target = owner(fresh);
         if (!target) return;
-        target.legs = legs.value().map((l) => (manual.input.checked ? { ...l, auto_km: null } : l));
+        target.legs = legs
+          .value()
+          .map((l) => (manual.input.checked ? { ...l, auto_km: null, path: null } : l));
         target.manual = manual.input.checked;
         putMilestone(projectId, fresh);
         redrawLegs();
@@ -279,7 +290,8 @@ export function openLegInfo(projectId: string, from: string): void {
       showMode();
       drawMap();
       // 길 선이 아직 없으면 열 때 한 번(km 같으면 안 씀 · 자동 그림 없음 · 수기 입력이면 안 함)
-      if (!manual.input.checked && !segmentPath(from).length && seg.from && seg.to) void run(false);
+      if (!manual.input.checked && !segmentPath(projectId, from).length && seg.from && seg.to)
+        void run(false);
     },
   });
 }
diff --git a/B08_Quantity/B08_Quantity_UI_Milestone_Route.ts b/B08_Quantity/B08_Quantity_UI_Milestone_Route.ts
index cc02d0d09..40526113d 100644
--- a/B08_Quantity/B08_Quantity_UI_Milestone_Route.ts
+++ b/B08_Quantity/B08_Quantity_UI_Milestone_Route.ts
@@ -5,6 +5,8 @@
  *
  *   [그림 변경] = 사용자 그림 올림(이 탭 = 그 그림) · [초기화] = 사용자 그림만 지움(길찾기 지도로 · 즉시 서버)
  *   서버 자동 그림(244-11 · 선 이을 때 · 서류용)은 그대로 만듦 · 이 탭에는 안 보임(157)
+ *   373 연결 없어도 소재지 넣기 — 지도 누름 = 그 자리 소재지 · 머리 줄 [소재지] = 등록 창(`openPlaceModal`) ·
+ *     운반 자동 상자(주소 · 선 · 좌표 없음)도 · 길 선 = 저장된 구간 `path` · 안 이은 기준점에 이음 = 「시점 미연결」
  *   255-2 시점도 끌기 = 길찾기용 덮개(`site.start_pin`) · 표지 옮기면 그 자리에 닿는 구간 모두 다시 길찾기 ·
  *     열 때 선 없는 사슬 구간 모두 길찾기 · 실패 = 안내 한 줄 · 끌기는 그림 캡처 안 함
  * ========================================================================== */
@@ -16,9 +18,10 @@ import {
 } from "@ui/ui_template_context_menu";
 import { createButton, el, showToast } from "@ui/ui_template_elements";
 import type { MilestoneData, MilestoneRoute } from "./B08_Quantity_Milestone_Calc";
-import { chainOf, ownerOf } from "./B08_Quantity_Milestone_Layout";
+import { chainOf, ownerOf, reachesSite } from "./B08_Quantity_Milestone_Layout";
 import { DEST_TEXT } from "./B08_Quantity_Milestone_Table";
 import { editMap, type MapPin } from "./B08_Quantity_UI_Milestone_KakaoMap";
+import { openPlaceModal } from "./B08_Quantity_UI_Milestone_Modal";
 import { reverseAddress } from "./B08_Quantity_UI_Milestone_Place";
 import {
   capturePlace,
@@ -122,6 +125,13 @@ export function routeView(projectId: string, routeId: string): MilestoneView {
       ),
   });
   reset.dataset.b08MilestoneRevert = "";
+  // 373 [소재지] — 연결 없이도 주소 넣기(거래처 등록 창 그대로)
+  const place = createButton({
+    label: "소재지",
+    variant: "ghost",
+    onClick: () => openPlaceModal(projectId, { add: false, id: routeId }),
+  });
+  place.dataset.b08MilestonePlaceOpen = "";
 
   const pins = (): MapPin[] => {
     const d = liveMilestone(projectId);
@@ -142,12 +152,16 @@ export function routeView(projectId: string, routeId: string): MilestoneView {
     const d = liveMilestone(projectId);
     const r = d.routes.find((x) => x.id === routeId);
     const chain = r && r.linked !== false ? chainOf(d, r.to).map((b) => b.id) : [];
-    return [routeId, ...chain].map(segmentPath).filter((p) => p.length >= 2);
+    return [routeId, ...chain].map((id) => segmentPath(projectId, id)).filter((p) => p.length >= 2);
   };
   // 255-2 길찾기 실패 = 안내 한 줄(까닭 줄 = 「 — 」)
   const status = el("p", { className: "b08-options__hint" });
   status.dataset.b08MilestoneRouteStatus = "";
   status.hidden = true;
+  // 373 안 이은 기준점에 이음 = 시점까지 안 닿음 안내(이은 거래처만)
+  const open = el("p", { className: "b08-options__hint" });
+  open.dataset.b08MilestoneRouteOpen = "";
+  open.hidden = true;
   /** 길 선 여럿 다시 길찾기(그림 캡처 없음 · 캡처는 [저장] 때) → 선 다시 · 실패 안내 */
   const refind = async (ids: string[]): Promise<void> => {
     const texts = await Promise.all(ids.map((id) => findSegmentKm(projectId, id, false)));
@@ -172,8 +186,10 @@ export function routeView(projectId: string, routeId: string): MilestoneView {
     await refind(touchingSegments(fresh, key));
   };
   const map = editMap(projectId, {
-    hint: "",
+    hint: "지도 누름 = 그 자리를 소재지로 · 표지 끌어 옮김",
+    onClick: (lon, lat) => void moveTo(routeId, lon, lat),
     onMove: (key, lon, lat) => void moveTo(key, lon, lat),
+    center: () => startPoint(liveMilestone(projectId)),
   });
   const drawMap = (): void => map.set(pins(), lines());
   let asked = false; // 길 선이 없으면 열 때 한 번 길찾기(사슬 선 모두 · 그림 · 알림 없음)
@@ -183,7 +199,7 @@ export function routeView(projectId: string, routeId: string): MilestoneView {
     const d = liveMilestone(projectId);
     const r = d.routes.find((x) => x.id === routeId);
     const chain = r && r.linked !== false ? chainOf(d, r.to).map((b) => b.id) : [];
-    const missing = [routeId, ...chain].filter((id) => !segmentPath(id).length);
+    const missing = [routeId, ...chain].filter((id) => !segmentPath(projectId, id).length);
     if (missing.length) void refind(missing);
   };
 
@@ -195,10 +211,11 @@ export function routeView(projectId: string, routeId: string): MilestoneView {
         className: "b08-milestone__route-head",
         children: [
           el("div", { className: "b08-milestone__route-title", children: [name, address] }),
-          el("div", { className: "b08-milestone__bar", children: [change, reset, file] }),
+          el("div", { className: "b08-milestone__bar", children: [place, change, reset, file] }),
         ],
       }),
       status,
+      open,
       img,
       map.root,
     ],
@@ -210,6 +227,8 @@ export function routeView(projectId: string, routeId: string): MilestoneView {
     if (!r) return;
     name.textContent = `${r.name || "거래처"} → ${DEST_TEXT[r.rows[0]?.dest ?? "start"]}`;
     address.textContent = r.address || "";
+    open.hidden = r.linked === false || reachesSite(d, routeId);
+    open.textContent = open.hidden ? "" : "시점 미연결 — 이은 기준점이 시점에 이어지지 않았습니다.";
     loadImage();
     const user = hasUserImage(routeId);
     reset.hidden = !user;
diff --git a/B08_Quantity/B08_Quantity_UI_Milestone_State.ts b/B08_Quantity/B08_Quantity_UI_Milestone_State.ts
index 6d87b31cc..7827c40b7 100644
--- a/B08_Quantity/B08_Quantity_UI_Milestone_State.ts
+++ b/B08_Quantity/B08_Quantity_UI_Milestone_State.ts
@@ -8,9 +8,10 @@
  *   그림 = 올리는 즉시 서버(경로 하나 = 그림 하나 · B09 견적서 꼴).
  *   [길찾기](244-7) = 구간마다 서버 POST …/directions(카카오 키는 서버만) → 자동 km 를 캐시에 ·
  *     단추 누를 때만(조작 중 자동 호출 없음) · km 만 남김(경로 좌표 · 응답 원문 없음)
- *   경로 좌표(244-9) = 마지막 [길찾기] 응답을 메모리에만(카카오 지도 길 선 · 새로 고침이면 사라짐)
+ *   경로 좌표(244-9 · 373) = 마지막 [길찾기] 길 선을 구간 첫 줄 `legs[0].path` 에(캐시 → [저장] 정본 ·
+ *     다시 이으면 옛 거리 · 선 지우고 새 값 · 실패 = 빈칸 + 까닭 · 수기 = 지움)
  *   경로 그림 자동(244-11) = [길찾기] 뒤 길 선 · 표지를 서버 POST …/image/auto → 서버 헤드리스 캡처 그림
- *     (뒤에서 · 화면 안 잠금) · 사용자 그림 우선 · 실패 = 까닭 한 줄(알림 · 경로 탭) · 좌표는 서버도 안 남김
+ *     (뒤에서 · 화면 안 잠금) · 사용자 그림 우선 · 실패 = 까닭 한 줄(알림 · 경로 탭)
  *   길찾기 = 연결선 한 구간씩(244-13 · `findSegmentKm` · 거래처 · 기준점 → to(기준점 · 시점) · 254) ·
  *     자동 그림 = 거래처 쪽 구간 길 선 · 표지 둘(거래처 · 기준점 또는 시점)
  *   장소 그림(256-1) = 상자 좌표가 정해지면 `capturePlace` → 서버 캡처 `place/<상자 id>.png` ·
@@ -29,7 +30,13 @@ import {
   type MilestoneData,
   type SegKind,
 } from "./B08_Quantity_Milestone_Calc";
-import { mapMarks, ownerOf, putAutoKm, segmentEnds } from "./B08_Quantity_Milestone_Layout";
+import {
+  mapMarks,
+  ownerOf,
+  putAutoKm,
+  reachesSite,
+  segmentEnds,
+} from "./B08_Quantity_Milestone_Layout";
 import type { SiteAddress } from "./B08_Quantity_UI_Milestone_Modal";
 
 export interface SiteInfo {
@@ -278,12 +285,30 @@ export function roadOptions(kind: SegKind): Array<{ value: string; text: string
   return [PAVED[kind], "비포장"].map((r) => ({ value: r, text: r }));
 }
 
-/** 마지막 [길찾기] 길 선 — 구간(from = 거래처 · 기준점 id) → [위도, 경도] 목록(메모리만 · 저장 안 함) */
-const paths = new Map<string, Array<[number, number]>>();
-export const segmentPath = (from: string): Array<[number, number]> => paths.get(from) ?? [];
-/** 경로 탭 · 자동 그림 길 선 = 거래처 쪽 구간 */
-export const routePaths = (routeId: string): Array<Array<[number, number]>> =>
-  paths.has(routeId) ? [paths.get(routeId)!] : [];
+/** 마지막 [길찾기] 길 선 — 구간(from = 거래처 · 기준점 id) → [위도, 경도] 목록(캐시 자료의 구간 첫 줄) */
+export const segmentPath = (projectId: string, from: string): Array<[number, number]> =>
+  ownerOf(liveMilestone(projectId), from)?.legs[0]?.path ?? [];
+
+/** 찾은 값을 구간 첫 줄에 — km · path 가 null 이면 옛 값 지움(옛 거리 · 선 안 남김) · 바뀔 때만 캐시에 */
+function putFound(
+  projectId: string,
+  from: string,
+  km: number | null,
+  path: Array<[number, number]> | null,
+): void {
+  const fresh = liveMilestone(projectId); // 기다리는 동안 고친 값 위에
+  const owner = ownerOf(fresh, from);
+  const before = JSON.stringify(owner?.legs[0] ?? null);
+  if (km != null) putAutoKm(fresh, from, km);
+  const leg = owner?.legs[0];
+  if (leg) {
+    if (km == null && leg.auto_km != null) leg.auto_km = null;
+    if (path) leg.path = path;
+    else delete leg.path;
+  }
+  if (JSON.stringify(leg ?? null) !== before) putMilestone(projectId, fresh);
+  else changes.dispatchEvent(new Event("change"));
+}
 
 /** [길찾기] 한 구간(연결선 · 244-13) — 서버가 카카오로 km · 자동 값을 캐시에(sameKm = 같으면 안 씀) ·
  *  거래처 쪽 구간 = 자동 그림(뒤에서) · 돌려줌 = 결과 한 줄(까닭 줄엔 「 — 」) */
@@ -299,6 +324,7 @@ export async function findSegmentKm(
   if (!seg) return "";
   if (!seg.from || !seg.to) {
     const missing = seg.text.split(" → ")[seg.from ? 1 : 0];
+    putFound(projectId, from, null, null);
     return `${seg.text} — ${missing} 좌표가 없습니다(소재지 · 노선) · km 를 손으로 넣으세요.`;
   }
   try {
@@ -313,18 +339,17 @@ export async function findSegmentKm(
         destination: { lon: seg.to[0], lat: seg.to[1] },
       }),
     });
-    if (res.km == null) return `${seg.text} — ${res.reason ?? "길찾기 실패"}`;
-    if ((res.path?.length ?? 0) >= 2) paths.set(from, res.path!);
-    else paths.delete(from);
-    const fresh = liveMilestone(projectId); // 기다리는 동안 고친 값 위에
-    if (ownerOf(fresh, from)?.legs[0]?.auto_km !== res.km) {
-      putAutoKm(fresh, from, res.km);
-      putMilestone(projectId, fresh);
-    } else changes.dispatchEvent(new Event("change"));
-    if (image && seg.key === "route" && paths.has(from))
-      void autoRouteImage(projectId, from, routePaths(from)); // 뒤에서 · km 알림 안 기다림
-    return `${seg.text} ${res.km} km`;
+    if (res.km == null) {
+      putFound(projectId, from, null, null);
+      return `${seg.text} — ${res.reason ?? "길찾기 실패"}`;
+    }
+    const path = (res.path?.length ?? 0) >= 2 ? res.path! : null;
+    putFound(projectId, from, res.km, path);
+    if (image && seg.key === "route" && path) void autoRouteImage(projectId, from, [path]); // 뒤에서 · km 알림 안 기다림
+    const open = reachesSite(liveMilestone(projectId), from) ? "" : " — 시점 미연결";
+    return `${seg.text} ${res.km} km${open}`;
   } catch (error) {
+    putFound(projectId, from, null, null);
     return `${seg.text} — 길찾기 요청 실패(${String(error)}) · km 를 손으로 넣으세요.`;
   }
 }
diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py
index 722b87ef3..03f62c17c 100644
--- a/M02_MasterTemplete/M02_Labor_Ref.py
+++ b/M02_MasterTemplete/M02_Labor_Ref.py
@@ -326,6 +326,14 @@ def refuse_used(folder: Path, kind: str, key: str) -> None:
 
 
 # ── 층 사이 복사 ──────────────────────────────────────────────────────
+def origin_mark(doc: dict[str, Any], ref: Ref) -> dict[str, Any]:
+    """복사 문서의 `본뜬` — 실무자료 본뜬(키 · 전국자재 …)은 지키고 원본 참조는 `복사원본` 칸에 둠."""
+    own = doc.get("본뜬")
+    if isinstance(own, dict) and own.get("층") == "실무자료":
+        return {**doc, "본뜬": {**own, "복사원본": ref}}
+    return {**doc, "본뜬": ref}
+
+
 def carry(doc: dict[str, Any], source: Here) -> dict[str, Any]:
     """복사(원본 층 `source` → 지금 층) — 지금 층이 못 읽는 참조는 그 문서를 지금 층에 새 키로
     같이 복사(`본뜬` = 원래 참조) · 참조를 새 키로 바꿈. 원본 층 읽기 권한은 부르는 쪽 몫."""
@@ -341,7 +349,7 @@ def carry(doc: dict[str, Any], source: Here) -> dict[str, Any]:
         got = read_ref(ref)
         if got is None:
             raise _bad(f"없는 참조 「{ref['키']}」")
-        body = {**got, "담은로직": _moved(got.get("담은로직"), move, depth + 1), "본뜬": ref}
+        body = origin_mark({**got, "담은로직": _moved(got.get("담은로직"), move, depth + 1)}, ref)
         made = create(kind_of(ref["키"]), body)
         done[ref_id(ref)] = {"층": target[0], "주인": target[1], "키": made["이름"]}
         return done[ref_id(ref)]
diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py
index e0ad37249..7e278e7c4 100644
--- a/M02_MasterTemplete/M02_Labor_Router.py
+++ b/M02_MasterTemplete/M02_Labor_Router.py
@@ -97,7 +97,7 @@ class LibraryBody(BaseModel):
 
 
 def _copy(kind: str, doc: dict[str, Any], source: refs.Here, ref: dict) -> dict[str, Any]:
-    return refs.create(kind, refs.carry({**doc, "본뜬": ref}, source))
+    return refs.create(kind, refs.carry(refs.origin_mark(doc, ref), source))
 
 
 @router.post("/layers/{layer}/library/{kind}")
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Sheet.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Sheet.ts
index 687db5ab1..6702b1564 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Sheet.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Sheet.ts
@@ -127,9 +127,9 @@ export function buildOrder(ones: { 번: number; 아래: number[] }[]): number[]
   return out;
 }
 
-/** 단가산출 행 → 행 전체 범위 A1(`4:9`) */
+/** 단가산출 행 → B ~ F 열 범위 A1(`B4:F9`) */
 export const rowsText = (행: number | [number, number]): string =>
-  typeof 행 === "number" ? `${행}:${행}` : `${행[0]}:${행[1]}`;
+  typeof 행 === "number" ? `B${행}:F${행}` : `B${행[0]}:F${행[1]}`;
 
 export function openHopyoSheet(opt: HopyoSheetOptions): void {
   let sheet: SpreadsheetHandle | null = null;
diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts
index 8e6585aa8..72d9c4a88 100644
--- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts
+++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts
@@ -111,12 +111,15 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection {
       scope,
       key: file.키,
       파일: file.파일,
-      canWrite: opt.canWrite,
+      // 사전조합은 어느 화면 층에서든 로그인한 사람 개인 층에 만듦 — 회사 · 마스터는 구조물 카드 [가져오기]
+      target: { layer: "personal", owner: null },
+      canWrite: true,
       onClose: () => {
         if (sheetKey === file.키) sheetKey = null;
         paintList();
       },
-      onDeleted: () => void refresh(),
+      // [삭제]는 실무자료 파일이 있는 화면 층 쓰기 권한 때만
+      onDeleted: opt.canWrite ? () => void refresh() : undefined,
     });
   }
 
diff --git a/common_util/common_util_cross_design_geometry.ts b/common_util/common_util_cross_design_geometry.ts
index 75358fc4b..59aa1fa94 100644
--- a/common_util/common_util_cross_design_geometry.ts
+++ b/common_util/common_util_cross_design_geometry.ts
@@ -180,6 +180,16 @@ export class SectionGeometry {
       this.slopePerOffset = lowLeft ? -slope : slope;
     }
 
+    // 설계선 쉬프트 = 쪽마다 사면 이동(≥ 0 · 139-6 · 151-2) — 노견(폭 고정) · 측구 · 사면이 같이
+    // 바깥으로 · 늘어난 폭은 차도 · 단면유형 · 측구 판정은 **옮긴 뒤** 노견에서(아래 · 370-1 — 마루를
+    // 넘으면 그 쪽 사면 기울기로 원지반까지). ⚠ 파이썬 짝 `_SectionGeometry`.
+    this.shoulderExtendLeft = Math.max(params.shoulderExtendLeftM ?? 0, 0);
+    this.shoulderExtendRight = Math.max(params.shoulderExtendRightM ?? 0, 0);
+    this.halfRoadLeft += this.shoulderExtendLeft;
+    this.halfRoadRight += this.shoulderExtendRight;
+    this.leftExtent += this.shoulderExtendLeft;
+    this.rightExtent += this.shoulderExtendRight;
+
     // 단면유형 자동 판정(D-2) — 노면 끝 지반이 설계면보다 높으면 절토, 낮으면 성토.
     const groundAt = params.groundAt;
     if (groundAt !== null) {
@@ -226,15 +236,6 @@ export class SectionGeometry {
     // 물넘이포장 · 맹암거 자리(286-2 · 288-1) — 측구가 안 섬 · 선택은 그대로(파이썬 짝)
     if (params.tilted) this.hasDitch = false;
 
-    // 설계선 쉬프트 = 쪽마다 사면 이동(≥ 0 · 139-6 · 151-2) — 단면유형 · 측구 판정은 **옮기기 전**
-    // 노견에서(위) · 노견(폭 고정) · 측구 · 사면이 같이 바깥으로 · 늘어난 폭은 차도. ⚠ 파이썬 짝 `_SectionGeometry`.
-    this.shoulderExtendLeft = Math.max(params.shoulderExtendLeftM ?? 0, 0);
-    this.shoulderExtendRight = Math.max(params.shoulderExtendRightM ?? 0, 0);
-    this.halfRoadLeft += this.shoulderExtendLeft;
-    this.halfRoadRight += this.shoulderExtendRight;
-    this.leftExtent += this.shoulderExtendLeft;
-    this.rightExtent += this.shoulderExtendRight;
-
     // 측구 꼭짓점(측구측 노면 끝 기준, 바깥 방향 부호 적용).
     const edgeOffset = params.ditchSide === "left" ? this.leftExtent : -this.rightExtent;
     const outward = params.ditchSide === "left" ? 1 : -1;
diff --git a/common_util/common_util_drainage_detail.py b/common_util/common_util_drainage_detail.py
index 05e215273..ac93ca754 100644
--- a/common_util/common_util_drainage_detail.py
+++ b/common_util/common_util_drainage_detail.py
@@ -3,7 +3,8 @@
 **격자 해석은 하지 않는다.** B04 배수유역 분석이 미리 돌려 저장한 결과를 읽어, 사용자가
 실제로 손대는 두 가지만 처리한다(2026-07-31 사용자 지시).
 
-  ⑨ 관 간격이 최대치를 넘는 구간에 **최소 개수**로 관을 보충
+  ⑨ 관 간격이 최대치를 넘는 구간에 **최소 개수**로 관을 보충([자동 제안] 때만 · 기본 = 세류선
+     교차만)
   ⑩ 측구 흐름으로 도로 셀 → 담당 관을 정하고, 셀이 도달한 도로 셀의 담당 관을 그대로
      그 셀의 유역 번호로 삼아 세부유역을 나눈다
   ⑪ 사용자가 관을 옮기거나 추가하면 ⑩만 다시 돈다 — 격자 해석은 재사용한다
@@ -25,7 +26,7 @@ from __future__ import annotations
 
 import json
 import logging
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
@@ -65,6 +66,10 @@ _SCORE_WEIGHT_STRENGTH = 0.7
 _SCORE_WEIGHT_SAG = 0.3
 # 성토부(내리막)는 물이 노선 밖으로 빠지므로 관 위치로 덜 선호한다.
 _SCORE_FILL_PENALTY = 0.5
+# [자동 제안] 전체 자동(369) — 새 자리에서 이만큼(m) 안의 지금 관 = 같은 관(그 자리 그대로 ·
+# 속성 이어받음). 화면 `SAME_PIPE_M`(제안 · 같은 유역)과 같은 값 — 노선 따라감으로 cm 어긋난
+# 세월교도 같은 관.
+SAME_PIPE_M = 0.5
 
 
 @dataclass
@@ -167,21 +172,25 @@ def build_detail(
     confirmed_chainages: list[float] | None = None,
     routing: RoadRouting | None = None,
     upstream_lonlat: list[list[list[float]]] | None = None,
+    auto: str | None = None,
 ) -> DrainageDetail | None:
-    """B04 분석 결과를 읽어 관을 보충하고 세부유역을 나눈다.
+    """B04 분석 결과를 읽어 관 자리를 정하고 세부유역을 나눈다.
 
     `confirmed_chainages`를 주면 그 위치를 관으로 확정하고(사용자 편집 · 빈 목록 = 관 0개), None 이면
-    B04의 기본 관에 최대 간격 규칙으로 최소 개수만 보충한다. 어느 쪽이든 격자 해석은 하지 않는다.
+    B04의 기본 관(세류선 교차)만. 어느 쪽이든 격자 해석은 하지 않는다.
+    `auto`([자동 제안] · 369) — None = 위 그대로 · "all" = 기본 관 + 최대 간격 보충으로 다시
+    (확정 목록 무시) · "add" = 확정 목록 + 빈 구간 보충. 관 자리 후보는 어느 길이든 셈.
     `routing` · `upstream_lonlat` 을 주면 파일 대신 그것(「지금 노선으로 셈」 메모리 결과 · 347-2).
     """
     routing = routing or read_road_routing(directory)
     if routing is None or len(vertices) < 2:
         return None
 
-    candidates: list[StructureCandidate] = []
-    if confirmed_chainages is not None:
+    if confirmed_chainages is not None and auto != "all":
         pipes = pipes_from_chainages(vertices, confirmed_chainages)
-        candidates = suggest_pipe_positions(vertices, pipes, routing.strength_curve)
+        if auto == "add":
+            pipes = [*pipes, *suggest_pipe_positions(vertices, pipes, routing.strength_curve)]
+            pipes.sort(key=lambda pipe: pipe.chainage_m)
     else:
         # 저장분의 기본 관은 누가거리만 신뢰한다 — 좌표는 현재 노선 위로 다시 찍는다.
         base = [
@@ -194,7 +203,22 @@ def build_detail(
             for pipe in routing.base_pipes
         ]
         # 자동 관 자리 = 정수 m · 일반 측점 1 m 안이면 그 측점(234-1) — 확정본(위)은 단추로만
-        pipes = snap_candidates(place_pipes(vertices, base, routing.strength_curve), vertices)
+        placed = place_pipes(vertices, base, routing.strength_curve, fill=auto is not None)
+        pipes = snap_candidates(placed, vertices)
+        if confirmed_chainages:
+            kept = pipes_from_chainages(vertices, confirmed_chainages)
+            pipes = [
+                replace(
+                    min(
+                        (k for k in kept if abs(k.chainage_m - pipe.chainage_m) <= SAME_PIPE_M),
+                        key=lambda k: abs(k.chainage_m - pipe.chainage_m),
+                        default=pipe,
+                    ),
+                    reason=pipe.reason,
+                )
+                for pipe in pipes
+            ]
+    candidates = suggest_pipe_positions(vertices, pipes, routing.strength_curve)
 
     detail = DrainageDetail(
         route_lonlat=routing.route_lonlat,
@@ -386,10 +410,12 @@ def place_pipes(
     vertices: list[RouteVertex],
     base_pipes: list[StructureCandidate],
     strength_curve: np.ndarray,
+    fill: bool = True,
 ) -> list[StructureCandidate]:
     """B04가 정한 기본 관(세류 교차점)에, 최대 간격을 넘는 구간만 최소 개수로 보충한다.
 
-    기본 관은 여기서 다시 찾지 않는다 — B04 산출물에 이미 들어 있다.
+    기본 관은 여기서 다시 찾지 않는다 — B04 산출물에 이미 들어 있다. `fill=False` = 보충 없이
+    기본 관만(최소 간격 겹침만 걸러 냄 · 369 기본).
     """
     total_length = vertices[-1].chainage_m
     base: list[StructureCandidate] = []
@@ -397,6 +423,8 @@ def place_pipes(
         if base and candidate.chainage_m - base[-1].chainage_m < DRAINAGE_PIPE_MIN_SPACING_M:
             continue
         base.append(candidate)
+    if not fill:
+        return base
 
     filled: list[StructureCandidate] = []
     previous = 0.0
diff --git a/common_util/common_util_mass_haul_view.ts b/common_util/common_util_mass_haul_view.ts
index 95d618d03..41bc3a659 100644
--- a/common_util/common_util_mass_haul_view.ts
+++ b/common_util/common_util_mass_haul_view.ts
@@ -786,7 +786,8 @@ export function createMassHaulLegend(
     reset.textContent = L("B06_MassHaul_Balloon_Reset");
     reset.title = L("B06_MassHaul_Balloon_Reset_Tip");
     reset.addEventListener("click", onResetBalloons);
-    legend.append(reset);
+    // [횡단 기준] 왼쪽(367-1)
+    legend.prepend(reset);
   }
   return legend;
 }
diff --git a/common_util/common_util_structure_underdrain.ts b/common_util/common_util_structure_underdrain.ts
index e992610e6..36179f3b3 100644
--- a/common_util/common_util_structure_underdrain.ts
+++ b/common_util/common_util_structure_underdrain.ts
@@ -12,7 +12,7 @@ import { catalogRow } from "./common_util_structure_catalog";
 
 const EDGE_TOLERANCE_M = 0.02;
 
-/** 맹암거 제원 — 높이 · 경사가 비면 null(높이 없으면 형상 없음 · 경사 없으면 표준 횡단경사). */
+/** 맹암거 제원 — 높이 · 경사가 비면 null(높이 없으면 형상 없음 · 경사 = 형상 하단 경계 · 없으면 노면과 평행 · 371-3). */
 export interface UnderdrainSpec {
   structure_id: string | null;
   chainage_m: number;
diff --git a/resources/help/B05/00_설명서.md b/resources/help/B05/00_설명서.md
index 89349f545..31c6e3a65 100644
--- a/resources/help/B05/00_설명서.md
+++ b/resources/help/B05/00_설명서.md
@@ -1,4 +1,4 @@
-# 종단설계 설명서
+# 노선설계 설명서
 
 ## 이 화면에서 하는 일
 
diff --git a/resources/tester/helper_137_design_pick.cjs b/resources/tester/helper_137_design_pick.cjs
index b30e6e80e..c45d0e9f6 100644
--- a/resources/tester/helper_137_design_pick.cjs
+++ b/resources/tester/helper_137_design_pick.cjs
@@ -288,7 +288,12 @@ const designLines = kids.filter((k) => k.classList.contains("b06-chart__design-c
 const stopped = hits[0].click();
 handle.setActive(1);
 const activeOn = hits.map((h) => h.classList.contains("is-active"));
-const labelOn = { hidden: handle.label.hidden, text: handle.label.textContent };
+// 아래 띠 공용 칸(370-3) — 빈 칸 = is-empty · 값 = 버튼 줄 끝 글
+const cellNow = () => ({
+  hidden: handle.cell.classList.contains("is-empty"),
+  text: handle.cell.children[1].children.at(-1).textContent,
+});
+const labelOn = cellNow();
 handle.setActive(null);
 out.real = {
   designLines,
@@ -303,7 +308,7 @@ out.real = {
   activeCount: activeOn.filter(Boolean).length,
   activeIndex: activeOn.indexOf(true),
   labelOn,
-  labelOff: { hidden: handle.label.hidden, text: handle.label.textContent },
+  labelOff: cellNow(),
   zones: [...new Set(handle.pieces.map((p) => pick.pieceZone(pipeSection.design, p).zone))].sort(),
 };
 
diff --git a/resources/tester/helper_139_4_buried_outlet.cjs b/resources/tester/helper_139_4_buried_outlet.cjs
index 9cc617d61..8b8a20cb2 100644
--- a/resources/tester/helper_139_4_buried_outlet.cjs
+++ b/resources/tester/helper_139_4_buried_outlet.cjs
@@ -131,7 +131,8 @@ function reshaped(rise, slope) {
   const s = clone(pipe);
   for (const p of s.samples) {
     const t = ((p.offset_m ?? 0) - start.offset) * outward;
-    if (t >= 0 && typeof p.elevation_m === "number")
+    // 시작점 바로 앞 표본까지(−1 m) — 보간이 시작점을 옛 지반에 두지 않게(371-1 벽 자리 이동)
+    if (t >= -1 && typeof p.elevation_m === "number")
       p.elevation_m = start.elevation + rise + slope * t;
   }
   return study(
@@ -141,4 +142,5 @@ function reshaped(rise, slope) {
 }
 out.pipeDown = reshaped(0.3, -0.15); // 3도보다 가파르게 내림 → 3도 선이 만남
 out.pipeUp = reshaped(0.3, 0.1); // 오르막 → 3도 선이 못 만남 → 복합경사
+out.pipeOpen = reshaped(-0.3, -0.5); // 끝 바깥이 지반 아래로 열림 → 성토부선(371-1)
 process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_139_6_line_shift.cjs b/resources/tester/helper_139_6_line_shift.cjs
index 4d146fc17..a8284f2e8 100644
--- a/resources/tester/helper_139_6_line_shift.cjs
+++ b/resources/tester/helper_139_6_line_shift.cjs
@@ -147,21 +147,21 @@ const handle = pick.attachDesignLinePick({
     set: (side, v) => (values[side] = v),
   },
 });
-const panel = handle.panel;
-const slot = (name) => panel.querySelector(`.b06-structure-panel__btn--${name}`);
-const close = panel.querySelector(".b06-structure-panel__close");
+// 아래 띠 공용 칸(370-3) — 제목 · 버튼 · 값 한 줄
+const cell = handle.cell;
+const slot = (name) => cell.querySelector(`.b06-cross-card__cell-btn--${name}`);
+const cellTitle = () => cell.children[0].textContent;
+const cellValue = () => cell.children[1].children.at(-1).textContent;
 const pieceAt = (offset) =>
   handle.pieces.findIndex(
     (p) =>
       Math.min(p.from.offset, p.to.offset) <= offset &&
       offset <= Math.max(p.from.offset, p.to.offset),
   );
-const hiddenAtStart = panel.classList.contains("is-hidden");
+const hiddenAtStart = cell.classList.contains("is-empty");
 const log = [];
 handle.setActive(pieceAt(4)); // 좌 사면
-const titleLeft = panel.descendants.find((n) =>
-  n._cls.has("b06-structure-panel__title"),
-).textContent;
+const titleLeft = cellTitle();
 slot("left").click(); // 화면 왼쪽 = 좌측 바깥 → +0.1
 key("ArrowLeft"); // 방향키 = 십자
 log.push({ ...values });
@@ -174,26 +174,25 @@ key("ArrowLeft"); // 화면 왼쪽 = 우측 안쪽 → 0 에서 멈춤
 slot("right").click(); // 우측 바깥 → +0.1
 log.push({ ...values });
 handle.setActive(pieceAt(-4));
-const text = handle.label.textContent;
-const readout = panel.descendants.find((n) => n._cls.has("b06-structure-panel__value")).textContent;
+const text = cellValue();
+const slots = ["left", "up", "reset", "down", "right"]
+  .map((n) => slot(n))
+  .filter((b) => !b.hidden)
+  .map((b) => b.textContent);
 slot("reset").click(); // ↺ = 그 쪽 0
 const afterReset = { ...values };
-close.click(); // ✕ = 같은 조각 다시 고름(카드가 풂)
 handle.setActive(null);
-key("ArrowRight"); // 숨은 패널은 방향키 안 먹음
+key("ArrowRight"); // 빈 칸은 방향키 안 먹음
 process.stdout.write(
   JSON.stringify({
     log,
     text,
-    readout,
     titleLeft,
     afterReset,
     afterHidden: { ...values },
     picks,
-    pieceRight: pieceAt(-4),
     hiddenAtStart,
-    hiddenAfter: panel.classList.contains("is-hidden"),
-    labelButtons: handle.label.children.length,
-    slots: ["left", "reset", "right"].map((n) => slot(n).textContent),
+    hiddenAfter: cell.classList.contains("is-empty"),
+    slots,
   }),
 );
diff --git a/resources/tester/helper_193_1_line_axis.cjs b/resources/tester/helper_193_1_line_axis.cjs
index e2e9d71eb..4be2feca6 100644
--- a/resources/tester/helper_193_1_line_axis.cjs
+++ b/resources/tester/helper_193_1_line_axis.cjs
@@ -173,13 +173,10 @@ function card(sectionMode, ditch) {
         Math.min(p.from.offset, p.to.offset) <= offset &&
         offset <= Math.max(p.from.offset, p.to.offset),
     );
-  const slot = (name) => handle.panel.querySelector(`.b06-structure-panel__btn--${name}`);
-  const title = () =>
-    handle.panel.descendants.find((n) => n._cls.has("b06-structure-panel__title")).textContent;
-  const rowHidden = () =>
-    handle.panel.descendants
-      .find((n) => n._cls.has("b06-structure-panel__struct"))
-      ._cls.has("is-hidden");
+  // 아래 띠 공용 칸(370-3) — 제목 · 버튼 줄(◀▲↺▼▶ 보임만 바뀜) · 값 한 줄
+  const slot = (name) => handle.cell.querySelector(`.b06-cross-card__cell-btn--${name}`);
+  const title = () => handle.cell.children[0].textContent;
+  const rowHidden = () => ["left", "reset", "right"].every((name) => slot(name).hidden);
   return { design, handle, values, at, slot, title, rowHidden };
 }
 
@@ -236,7 +233,7 @@ const out = {};
     same: JSON.stringify(before) === JSON.stringify(c.values),
     title: c.title(),
     rowHidden: c.rowHidden(),
-    label: c.handle.label.textContent,
+    label: c.handle.cell.children[1].children.at(-1).textContent,
   };
   // 고름 풀면 아무 키도 안 막음
   c.handle.setActive(null);
diff --git a/resources/tester/helper_194_1_berm_pick.cjs b/resources/tester/helper_194_1_berm_pick.cjs
index 96b25c34a..d0f8a57e2 100644
--- a/resources/tester/helper_194_1_berm_pick.cjs
+++ b/resources/tester/helper_194_1_berm_pick.cjs
@@ -176,15 +176,17 @@ function card({ dl = 1, stored = undefined, order = ["left", "road", "right"], s
     leftUpper: find((p) => !pick.isBermPiece(design, p) && mid(p) > 2 && mid(p) < 2 + 1.5 * dl),
     road: find((p) => mid(p) > 0 && mid(p) < 2),
   };
+  // 아래 띠 공용 칸(370-3) — 버튼 다섯 칸 한 벌(보임만 바뀜) · 제목 · 값 한 줄
   const slot = (name) =>
-    handle.panel.descendants.find(
-      (n) => n._cls.has(`b06-structure-panel__btn--${name}`) && !n.parentHidden,
-    );
-  const rows = () =>
-    handle.panel.descendants
-      .filter((n) => n._cls.has("b06-structure-panel__struct"))
-      .map((n) => n._cls.has("is-hidden"));
-  const text = (cls) => handle.panel.descendants.find((n) => n._cls.has(cls)).textContent;
+    handle.cell.descendants.find((n) => n._cls.has(`b06-cross-card__cell-btn--${name}`));
+  const rows = () => [
+    slot("left").hidden && slot("right").hidden,
+    slot("up").hidden && slot("down").hidden,
+  ];
+  const text = (what) =>
+    what === "title"
+      ? handle.cell.children[0].textContent
+      : handle.cell.children[1].children.at(-1).textContent;
   return { design, handle, values, sets, focus, at, slot, rows, text };
 }
 
@@ -212,13 +214,10 @@ const out = {};
   const afterSide = { values: { ...c.values }, sets: c.sets.length };
   const upTaken = press("ArrowUp");
   press("ArrowDown");
-  c.handle.panel.descendants
-    .filter((n) => n._cls.has("b06-structure-panel__btn--reset"))
-    .at(-1)
-    .click();
+  c.slot("reset").click();
   out.berm = {
-    title: c.text("b06-structure-panel__title"),
-    readout: c.text("b06-structure-panel__value"),
+    title: c.text("title"),
+    readout: c.text("value"),
     moveHidden,
     liftHidden,
     leftBlocked,
@@ -232,7 +231,7 @@ const out = {};
   const before = c.sets.length;
   out.berm.slopeUpBlocked = press("ArrowUp");
   out.berm.slopeSets = c.sets.length - before;
-  out.berm.slopeTitle = c.text("b06-structure-panel__title");
+  out.berm.slopeTitle = c.text("title");
   out.berm.focusAfter = c.focus.at(-1);
   // 노면 = ▲▼ 는 종단도로 넘김(안 막음)
   c.handle.setActive(c.at.road);
diff --git a/resources/tester/helper_215_1_free_profile.cjs b/resources/tester/helper_215_1_free_profile.cjs
index 3c27f333b..e5a7e9181 100644
--- a/resources/tester/helper_215_1_free_profile.cjs
+++ b/resources/tester/helper_215_1_free_profile.cjs
@@ -26,7 +26,9 @@ function loadTs(file) {
 }
 
 const free = loadTs(path.join(ROOT, "A00_Common", "design", "logic", "design_profile_free.ts"));
-const align = loadTs(path.join(ROOT, "B05_Profile", "logic", "B05_Profile_UI_Profile_Alignment.ts"));
+const align = loadTs(
+  path.join(ROOT, "B05_Profile", "logic", "B05_Profile_UI_Profile_Alignment.ts"),
+);
 
 // 전체 측점 폴리라인(20m 간격 · 0~200m) — 계획고 = 지반고, 마디마다 기울기가 다르다.
 const stations = Array.from({ length: 11 }, (_, i) => i * 20);
@@ -124,14 +126,23 @@ out.snapOutside = free.snapStation(stations, 190, [40, 160]);
   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.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);
+  out.outsideUntouched =
+    !("20.000" in next.station_offsets) && !("180.000" in next.station_offsets);
 }
 
 // ④ Enter = 끝(마지막 점 → 끝 세로선) · 끝 세로선에서 거꾸로 시작.
@@ -172,4 +183,62 @@ out.snapOutside = free.snapStation(stations, 190, [40, 160]);
   out.enterOutsideDrawing = draw.key("Enter");
 }
 
+// ⑥ 되돌리기 · 다시하기(367-3) — 점 둘 → ↶ → ↷ → 새 클릭이 ↷ 지움 · apply 안 불림 · 범위까지 거꾸로.
+{
+  const { draw, log } = harness();
+  out.undoEmpty = { can: draw.canUndo(), backspace: draw.key("Backspace") };
+  draw.click(40, 0, stations);
+  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);
+  const dots = () => draw.marks().dots.map((d) => d.chainage_m);
+  draw.undo();
+  out.undo1 = { dots: dots(), canRedo: draw.canRedo() };
+  draw.redo();
+  out.redo1 = { dots: dots(), canRedo: draw.canRedo() };
+  draw.undo();
+  draw.click(100, 104, stations); // 새 클릭 = future 비움
+  out.newClick = { dots: dots(), canRedo: draw.canRedo() };
+  const phases = [];
+  while (draw.canUndo()) {
+    draw.undo();
+    phases.push(`${draw.phase()}:${draw.marks().edges.length}`);
+  }
+  out.undoAll = phases;
+  out.undoApplied = log.applied.length;
+  out.undoClosed = log.closed;
+  draw.redo();
+  draw.redo();
+  out.redoTwice = { phase: draw.phase(), band: draw.marks().band };
+  draw.reset();
+  out.resetClears = { undo: draw.canUndo(), redo: draw.canRedo() };
+}
+
+// ⑦ 적용이 막히면(apply = false) 자유지정 열린 채 · 점 그대로.
+{
+  let tries = 0;
+  const draw = free.createFreeDraw({
+    base: () => base,
+    alignment: () => align.buildAlignment(base, align.emptyEdits()),
+    edits: () => align.emptyEdits(),
+    apply: () => ((tries += 1), false),
+    close: () => (tries += 100),
+    changed: () => undefined,
+  });
+  draw.click(40, 0, stations);
+  draw.click(160, 0, stations);
+  draw.click(40, 0, stations);
+  draw.click(80, 102, stations);
+  draw.key("Enter");
+  draw.click(160, 0, stations);
+  out.blocked = {
+    tries,
+    phase: draw.phase(),
+    dots: draw.marks().dots.length,
+    canUndo: draw.canUndo(),
+  };
+}
+
 process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_218_1_loupe.cjs b/resources/tester/helper_218_1_loupe.cjs
index 1d8e2030c..be3b7ea74 100644
--- a/resources/tester/helper_218_1_loupe.cjs
+++ b/resources/tester/helper_218_1_loupe.cjs
@@ -489,7 +489,8 @@ function makePage() {
   return app;
 }
 function fakeDocument(app) {
-  const doc = { body: new El("BODY") };
+  // 374-1 뜨는 자리 = body(모달 포함) · 원 · 배율 글은 html 바로 아래
+  const doc = { body: app, documentElement: new El("HTML") };
   doc.createElement = (tag) => new El(tag.toUpperCase());
   doc.getElementById = (id) => (id === "app" ? app : null);
   return doc;
@@ -515,10 +516,12 @@ function fakeDocument(app) {
   };
   const view = m.createLoupeView(win);
   view.show(500, 400);
-  const root = doc.body.children[0];
-  const label = doc.body.children[1];
+  const root = doc.documentElement.children[0];
+  const label = doc.documentElement.children[1];
   const stage = root.children[0];
-  const page = stage.children[0];
+  const scaler = stage.children[0]; // 이동 = stage · 배율 = scaler
+  const page = scaler.children[0];
+  const lens = () => `${stage.style.transform} ${scaler.style.transform}`;
   const copy = page.children[0];
   const [scroller, offscreen, table, svg, frame, cadBox] = copy.children;
   const [canvas, blank, input, check] = scroller.children;
@@ -529,7 +532,8 @@ function fakeDocument(app) {
     ariaHidden: root.attrs["aria-hidden"],
     hidden: root.hidden,
     rootTransform: root.style.transform,
-    stageTransform: stage.style.transform,
+    stageTransform: lens(),
+    stageMoveOnly: 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]),
@@ -560,19 +564,31 @@ function fakeDocument(app) {
     hidden: label.hidden,
   };
   view.setZoom(3);
-  r.label.zoom3 = [label.textContent, stage.style.transform, root.style.transform];
+  r.label.zoom3 = [label.textContent, lens(), root.style.transform];
   view.move(500, 790);
   r.label.bottom = label.style.transform;
   view.setZoom(2);
   view.move(500, 400);
-  // 화면이 바뀜 — 0.5 초 뒤 한 번만 다시 뜸
+  // 화면이 바뀜 — 멈춘 뒤 0.5 초에 한 번만 다시 뜸
   const firstCopy = copy;
   observers[0].fn();
   observers[0].fn();
   win.tick(499);
-  const sameBefore = stage.children[0].children[0] === firstCopy;
+  const sameBefore = scaler.children[0].children[0] === firstCopy;
   win.tick(1);
-  const recaptured = stage.children[0].children[0] !== firstCopy && stage.children.length === 1;
+  const recaptured = scaler.children[0].children[0] !== firstCopy && scaler.children.length === 1;
+  // 374-1 움직이는 동안 안 뜸 — 바뀜 뒤 움직이면 처음부터 · 멈춘 뒤 0.5 초에 한 번
+  const moving = scaler.children[0].children[0];
+  observers[0].fn();
+  win.tick(300);
+  view.move(520, 400);
+  win.tick(300);
+  view.move(540, 400);
+  win.tick(499);
+  const heldWhileMoving = scaler.children[0].children[0] === moving;
+  win.tick(1);
+  r.debounce = { heldWhileMoving, afterStop: scaler.children[0].children[0] !== moving };
+  view.move(500, 400);
   view.move(10, 10);
   const nearEdge = root.style.transform;
   view.hide();
@@ -580,20 +596,21 @@ function fakeDocument(app) {
     sameBefore,
     recaptured,
     nearEdge,
-    stageChildren: stage.children.length,
+    stageChildren: scaler.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;
+  r.hide.noRecaptureAfterHide = scaler.children.length;
   r.hide.labelHidden = label.hidden;
   view.setZoom(4);
   view.hide();
   view.show(500, 400);
-  r.hide.reopenLabel = [label.textContent, label.hidden, stage.style.transform];
-  r.hide.reuseRoot = doc.body.children.length;
+  r.hide.reopenLabel = [label.textContent, label.hidden, lens()];
+  r.hide.reuseRoot = doc.documentElement.children.length;
+  r.hide.bodyUntouched = app.children.length; // 원이 body 에 안 붙음
 }
 {
   // 221-2 스크롤 — 스크롤한 뒤 켬 · 켠 채 스크롤(칸 · 문서)
@@ -606,8 +623,9 @@ function fakeDocument(app) {
     disconnect() {}
   };
   const view = m.createLoupeView(win);
-  const cloneScroller = () => doc.body.children[0].children[0].children[0].children[0].children[0];
-  const page = () => doc.body.children[0].children[0].children[0];
+  const scaler = () => doc.documentElement.children[0].children[0].children[0];
+  const cloneScroller = () => scaler().children[0].children[0].children[0];
+  const page = () => scaler().children[0];
   view.show(500, 400);
   view.hide();
   scroller.scrollTop = 0; // 0 에서 켬 → 스크롤 칸으로 잡힘
diff --git a/resources/tester/helper_230_2_popout_frames.cjs b/resources/tester/helper_230_2_popout_frames.cjs
index 23a06bbd6..d208a03df 100644
--- a/resources/tester/helper_230_2_popout_frames.cjs
+++ b/resources/tester/helper_230_2_popout_frames.cjs
@@ -99,7 +99,7 @@ out.viewOf = {
     buildAlignment: () => null,
     store: { edits: () => ({}) },
     projectId: "p",
-    pagePipeline: { pipelineGrade: () => undefined }, // 계산 묶음(346-1) — 묶음 없으면 아무 일 없음
+    pagePipeline: { pipelineGrade: () => undefined, pipelineOwnsCross: () => false }, // 계산 묶음(346-1 · 365-4) — 묶음 없으면 아무 일 없음
     scheduleCrossPreview: () => s.previews++,
     draw: () => s.draws++,
     root: inPopup(),
diff --git a/resources/tester/helper_288_underdrain.cjs b/resources/tester/helper_288_underdrain.cjs
index eaf9c50ed..bcabb6a73 100644
--- a/resources/tester/helper_288_underdrain.cjs
+++ b/resources/tester/helper_288_underdrain.cjs
@@ -107,6 +107,8 @@ process.stdout.write(
     attached,
     sections: sections.map((s) => s.underdrain ?? null),
     outline: draw.underdrainOutline(design, 1),
+    // 371-3 암거 경사 3 % — 하단 = 높은 쪽(좌) 노면 끝 − 1 m 에서 3 % 로 낮은 쪽(우)으로 내림
+    sloped: draw.underdrainOutline(design, 1, 3),
     bothCut: draw.underdrainOutline(bothCut, 1),
     noHeight: draw.underdrainOutline(design, null),
     drew: !!group,
diff --git a/resources/tester/helper_318_cross_card.cjs b/resources/tester/helper_318_cross_card.cjs
index d69a3482d..e176501a4 100644
--- a/resources/tester/helper_318_cross_card.cjs
+++ b/resources/tester/helper_318_cross_card.cjs
@@ -321,6 +321,12 @@ const out = {};
     soil_exists: soil !== null,
     soil_children: soil?.childElementCount ?? null,
   };
+  // 370-3 — 설계선 고름 공용 칸이 오면 그 칸이 왼쪽(암 제어를 따로 안 만듦)
+  const cell = new FakeNode("div");
+  cell.className = "linecell";
+  const cellCard = new FakeNode("article");
+  appendCardFooter(cellCard, { design: { geometry_preset: "rock" } }, {}, {}, cell);
+  out.footer.cell_classes = cellCard.querySelector("footer").children.map((kid) => kid.className);
 }
 
 // ── 3. 단추 줄(318-1) — 빈자리 누름 = 카드 고름 · 조작 누름 = 안 넘김 ───────────
diff --git a/resources/tester/helper_346_3_route_save.cjs b/resources/tester/helper_346_3_route_save.cjs
index ac42504f0..173ab21be 100644
--- a/resources/tester/helper_346_3_route_save.cjs
+++ b/resources/tester/helper_346_3_route_save.cjs
@@ -56,7 +56,7 @@ const STUBS = {
       if (failReplan) throw new Error("체인 실패");
       return {
         route_id: 9,
-        pipes: { kept: 3, crossing: 1, concave: 2 },
+        pipes: { kept: 3, crossing: 1 },
         structures: { moved: 1, far: 0 },
         cross_dropped: 1,
         drainage_stale: true,
diff --git a/resources/tester/helper_347_pipe_id_reconcile.cjs b/resources/tester/helper_347_pipe_id_reconcile.cjs
index dc734afd3..fd84022cb 100644
--- a/resources/tester/helper_347_pipe_id_reconcile.cjs
+++ b/resources/tester/helper_347_pipe_id_reconcile.cjs
@@ -21,7 +21,7 @@ function loadTs(file, real) {
   return box.exports;
 }
 
-const { reconcilePipes } = loadTs(
+const { adoptDraftPipes, reconcilePipes } = loadTs(
   path.join(ROOT, "B05_Profile", "B05_Profile_UI_Drainage_Parts.ts"),
   ["design_selection"],
 );
@@ -35,5 +35,19 @@ process.stdout.write(
     moved: reconcilePipes(before, [100, 250]),
     added: reconcilePipes(before, [100, 200, 300]),
     twoMoved: reconcilePipes(before, [150, 250]),
+    // 369 되돌리기 — 그 걸음 초안이 같은 자리면 초안 속성 · id 를 씀 · 다르면 null
+    adopt: (() => {
+      const next = [
+        { chainage_m: 100, reason: "user" },
+        { chainage_m: 200, reason: "user" },
+      ];
+      const draft = [
+        { chainage_m: 100, id: "a1", facility: "ford_bridge" },
+        { chainage_m: 200.004, id: "b2" },
+      ];
+      return { draft: adoptDraftPipes(draft, next), next };
+    })(),
+    adoptOther: adoptDraftPipes([{ chainage_m: 120, id: "z" }], [{ chainage_m: 100 }]),
+    adoptNone: adoptDraftPipes(null, [{ chainage_m: 100 }]),
   }),
 );
diff --git a/resources/tester/helper_349_drainage_live_flow.cjs b/resources/tester/helper_349_drainage_live_flow.cjs
index 519020dd4..5e7f6af17 100644
--- a/resources/tester/helper_349_drainage_live_flow.cjs
+++ b/resources/tester/helper_349_drainage_live_flow.cjs
@@ -86,7 +86,10 @@ const flush = async () => {
 /* ---- 모듈 읽기(그 자리 트랜스파일 · 바깥 모듈은 가짜) ---- */
 const state = new Map();
 const detailCalls = [];
-let modeRow = 1; // ⚙ 창에서 고를 줄 — 0 수동 · 1 자동
+const detailAutos = []; // [자동 제안](369) 방식 — 없으면 null
+let records = 0; // 사진첩 한 걸음(369)
+let detailStale = false; // detail-basins 가 409 낡음으로 답함(369 — 화면이 몰랐던 낡음)
+let modeRow = 1; // ⚙ · [자동 제안] 창에서 고를 줄 — ⚙ 0 수동 · 1 자동 / 제안 0 전체 · 1 지정 포함
 const stubs = {
   "@config/config_frontend": { API_BASE_URL: "/api" },
   "@ui/ui_template_progress": { createProgressCircle: () => ({ root: el("progress") }) },
@@ -98,14 +101,21 @@ const stubs = {
       body.children[modeRow].children[0].fire("change");
     },
   },
+  "@ui/ui_template_locale": {
+    currentLanguageIndex: 0,
+    ui_locales: new Proxy({}, { get: (_target, key) => [key, key] }),
+  },
+  "./B05_Profile_UI_Profile_History": { pageHistory: () => ({ record: () => (records += 1) }) },
   "../A00_Common/b_page_state": {
     readStateRaw: (key) => state.get(key) ?? null,
     writeStateRaw: (key, value) => state.set(key, value),
   },
   "../B04_PreProcess/B04_PreProcess_Api_Fetch": {
-    computeDetailBasins: async (projectId, points) => {
+    computeDetailBasins: async (projectId, points, auto) => {
       detailCalls.push(points);
-      return { basins: [], pipe_points: points, stale: null };
+      detailAutos.push(auto ?? null);
+      if (detailStale) throw new Error("배수유역 낡음 — 노선이 분석 때와 다릅니다.");
+      return { basins: [], pipe_points: points ?? [], stale: null };
     },
   },
   "./B05_Profile_UI_Drainage_Parts": { analyzeFailed: (_error, fallback) => fallback },
@@ -135,6 +145,8 @@ async function main() {
   const viewport = el("viewport");
   const header = el("header");
   const root = el("root");
+  const propose = el("button");
+  header.querySelector = (selector) => (selector === ".b05-drainage__propose" ? propose : null);
   root.querySelector = (selector) =>
     selector === ".b05-drainage__viewport"
       ? viewport
@@ -280,7 +292,12 @@ async function main() {
   out.autoSavedDone = look();
 
   // 349-0i 되돌리기 — 자동: 끌기 → 낡음 → Ctrl+Z(초안 없어짐) = 3 s 셈 대신 저장분
-  const savedOk = { basins: [], pipe_points: pipes, stale: null };
+  // 저장분 답에도 관경 제안 하나 — [적용] 켜짐은 낡음 · 관경/시설 제안 유무로 갈림(369)
+  const savedOk = {
+    basins: [{ chainage_m: 100, recommended_facility: "pipe", recommended_diameter_mm: 1200 }],
+    pipe_points: pipes,
+    stale: null,
+  };
   stage(draft(20, 300));
   advance(1000);
   stage(null);
@@ -308,6 +325,70 @@ async function main() {
   savedAnswer({ basins: [], pipe_points: pipes, stale: "배수유역 낡음" });
   await flush();
   out.undoSavedStale = { ...look(), savedLoads, mode: state.get("drainage-mode") };
+  // 369 [자동 제안] — 낡은 동안 끔 · ① all · ② add · [배관 배치 초기화] = 관 목록 없이(세류선만)
+  out.proposeStale = { off: propose.disabled, title: propose.title };
+  const beforeStale = detailCalls.length;
+  propose.fire("click");
+  await flush();
+  out.proposeStale.calls = detailCalls.length - beforeStale;
+  live.markFresh();
+  out.proposeFresh = { off: propose.disabled, title: propose.title };
+  const n0 = detailCalls.length;
+  const remembered0 = remembered;
+  const records0 = records;
+  modeRow = 0;
+  propose.fire("click");
+  await flush();
+  modeRow = 1;
+  propose.fire("click");
+  await flush();
+  live.resetToStreams();
+  await flush();
+  out.propose = {
+    autos: detailAutos.slice(n0),
+    points: detailCalls.slice(n0).map((points) => (points === null ? null : points.length)),
+    remembered: remembered - remembered0,
+    records: records - records0,
+  };
+  // 화면이 몰랐던 낡음 — 빠른 길이 409 낡음이면 곧바로 지금 노선으로 셈 길로 다시
+  detailStale = true;
+  modeRow = 0;
+  const fallbackFrom = calls.length;
+  propose.fire("click");
+  await flush();
+  const fallbackCall = calls[calls.length - 1];
+  out.proposeFallback = {
+    sent: calls.length - fallbackFrom,
+    auto: fallbackCall.body.auto,
+    status: status.textContent,
+  };
+  answer(fallbackCall);
+  await flush();
+  detailStale = false;
+  // 저장 분석이 옛 노선(서버 낡음 답) → [업데이트] 뒤 [자동 제안] = 지금 노선으로 셈 길에 방식 실음
+  await runner.run(async () => ({ basins: [], pipe_points: pipes, stale: "배수유역 낡음" }));
+  update.fire("click");
+  answer(calls[calls.length - 1]);
+  await flush();
+  const viaDetail = detailCalls.length;
+  modeRow = 0;
+  propose.fire("click");
+  const liveCall = calls[calls.length - 1];
+  answer(liveCall);
+  await flush();
+  live.resetToStreams();
+  const resetCall = calls[calls.length - 1];
+  answer(resetCall);
+  await flush();
+  out.proposeLive = {
+    auto: liveCall.body.auto,
+    points: liveCall.body.points.length,
+    resetPoints: resetCall.body.points,
+    resetAuto: resetCall.body.auto ?? null,
+    detailCalls: detailCalls.length - viaDetail,
+    remembered: remembered - remembered0,
+    records: records - records0,
+  };
   // 입력 지문 — 판 번호 · 관 차례는 안 봄 · 꼭짓점 · 관 자리(cm) · id 는 봄
   const { inputKey } = load(path.join(B05, "logic", "B05_Profile_Drainage_Live.ts"));
   const a = { id: "a1", chainage_m: 100 };
diff --git a/resources/tester/helper_354_2_masshaul_cross_only.cjs b/resources/tester/helper_354_2_masshaul_cross_only.cjs
index 8a688c9a6..088ea97e2 100644
--- a/resources/tester/helper_354_2_masshaul_cross_only.cjs
+++ b/resources/tester/helper_354_2_masshaul_cross_only.cjs
@@ -23,7 +23,7 @@ const mass = read("B05_Profile", "B05_Profile_UI_Profile_MassHaul.ts");
 let stored = null;
 const src = [
   'const SERIES_BASES = ["cross", "longitudinal"];',
-  'const DEFAULT_VISIBLE = ["cross"];',
+  'const DEFAULT_VISIBLE = ["cross", "balance"];', // 367-1 기본 = 횡단 + 분배
   block(util, "export function normalizeVisibleBasis("),
   block(mass, "function readVisible(): Set<string> {"),
   block(util, "export function computeMassHaulSeries("),
diff --git a/resources/tester/helper_365_page_pipeline.cjs b/resources/tester/helper_365_page_pipeline.cjs
new file mode 100644
index 000000000..8ee5eecee
--- /dev/null
+++ b/resources/tester/helper_365_page_pipeline.cjs
@@ -0,0 +1,403 @@
+/* PLAN 365 단위검증 헬퍼 — 묶음 주인 = 페이지(초안 둔 채 열기 · B06 바로 열기 · 새로고침). 진짜 TS
+ * (`design_pipeline_page` · 단계 파일 전부)를 그 자리에서 트랜스파일해 Node 로 돌림 · 서버 창구만 가짜
+ * (틀 = `helper_346_2_pipeline_cross_page.cjs`). 입력 argv[2] JSON · argv[3] 격자 이진 · 결과 = 표준출력 JSON.
+ * 짝 = `test_365_page_pipeline.py`. */
+const fs = require("fs");
+const path = require("path");
+const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
+const CATALOG = require("./helper_322_catalog_module.cjs");
+
+const ROOT = path.join(__dirname, "..", "..");
+const job = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+
+function memoryStorage() {
+  const map = new Map();
+  return {
+    getItem: (key) => (map.has(key) ? map.get(key) : null),
+    setItem: (key, value) => map.set(key, String(value)),
+    removeItem: (key) => map.delete(key),
+    key: (index) => [...map.keys()][index] ?? null,
+    get length() {
+      return map.size;
+    },
+  };
+}
+globalThis.window = {
+  sessionStorage: memoryStorage(),
+  localStorage: memoryStorage(),
+  setTimeout,
+  clearTimeout,
+};
+
+// 흙 배분 서버 — 늦게 답함 · 끊기면 버림
+const haul = { calls: 0, aborted: 0, answered: 0 };
+globalThis.fetch = (url, init) =>
+  new Promise((resolve, reject) => {
+    haul.calls += 1;
+    const timer = setTimeout(() => {
+      haul.answered += 1;
+      resolve({ ok: true, json: async () => ({ haul_plan: { blocks: [], url } }) });
+    }, job.haulDelayMs);
+    init.signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      haul.aborted += 1;
+      reject(new Error("aborted"));
+    });
+  });
+
+const STUBS = {};
+const cache = new Map();
+function loadTs(full) {
+  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 (CATALOG.isCatalogRequest(request)) return CATALOG;
+    const key = Object.keys(STUBS).find((name) => request.endsWith(name));
+    if (key) return STUBS[key];
+    if (request.startsWith("@config/")) return { API_BASE_URL: "http://fake" };
+    if (request.startsWith("@util/"))
+      return loadTs(path.join(ROOT, "common_util", `${request.slice(6)}.ts`));
+    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);
+  return box.exports;
+}
+const load = (...parts) => loadTs(path.join(ROOT, ...parts));
+
+const sampler = load("common_util", "common_util_surface_sampler.ts");
+const bytes = fs.readFileSync(process.argv[3]);
+const grid = sampler.parseDtmGrid(
+  bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.length),
+);
+const local = { grid, design: "las" };
+
+STUBS["B05_Profile_Api_Replan"] = {
+  analysisTerrain: () => "las",
+  fetchRoutePlan: async () => ({
+    planned: job.line,
+    curves: [],
+    min_radius_m: job.minRadius,
+    station_snap: false,
+  }),
+};
+STUBS["B05_Profile_Api_Structures"] = {
+  fetchStructures: async () => ({ structures: [] }),
+  fetchStructureTypes: async () => job.types,
+};
+STUBS["B05_Profile_Api_TerrainGrid"] = {
+  loadDesignTerrainGrid: async () => local,
+  groundStageDeps: () => ({ grid: () => local, remote: async () => [] }),
+};
+STUBS["B04_PreProcess_Api_Fetch"] = {
+  fetchDetailPipePoints: async () => ({
+    pipe_points: job.pipes.map((pipe) => ({ ...pipe, lonlat: [0, 0] })),
+  }),
+};
+STUBS["B06_Section_UI_Standard_Panel"] = {
+  effectiveStandardCross: () => job.standard,
+  readRockBoundaryDefault: () => -0.5,
+};
+
+const pipeMod = load("A00_Common", "design", "logic", "design_pipeline.ts");
+const pageMod = load("A00_Common", "design", "design_pipeline_page.ts");
+const stationsMod = load("A00_Common", "design", "logic", "design_pipeline_stations.ts");
+const routeGround = load("B05_Profile", "logic", "B05_Profile_Pipeline_RouteGround.ts");
+const grade = load("B05_Profile", "logic", "B05_Profile_Pipeline_Grade.ts");
+const gradeGround = load("B05_Profile", "logic", "B05_Profile_Grade_Ground.ts");
+const detailMod = load("B05_Profile", "logic", "B05_Profile_Pipeline_Detail.ts");
+const alignment = load("B05_Profile", "logic", "B05_Profile_UI_Profile_Alignment.ts");
+const editMod = load("B05_Profile", "B05_Profile_UI_Profile_Edit.ts");
+const page = load("A00_Common", "b_page_state.ts");
+
+const tick = (ms = 0) => new Promise((resolve) => setTimeout(resolve, ms));
+const runs = () => globalThis.__aisloPipeline?.runs ?? [];
+async function settle(count) {
+  for (let i = 0; i < 400; i += 1) {
+    const last = runs()[runs().length - 1];
+    if (runs().length >= count && last && last.outcome !== "running") return last;
+    await tick(5);
+  }
+  throw new Error("묶음이 끝나지 않음");
+}
+const n = job.nodes.length;
+const draftOf = (nodes) => ({
+  nodes,
+  curveOn: Array(n).fill(true),
+  curveRadius: Array(n).fill(null),
+  curveLock: Array(n).fill(null),
+  curveArc: Array(n).fill(null),
+  stationSnap: false,
+});
+const shift = (index, dx, dy) =>
+  job.nodes.map((node, i) => (i === index ? [node[0] + dx, node[1] + dy] : node));
+
+/** 저장 기준 — 저장 노선 지반 첫 계획선(관 측점 포함 · 서버 정책 그대로). */
+async function savedBaseOf() {
+  const seed = pipeMod.createDesignPipeline({
+    stages: {
+      route: routeGround.createRouteStage({
+        minRadiusM: () => job.minRadius,
+        savedLine: () => ({ line: job.line, curves: [] }),
+      }),
+      stations: stationsMod.createStationsStage({
+        intervalM: job.interval,
+        types: () => job.types,
+      }),
+      ground: routeGround.createGroundStage({ grid: () => local, remote: async () => [] }),
+    },
+  });
+  await seed.start({ route: null, alignment: null, cross: null, pipes: job.pipes, structures: [] });
+  const ground = seed.output("ground");
+  seed.dispose();
+  const samples = ground.longitudinal.chainageM.map((c, i) => ({
+    chainage_m: c,
+    elevation_m: ground.longitudinal.z[i],
+  }));
+  const profile = gradeGround.groundProfile(samples);
+  return {
+    policy: job.policy,
+    onlyExplicitCurves: false,
+    basePvi: gradeGround.groundFollowingBasePvi({
+      samples,
+      stations: ground.stations.map((s) => s.chainageM),
+      policy: job.policy,
+    }),
+    chainage: profile.chainage,
+    ground: profile.ground,
+    stations: ground.stations.map((s) => ({
+      station_id: grade.stationIdOf(s.chainageM),
+      chainage_m: s.chainageM,
+    })),
+  };
+}
+
+const store = load("A00_Common", "design", "design_store.ts");
+// B05 오른쪽 횡단 판(365-3) — 그림 조각만 가짜 · 값 고르기는 진짜
+STUBS["b_svg_zoom_pan"] = { attachSvgZoomPan: () => undefined };
+STUBS["B05_Profile_UI_RouteEdit_Cross_Draw"] = { CROSS_PLOT_PAD: {}, summarizeCross: () => "" };
+const pane = load("B05_Profile", "B05_Profile_UI_RouteEdit_Cross.ts");
+const r3 = (value) => (typeof value === "number" ? Math.round(value * 1000) / 1000 : null);
+
+/** 묶음 새 노선 상세(카드가 그리는 것) — 측점 · 계획고 · 절 · 성토 면적. */
+function shownRows(P) {
+  const shown = pageMod.pipelineDetail(P);
+  return (
+    shown &&
+    shown.cross_sections.map((s) => [
+      r3(s.chainage_m),
+      r3(s.design?.design_elevation_m),
+      r3(s.design?.cut_area_m2),
+      r3(s.design?.fill_area_m2),
+    ])
+  );
+}
+
+async function run() {
+  const P = "proj-365";
+  window.localStorage.setItem("frd_current_project_id", P); // 지금 프로젝트(노선 0 칸 자리)
+  const savedBase = await savedBaseOf();
+  const shop = store.useDesignStore(P, null);
+  const holds = [];
+  let unstable = 0;
+  const link = () => ({
+    pipelineSource: () => ({
+      base: savedBase,
+      edits: alignment.emptyEdits(),
+      detail: job.detail,
+      routeId: 7,
+    }),
+    adoptPipeline: () => undefined,
+    redraw: () => undefined,
+  });
+  const options = {
+    stationIntervalM: job.interval,
+    holdDraft: (_routeId, saved) => {
+      holds.push(saved === job.detail ? "saved" : saved ? "other" : "null");
+      return async () => "saved";
+    },
+    onUnstable: () => (unstable += 1),
+  };
+  const open = (label) => {
+    const bridge = pageMod.routeDraftBridge(P, link(), options);
+    pageMod.pipelineEarthwork(P, { conversion: job.conversion });
+    return { bridge, label };
+  };
+  const stationList = () => (shop.get("stations") ?? []).map((s) => r3(s.chainageM));
+
+  // ① B05 길 — 저장 노선으로 열고 노선 꼭짓점 옮김(초안)
+  const first = open("b05");
+  await settle(runs().length + 1);
+  first.bridge.edited(draftOf(shift(1, 8, -6)));
+  await settle(runs().length + 1);
+  await tick(20);
+  const b05 = { rows: shownRows(P), stations: stationList(), holds: [...holds] };
+
+  // ② 떠남(새로고침 · 묶음 메모리 버림) — 세션(가게) 초안은 남음 · 가게 측점은 비워 다시 내는지 봄
+  pageMod.disposePagePipeline(P);
+  const kept = shop.get("routeDraft") !== null;
+  shop.set("stations", null);
+  holds.length = 0;
+
+  // ③ B06 바로 열기 — 페이지가 묶음을 세움(편집기 없음) · 초안 그대로 셈
+  const again = open("b06");
+  const reopenRun = await settle(runs().length + 1);
+  await tick(20);
+  const b06 = {
+    rows: shownRows(P),
+    stations: stationList(),
+    holds: [...holds],
+    outcome: reopenRun.outcome,
+    stages: Object.keys(reopenRun.stages),
+  };
+
+  // ⑤ 초안 동안 B06 고침 — 세션 칸(측점 열쇠) → pipelineCross → 카드(묶음 새 노선 상세)
+  const pipe = pageMod.pagePipeline(P);
+  const target = pipe.output("ground").stations.find((s) => s.kind === "grid" && s.chainageM > 30);
+  const cell = (ground) => ({ [target.key]: { ground_type: ground, section_mode: "left_cut" } });
+  const groundAt = () =>
+    pageMod
+      .pipelineDetail(P)
+      .cross_sections.find((s) => Math.abs(s.chainage_m - target.chainageM) < 1e-3)?.design
+      ?.ground_type ?? null;
+  const before = groundAt();
+  page.writeState("crossdesign", cell("blasting_rock"), P, 7);
+  let mark = runs().length;
+  pageMod.pipelineCross(P);
+  await settle(mark + 1);
+  await tick(20);
+  const edit = {
+    key: target.key,
+    before,
+    after: groundAt(),
+    input: pipe.input("cross").byKey[target.key]?.groundType ?? null,
+    runs: runs().length - mark,
+    sources: runs()[runs().length - 1].sources,
+  };
+  // ⑦ B05 오른쪽 횡단 판 = 묶음 그 측점(카드와 같은 계획고 · 면적)
+  const card = pageMod.pipelineDetail(P).cross_sections;
+  const panes = card.map((section) => {
+    const shown = pane.pipelineCrossAt(pipe, section.chainage_m + 0.4, job.interval, undefined);
+    return [
+      r3(shown?.chainage_m) === r3(section.chainage_m),
+      r3(shown?.design?.design_elevation_m) === r3(section.design?.design_elevation_m),
+      r3(shown?.design?.cut_area_m2) === r3(section.design?.cut_area_m2),
+      shown?.samples.length === section.samples.length,
+    ];
+  });
+  const paneCheck = {
+    count: card.length,
+    same: panes.filter((row) => row.every(Boolean)).length,
+    elevation: r3(
+      pane.pipelineCrossAt(pipe, target.chainageM, job.interval, undefined)?.design
+        ?.design_elevation_m,
+    ),
+  };
+
+  // ⑥ 고리 — 같은 입력 = 0 바퀴 · 세션만 바뀜(알림 없음) = 1 바퀴 · 안 맞음 = 3 바퀴 뒤 알림
+  mark = runs().length;
+  const same = await pageMod.reconcilePagePipeline(P);
+  const sameRuns = runs().length - mark;
+  page.writeState("crossdesign", cell("ripping_rock"), P, 7);
+  mark = runs().length;
+  const once = await pageMod.reconcilePagePipeline(P);
+  const loop = {
+    same,
+    sameRuns,
+    once,
+    onceRuns: runs().length - mark,
+    onceGround: groundAt(),
+  };
+  let n = 0;
+  const realStandard = STUBS["B06_Section_UI_Standard_Panel"].effectiveStandardCross;
+  STUBS["B06_Section_UI_Standard_Panel"].effectiveStandardCross = () => ({
+    ...job.standard,
+    n: (n += 1),
+  });
+  mark = runs().length;
+  loop.unstable = await pageMod.reconcilePagePipeline(P);
+  loop.unstableRuns = runs().length - mark;
+  loop.alerts = unstable;
+  STUBS["B06_Section_UI_Standard_Panel"].effectiveStandardCross = realStandard;
+  await pageMod.reconcilePagePipeline(P);
+
+  // ④ 초안 버림 — 열 때 맡긴 초안 전 상세로 되돌림(저장 정본)
+  again.bridge.edited(null);
+  const dropRun = await settle(runs().length + 1);
+  await tick(20);
+  const dropped = {
+    detail: pageMod.pipelineDetail(P),
+    restoreWhy: dropRun.restoreWhy ?? null,
+    routeDraft: shop.get("routeDraft"),
+  };
+  pageMod.disposePagePipeline(P);
+  page.clearDrafts(P);
+
+  // ⑨ 저장 노선 ▲▼ 한 번 = 횡단 한 벌(365-4) — 묶음 cross 가 다시 셈 창구를 부르고 그 상세 설계를 냄
+  const Q = "proj-365b";
+  window.localStorage.setItem("frd_current_project_id", Q);
+  let refreshCalls = 0;
+  const qBridge = pageMod.routeDraftBridge(Q, link(), {
+    stationIntervalM: job.interval,
+    savedCross: async (detail, _routeId, stations) => {
+      if (!detailMod.detailCross(detail, stations)) return null;
+      refreshCalls += 1;
+      return detailMod.detailCross(detail, stations);
+    },
+  });
+  pageMod.pipelineEarthwork(Q, { conversion: job.conversion });
+  const qPipe = pageMod.pagePipeline(Q);
+  await settle(runs().length + 1);
+  await tick(20);
+  const openCalls = refreshCalls;
+  const key = alignment.chainageKey(savedBase.stations[3].chainage_m);
+  mark = runs().length;
+  pageMod.pipelineGrade(Q, { station_offsets: { [key]: 0.3 }, curve_radii: {} });
+  const gradeRun = await settle(mark + 1);
+  const firstKey = qPipe.output("ground").stations[0].key;
+  const saved = {
+    owns: pageMod.pipelineOwnsCross(Q),
+    openCalls,
+    gradeCalls: refreshCalls - openCalls,
+    runs: runs().length - mark,
+    sources: gradeRun.sources,
+    fromDetail:
+      qPipe.output("cross").byKey[firstKey]?.detail === job.detail.cross_sections[0].design,
+  };
+
+  // ⑧ 중심점 좌우(356-3 꼴) — 노선 한 걸음 → 새 종단이 오면 계획고 맞춤 · 첫 차례는 cross 전에 밀림(무거운 셈 한 번)
+  let graded = false;
+  const stopShift = qPipe.subscribe((event) => {
+    if (event.kind !== "stage" || event.stage !== "profile" || graded) return;
+    if (event.generation !== qPipe.generation) return;
+    graded = true;
+    void Promise.resolve().then(() =>
+      pageMod.pipelineGrade(Q, { station_offsets: { [key]: 0.1 }, curve_radii: {} }),
+    );
+  }, "중심점 좌우");
+  mark = runs().length;
+  qBridge.edited(draftOf(shift(1, 0, 1)));
+  await settle(mark + 2);
+  await tick(job.haulDelayMs + 30);
+  stopShift();
+  const shiftRuns = runs()
+    .slice(mark)
+    .map((r) => ({ outcome: r.outcome, cross: "cross" in r.stages, sources: r.sources }));
+  pageMod.disposePagePipeline(Q);
+  page.clearDrafts(Q);
+  return { kept, b05, b06, dropped, edit, loop, pane: paneCheck, saved, shiftRuns };
+}
+
+run()
+  .then((out) => {
+    process.stdout.write(JSON.stringify(out));
+    process.exit(0);
+  })
+  .catch((error) => {
+    process.stderr.write(String(error && error.stack ? error.stack : error));
+    process.exit(1);
+  });
diff --git a/resources/tester/helper_365_swap.mjs b/resources/tester/helper_365_swap.mjs
new file mode 100644
index 000000000..bdac7b8c1
--- /dev/null
+++ b/resources/tester/helper_365_swap.mjs
@@ -0,0 +1,109 @@
+/* 365-1 헬퍼 — 노선 초안 동안 측점 갈아끼움은 캐시(메모리)만 · 세션 상세 = 저장 노선 그대로.
+ *   node helper_365_swap.mjs <묶음.mjs>
+ * vite ssr 로 묶은 진짜 모듈(helper_365_swap_entry.ts) · 표준출력 JSON 한 벌. 짝 = test_365_page_pipeline.py.
+ */
+import { pathToFileURL } from "node:url";
+
+const store = () => {
+  const m = new Map();
+  return {
+    getItem: (k) => (m.has(k) ? m.get(k) : null),
+    setItem: (k, v) => m.set(k, String(v)),
+    removeItem: (k) => m.delete(k),
+    key: (i) => [...m.keys()][i] ?? null,
+    get length() {
+      return m.size;
+    },
+    clear: () => m.clear(),
+  };
+};
+globalThis.window = globalThis;
+globalThis.sessionStorage = store();
+globalThis.localStorage = store();
+const any = new Proxy(function () {}, {
+  get: (_t, k) => (k === Symbol.toPrimitive ? () => 0 : any),
+  apply: () => any,
+  construct: () => any,
+});
+globalThis.document = any;
+globalThis.requestAnimationFrame = (run) => setTimeout(run, 0);
+
+const m = await import(pathToFileURL(process.argv[2]).href);
+const P = "p365";
+const R = 9;
+localStorage.setItem("frd_current_project_id", P);
+
+const section = (chainage_m, kind) => ({
+  station_id: `station_${String(Math.round(chainage_m * 1000)).padStart(12, "0")}`,
+  chainage_m,
+  label: "",
+  kind,
+  center_z: 100,
+  azimuth_deg: 90,
+  center_x: chainage_m,
+  center_y: 0,
+  frame: { left_xy: [0, 1] },
+  samples: [{ offset_m: 0, elevation_m: 100, valid: true }],
+  design: { design_elevation_m: 101 },
+});
+const saved = {
+  longitudinal: {
+    length_m: 60,
+    stations: [],
+    profile_alignment: { policy: { station_interval_m: 20 } },
+  },
+  cross_sections: [
+    section(0, "bp"),
+    section(20, "regular"),
+    section(40, "regular"),
+    section(60, "ep"),
+  ],
+};
+const station = (key, chainageM, kind) => ({
+  key,
+  chainageM,
+  x: chainageM,
+  y: 0,
+  azimuthDeg: 90,
+  left: [0, 1],
+  kind,
+  id: null,
+  ground: { centerZ: 99, left: [{ offsetM: 0.5, z: 99.1 }], right: [{ offsetM: 0.5, z: 98.9 }] },
+  planRadiusM: null,
+  curveOuterSide: null,
+  curveWideningM: null,
+});
+const list = (...at) =>
+  at.map((c, i) =>
+    station(
+      i === 0 ? "end:BP" : i === at.length - 1 ? "end:EP" : `grid:${c}`,
+      c,
+      i === 0 || i === at.length - 1 ? "end" : "grid",
+    ),
+  );
+const chainages = (detail) => detail?.cross_sections.map((s) => s.chainage_m) ?? null;
+const shop = m.useDesignStore(P, null);
+
+m.writeState("section-detail", saved, P, R);
+await m.loadSectionDetail(P, R); // 세션 한 벌 → 캐시
+const out = {};
+
+// 노선 초안 동안 — 측점 하나 늘어난 목록
+shop.set("routeDraft", { nodes: [], rev: 1 });
+const draft = await m.swapSectionStations(P, R, list(0, 20, 30, 40, 60));
+out.draft = {
+  swapped: draft !== null,
+  cache: chainages(await m.loadSectionDetail(P, R)),
+  session: chainages(m.readState("section-detail", P, R)),
+};
+
+// 초안 없음(저장 노선) — 갈아끼움이 세션까지
+shop.set("routeDraft", null);
+const plain = await m.swapSectionStations(P, R, list(0, 20, 50, 60));
+out.saved = {
+  swapped: plain !== null,
+  cache: chainages(await m.loadSectionDetail(P, R)),
+  session: chainages(m.readState("section-detail", P, R)),
+};
+process.stdout.write(JSON.stringify(out));
+process.exit(0);
diff --git a/resources/tester/helper_365_swap_entry.ts b/resources/tester/helper_365_swap_entry.ts
new file mode 100644
index 000000000..7881d8068
--- /dev/null
+++ b/resources/tester/helper_365_swap_entry.ts
@@ -0,0 +1,7 @@
+/* 365-1 시험 묶음 진입점 — 초안 동안 측점 갈아끼움 = 메모리만(진짜 모듈 · vite ssr). */
+export {
+  loadSectionDetail,
+  swapSectionStations,
+} from "../../B06_Section/B06_Section_Section_Store";
+export { useDesignStore } from "../../A00_Common/design/design_store";
+export { readState, writeState } from "../../A00_Common/b_page_state";
diff --git a/resources/tester/helper_366_3_station_fit.cjs b/resources/tester/helper_366_3_station_fit.cjs
new file mode 100644
index 000000000..37e872e41
--- /dev/null
+++ b/resources/tester/helper_366_3_station_fit.cjs
@@ -0,0 +1,114 @@
+/* 366-3 측점 스냅 = 곡선 가운데(MC)를 일반측점에 — `logic/B05_Profile_RouteEdit_StationFit.ts` 를
+ * Node 로 돌려 JSON 한 줄을 냄(`test_366_3_station_fit.py` 가 판정).
+ * `.cjs` = 루트 package.json 이 "type": "module" 이라서.
+ */
+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) =>
+    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 LOGIC = path.join(ROOT, "B05_Profile", "logic");
+const fit = loadTs(path.join(LOGIC, "B05_Profile_RouteEdit_StationFit.ts"));
+const curve = loadTs(path.join(LOGIC, "B05_Profile_UI_RouteEdit_Curve.ts"));
+const frame = loadTs(path.join(LOGIC, "B05_Profile_UI_RouteEdit_Frame.ts"));
+
+const INTERVAL = 20;
+const LIMITS = { minRadiusM: 30, limitRadiusM: 12, limitArcM: 0, intervalM: INTERVAL };
+// 지그재그 노선 — 꺾임 다섯(교각 다양) · 직선 넉넉
+const ROUTE = [
+  [0, 0],
+  [93, 7],
+  [171, 61],
+  [262, 48],
+  [337, 112],
+  [431, 101],
+  [503, 160],
+];
+
+function columns(planned, lock = []) {
+  const n = planned.length;
+  return {
+    planned,
+    curveOn: planned.map(() => true),
+    curveRadius: planned.map(() => null),
+    curveLock: planned.map(() => null),
+    curveArc: planned.map(() => null),
+    apexLock: planned.map((_, i) => i === 0 || i === n - 1 || lock.includes(i)),
+  };
+}
+
+function measure(planned) {
+  const built = curve.buildEditedPolyline(
+    planned,
+    planned.map(() => true),
+    planned.map(() => null),
+    LIMITS.minRadiusM,
+  );
+  const spans = frame.curveSpans(built.vertices, built.curves);
+  const mcs = spans.map(([a, b]) => (a + b) / 2);
+  const total = frame.stationsAlong(built.vertices, INTERVAL, false);
+  const length = built.vertices.reduce(
+    (sum, v, i) =>
+      i ? sum + Math.hypot(v[0] - built.vertices[i - 1][0], v[1] - built.vertices[i - 1][1]) : 0,
+    0,
+  );
+  return {
+    curves: built.curves.length,
+    mcs,
+    residues: mcs.map((mc) => Math.abs(mc - Math.round(mc / INTERVAL) * INTERVAL)),
+    innerStations: total.filter((s) => s > 0 && s < length).length,
+    off: fit.offStationCount(built.vertices, built.curves, INTERVAL),
+  };
+}
+
+const moved = (a, b) => a.map((v, i) => Math.hypot(v[0] - b[i][0], v[1] - b[i][1]));
+
+const before = measure(ROUTE);
+const all = fit.fitCurveStations(columns(ROUTE), LIMITS, 1);
+const locked = fit.fitCurveStations(columns(ROUTE, [3]), LIMITS, 1);
+const fromLater = fit.fitCurveStations(columns(ROUTE), LIMITS, 4);
+const everyLocked = fit.fitCurveStations(columns(ROUTE, [1, 2, 3, 4, 5]), LIMITS, 1);
+
+console.log(
+  JSON.stringify({
+    before,
+    all: { ...measure(all), moved: moved(ROUTE, all) },
+    locked: { ...measure(locked), moved: moved(ROUTE, locked) },
+    fromLater: { ...measure(fromLater), moved: moved(ROUTE, fromLater) },
+    everyLocked: { ...measure(everyLocked), moved: moved(ROUTE, everyLocked) },
+    again: moved(all, fit.fitCurveStations(columns(all), LIMITS, 1)),
+    noInterval: moved(ROUTE, fit.fitCurveStations(columns(ROUTE), { ...LIMITS, intervalM: 0 }, 1)),
+    start: {
+      moved4: fit.fitStart(
+        columns(ROUTE),
+        columns(ROUTE.map((v, i) => (i === 4 ? [v[0] + 1, v[1]] : v))),
+      ),
+      radius2: fit.fitStart(columns(ROUTE), {
+        ...columns(ROUTE),
+        curveRadius: ROUTE.map((_, i) => (i === 2 ? 40 : null)),
+      }),
+      dropLast: fit.fitStart(columns(ROUTE), columns(ROUTE.filter((_, i) => i !== 5))),
+      same: fit.fitStart(columns(ROUTE), columns(ROUTE)),
+      none: fit.fitStart(null, columns(ROUTE)),
+    },
+  }),
+);
diff --git a/resources/tester/helper_370_2_toe_stop.cjs b/resources/tester/helper_370_2_toe_stop.cjs
new file mode 100644
index 000000000..3d64dda20
--- /dev/null
+++ b/resources/tester/helper_370_2_toe_stop.cjs
@@ -0,0 +1,305 @@
+/* PLAN 370-2 단위검증 헬퍼 — B06 사면 이동 멈춤 · 교차점 손잡이 · 고름 이어받기.
+ * 화면 TS 를 그 자리에서 트랜스파일해 Node 로 돌림 · 결과 = 표준출력 JSON 한 벌.
+ * 입력 = argv[2] 표준단면 JSON(파이썬 config) · 마루 지반(우측 −4 m 너머 내리막). 짝 = `test_370_2_toe_stop.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 STUBS = {
+  "@ui/ui_template_toast": { showToast: () => undefined },
+  "@ui/ui_template_elements": { showToast: () => undefined },
+};
+
+class FakeNode {
+  constructor(tag) {
+    this.tagName = String(tag);
+    this.children = [];
+    this.attrs = {};
+    this.listeners = {};
+    this.hidden = false;
+    this.title = "";
+    this._text = "";
+    this._classes = new Set();
+    const self = this;
+    this.classList = {
+      add: (...names) => names.forEach((n) => self._classes.add(n)),
+      remove: (...names) => names.forEach((n) => self._classes.delete(n)),
+      toggle: (name, force) => {
+        const on = force === undefined ? !self._classes.has(name) : !!force;
+        on ? self._classes.add(name) : self._classes.delete(name);
+        return on;
+      },
+      contains: (name) => self._classes.has(name),
+    };
+    this.style = { setProperty: () => {} };
+  }
+  set className(value) {
+    this._classes = new Set(String(value).split(/\s+/).filter(Boolean));
+  }
+  get className() {
+    return [...this._classes].join(" ");
+  }
+  set textContent(value) {
+    this._text = String(value);
+    this.children = [];
+  }
+  get textContent() {
+    return this._text + this.children.map((c) => c.textContent).join("");
+  }
+  get childElementCount() {
+    return this.children.length;
+  }
+  get isConnected() {
+    return true;
+  }
+  _detach(kid) {
+    if (kid.parent) kid.parent.children = kid.parent.children.filter((k) => k !== kid);
+    kid.parent = this;
+  }
+  append(...kids) {
+    kids.forEach((k) => {
+      if (typeof k === "string") return;
+      this._detach(k);
+      this.children.push(k);
+    });
+  }
+  prepend(...kids) {
+    kids.reverse().forEach((k) => {
+      this._detach(k);
+      this.children.unshift(k);
+    });
+  }
+  appendChild(kid) {
+    this.append(kid);
+    return kid;
+  }
+  insertBefore(kid, ref) {
+    this._detach(kid);
+    const at = ref ? this.children.indexOf(ref) : -1;
+    if (at < 0) this.children.push(kid);
+    else this.children.splice(at, 0, kid);
+    return kid;
+  }
+  remove() {
+    if (this.parent) this.parent.children = this.parent.children.filter((k) => k !== this);
+  }
+  querySelector() {
+    return null;
+  }
+  setAttribute(name, value) {
+    this.attrs[name] = String(value);
+    if (name === "class") this.className = value;
+  }
+  getAttribute(name) {
+    return name === "class" ? this.className : (this.attrs[name] ?? null);
+  }
+  hasAttribute(name) {
+    return name in this.attrs;
+  }
+  addEventListener(type, fn) {
+    (this.listeners[type] ??= []).push(fn);
+  }
+  click() {
+    const event = { stopPropagation: () => {}, preventDefault: () => {} };
+    (this.listeners.click ?? []).forEach((fn) => fn(event));
+  }
+}
+globalThis.document = {
+  createElement: (tag) => new FakeNode(tag),
+  createElementNS: (_ns, tag) => new FakeNode(tag),
+  addEventListener: () => {},
+  removeEventListener: () => {},
+};
+globalThis.window = { setTimeout, clearTimeout, addEventListener: () => {} };
+
+function loadTs(file) {
+  const full = path.resolve(file);
+  if (cache.has(full)) return cache.get(full);
+  if (full.endsWith(".json")) {
+    const data = JSON.parse(fs.readFileSync(full, "utf8"));
+    cache.set(full, data);
+    return data;
+  }
+  const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2020,
+      esModuleInterop: true,
+    },
+  }).outputText;
+  const box = { exports: {} };
+  cache.set(full, box.exports);
+  const localRequire = (request) => {
+    if (STUBS[request]) return STUBS[request];
+    if (request.endsWith(".css")) return {};
+    const alias = { "@util/": "common_util", "@ui/": "ui_template", "@config/": "config" };
+    for (const [prefix, dir] of Object.entries(alias))
+      if (request.startsWith(prefix))
+        return loadTs(resolve(path.join(ROOT, dir, request.slice(prefix.length))));
+    return loadTs(resolve(path.join(path.dirname(full), request)));
+  };
+  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
+  cache.set(full, box.exports);
+  return box.exports;
+}
+const resolve = (base) =>
+  [base, `${base}.ts`, path.join(base, "index.ts")].find(
+    (p) => fs.existsSync(p) && fs.statSync(p).isFile(),
+  ) ?? `${base}.ts`;
+
+const B06 = (f) => path.join(ROOT, "B06_Section", `${f}.ts`);
+const pick = loadTs(B06("B06_Section_UI_Cross_Design_Pick"));
+const fit = loadTs(B06("logic/B06_Section_UI_Cross_Fit"));
+const { appendCrossDesignOverlay } = loadTs(B06("B06_Section_UI_Cross_Design"));
+const { computeCrossDesign } = loadTs(
+  path.join(ROOT, "common_util", "common_util_cross_design.ts"),
+);
+const standard = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+const out = {};
+
+// 마루 지반 — 우측 −4 m 까지 평지(노면보다 높음 = 절토) · 그 너머 1:0.6 내리막
+const samples = Array.from({ length: 49 }, (_, i) => {
+  const o = -12 + i * 0.5;
+  return { offset_m: o, elevation_m: 100.3 - 0.6 * Math.max(0, -o - 4), valid: true };
+});
+const groundAt = (o) => 100.3 - 0.6 * Math.max(0, -o - 4);
+const designOf = (extendRight) => {
+  const result = computeCrossDesign(samples, 100, {
+    standard,
+    groundType: "soil",
+    sectionMode: "right_cut",
+    ditchSide: "right",
+    shoulderExtendRightM: extendRight,
+  });
+  // 화면 design 칸 이름(저장 · 응답과 같음)
+  return { ...result, shoulder_extend_right_m: extendRight, shoulder_extend_left_m: 0 };
+};
+const section = (extendRight) => ({
+  station_id: "S1",
+  chainage_m: 20,
+  samples,
+  design: designOf(extendRight),
+});
+
+// ① 멈춤 — 우측 노견 끝이 원지반을 지나는 한 걸음 사이 → 그 자리
+const gapAt = (design, e) => {
+  const { left, right } = design.road_edges;
+  const o = -(Math.abs(right.offset_m) - (design.shoulder_extend_right_m ?? 0) + e);
+  const plane =
+    right.elevation_m +
+    ((left.elevation_m - right.elevation_m) * (o - right.offset_m)) /
+      (left.offset_m - right.offset_m);
+  return groundAt(o) - plane;
+};
+const base = designOf(0);
+let crossing = null;
+for (let e = 0; e < 6; e = Math.round((e + 0.1) * 10) / 10) {
+  if (Math.sign(gapAt(base, e)) !== Math.sign(gapAt(base, e + 0.1))) {
+    crossing = [e, Math.round((e + 0.1) * 10) / 10];
+    break;
+  }
+}
+const stop = fit.extendStop(
+  samples,
+  designOf(crossing[0]).road_edges,
+  "right",
+  crossing[0],
+  crossing[1],
+);
+out.stop = {
+  crossing,
+  value: stop,
+  gap: Math.abs(gapAt(base, stop)),
+  noCross: fit.extendStop(samples, base.road_edges, "right", 0, 0.1),
+  // 멈춘 자리에서 다음 걸음은 그대로 감(다시 안 섬)
+  fromStop: fit.extendStop(
+    samples,
+    designOf(stop).road_edges,
+    "right",
+    stop,
+    Math.round((stop + 0.1) * 10) / 10,
+  ),
+  leftNoGround: fit.extendStop([], base.road_edges, "left", 0, 0.1),
+};
+
+// ② 교차점 손잡이 — 쪽마다 원 · 늘 보임 · 키 toe:left|right · 고르면 ◀▶ 가 멈춤 자리로 보냄
+const x = (o) => 300 - o * 20;
+const y = (e) => 400 - (e - 100) * 20;
+const attach = (sec, changes) => {
+  const layer = new FakeNode("g");
+  const from = layer.childElementCount;
+  appendCrossDesignOverlay(layer, sec.design, x, y, sec.samples, undefined);
+  layer.children.slice(from).forEach((el) => el.setAttribute(pick.DESIGN_LINE_ATTR, ""));
+  const picks = [];
+  const handle = pick.attachDesignLinePick({
+    layer,
+    design: sec.design,
+    x,
+    toDisplayY: y,
+    onPick: (i) => picks.push(i),
+    ...pick.designLineMoves(sec, (_chainage, change) => changes.push(change)),
+  });
+  return { layer, handle, picks };
+};
+const changes = [];
+const near = section(crossing[0]);
+const { layer, handle, picks } = attach(near, changes);
+const toes = layer.children.filter((k) => k.classList.contains("b06-chart__toe-hit"));
+const keys = pick.designLineMoves(near, () => undefined).toes;
+out.toe = {
+  count: toes.length,
+  centerClass: toes.every((t) => t.classList.contains("b06-chart__center-hit")),
+  sides: ["left", "right"].filter((s) => keys[s]),
+  rightOnGround:
+    keys.right && Math.abs(keys.right.elevation_m - groundAt(keys.right.offset_m)) < 1e-9,
+  rightCx: toes.length === 2 ? Number(toes[1].getAttribute("cx")) : null,
+  rightX: keys.right ? x(keys.right.offset_m) : null,
+};
+toes[1].click();
+handle.setActive(picks[0]);
+// 아래 띠 공용 칸(370-3) — 제목 · 버튼 줄(끝 = 값 글)
+const cellOf = (h) => ({
+  title: h.cell.children[0].textContent,
+  value: h.cell.children[1].children.at(-1).textContent,
+  button: (slot) =>
+    h.cell.children[1].children.find((k) =>
+      k.classList.contains(`b06-cross-card__cell-btn--${slot}`),
+    ),
+});
+const cell = cellOf(handle);
+cell.button(x(-1) > x(0) ? "right" : "left").click(); // 화면 → 바깥(우 = −offset)
+out.toePick = {
+  picked: picks,
+  active: toes[1].classList.contains("is-active"),
+  value: cell.value,
+  title: cell.title,
+  panelOpen: !handle.cell.classList.contains("is-empty"),
+  sent: changes.map((c) => c.shoulder_extend),
+};
+
+// ③ 고름 이어받기 — 우 절토 사면을 고른 뒤 마루 너머로 옮기면(키 cut → fill) 같은 쪽 손잡이
+const cutIndex = handle.pieces.findIndex(
+  (p) =>
+    pick.pieceZone(near.design, p).zone === "cut" &&
+    pick.pieceZone(near.design, p).side === "right",
+);
+pick.setPickedLine("S1", null);
+attach(near, []); // 키 적음
+pick.setPickedLine("S1", cutIndex);
+const before = pick.pickedLineAt("S1");
+const far = section(crossing[1] + 1.0);
+const after = attach(far, []);
+const afterIndex = pick.pickedLineAt("S1");
+out.inherit = {
+  cutIndex,
+  before,
+  farMode: far.design.section_mode,
+  afterIndex,
+};
+after.handle.setActive(afterIndex);
+out.inherit.label = cellOf(after.handle).title;
+
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_370_3_rock_cell.cjs b/resources/tester/helper_370_3_rock_cell.cjs
new file mode 100644
index 000000000..bce0124f2
--- /dev/null
+++ b/resources/tester/helper_370_3_rock_cell.cjs
@@ -0,0 +1,310 @@
+/* PLAN 370-3 단위검증 헬퍼 — B06 암 경계선 고름 · 방향키 · 세로 끌기 · 아래 띠 공용 칸.
+ * `_Cross_Design_Pick.attachDesignLinePick` 을 그 자리에서 트랜스파일해 흉내 DOM 으로 돌림. 짝 = `test_370_3_rock_cell.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();
+
+class Node {
+  constructor(tag) {
+    this.tagName = tag;
+    this.children = [];
+    this.attrs = {};
+    this.listeners = {};
+    this.hidden = false;
+    this.isConnected = true;
+    this._text = "";
+    this._cls = new Set();
+    const self = this;
+    this.classList = {
+      add: (...n) => n.forEach((c) => self._cls.add(c)),
+      toggle: (c, on) => ((on ?? !self._cls.has(c)) ? self._cls.add(c) : self._cls.delete(c)),
+      contains: (c) => self._cls.has(c),
+    };
+  }
+  get descendants() {
+    return this.children.flatMap((c) => [c, ...c.descendants]);
+  }
+  /** `.이름` 한 개만 — 패널 공용 부품이 슬롯 단추를 찾는 꼴. */
+  querySelector(sel) {
+    return this.descendants.find((n) => n._cls.has(sel.slice(1))) ?? null;
+  }
+  getClientRects() {
+    return this._cls.has("is-hidden") ? [] : [{}];
+  }
+  set className(v) {
+    this._cls = new Set(String(v).split(/\s+/).filter(Boolean));
+  }
+  set textContent(v) {
+    this._text = String(v);
+  }
+  get textContent() {
+    return this._text + this.children.map((c) => c.textContent).join("");
+  }
+  append(...kids) {
+    this.children.push(...kids);
+  }
+  insertBefore(kid) {
+    this.children.push(kid);
+  }
+  setAttribute(n, v) {
+    this.attrs[n] = String(v);
+    if (n === "class") this.className = v;
+  }
+  getAttribute(n) {
+    return this.attrs[n] ?? null;
+  }
+  hasAttribute(n) {
+    return n in this.attrs;
+  }
+  addEventListener(t, fn) {
+    (this.listeners[t] ??= []).push(fn);
+  }
+  click() {
+    (this.listeners.click ?? []).forEach((fn) => fn({ stopPropagation: () => undefined }));
+  }
+}
+const docListeners = {};
+globalThis.document = {
+  createElement: (t) => new Node(t),
+  createElementNS: (_n, t) => new Node(t),
+  addEventListener: (t, fn) => (docListeners[t] ??= []).push(fn),
+  removeEventListener: (t, fn) => {
+    docListeners[t] = (docListeners[t] ?? []).filter((f) => f !== fn);
+  },
+};
+const key = (name) =>
+  [...(docListeners.keydown ?? [])].forEach((fn) =>
+    fn({ key: name, target: null, preventDefault: () => 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 req = (r) =>
+    r.startsWith("@util/")
+      ? loadTs(path.join(ROOT, "common_util", `${r.slice(6)}.ts`))
+      : loadTs(path.join(path.dirname(full), `${r}.ts`));
+  new Function("exports", "module", "require", js)(box.exports, box, req);
+  cache.set(full, box.exports);
+  return box.exports;
+}
+globalThis.Element = Node;
+
+const pick = loadTs(path.join(ROOT, "B06_Section", "B06_Section_UI_Cross_Design_Pick.ts"));
+const x = (o) => 100 - o * 12; // +offset = 화면 왼쪽
+const y = (e) => 900 - (e - 100) * 12;
+const line = (pts, structure = false) => {
+  const el = new Node("polyline");
+  el.setAttribute("class", "b06-chart__design-cross");
+  el.setAttribute("points", pts.map(([o, e]) => `${x(o)},${y(e)}`).join(" "));
+  if (!structure) el.setAttribute(pick.DESIGN_LINE_ATTR, "");
+  return el;
+};
+/** 방향키 한 번 — 막혔나(preventDefault) 돌려줌. */
+/** 방향키 한 번 — 막혔나(preventDefault) 돌려줌. */
+const press = (name) => {
+  let prevented = false;
+  [...(docListeners.keydown ?? [])].forEach((fn) =>
+    fn({ key: name, target: null, preventDefault: () => (prevented = true) }),
+  );
+  return prevented;
+};
+// 끌기 — window 듣개(놓을 때 click 한 번 막음 포함)
+const winListeners = {};
+globalThis.window = {
+  addEventListener: (t, fn) => (winListeners[t] ??= []).push(fn),
+  removeEventListener: (t, fn) => {
+    winListeners[t] = (winListeners[t] ?? []).filter((f) => f !== fn);
+  },
+  setTimeout: () => 0,
+  clearTimeout: () => undefined,
+  setInterval: () => 0,
+  clearInterval: () => undefined,
+};
+globalThis.setTimeout = () => 0;
+const fire = (type, event) => [...(winListeners[type] ?? [])].forEach((fn) => fn(event));
+
+/** 암 측점 카드 — 좌 사면 · 노면 · 우 사면 + 암 경계선 점선 두 토막(결측으로 끊김). */
+function card(rockOn = true) {
+  docListeners.keydown = [];
+  const design = {
+    road_edges: {
+      left: { offset_m: 2, elevation_m: 100 },
+      right: { offset_m: -2, elevation_m: 100 },
+    },
+    ditch: null,
+    ditch_side: "left",
+    ditch_enabled: false,
+    section_mode: "both_fill",
+  };
+  const layer = new Node("g");
+  layer.getScreenCTM = () => ({ a: 1, d: 1 });
+  layer.append(
+    line([
+      [6, 97],
+      [2, 100],
+    ]),
+    line([
+      [2, 100],
+      [-2, 100],
+    ]),
+    line([
+      [-2, 100],
+      [-6, 97],
+    ]),
+  );
+  const rockLine = (pts) => {
+    const el = new Node("polyline");
+    el.setAttribute("class", "b06-chart__rock-boundary");
+    el.setAttribute("points", pts.map(([o, e]) => `${x(o)},${y(e)}`).join(" "));
+    el.style = { setProperty: (k, v) => (el.styleSet = v) };
+    return el;
+  };
+  const rocks = [
+    rockLine([
+      [8, 96],
+      [1, 98],
+    ]),
+    rockLine([
+      [-1, 98],
+      [-8, 96],
+    ]),
+  ];
+  layer.append(...rocks);
+  const offsets = [];
+  const resets = [];
+  const rock = {
+    legend: "암 경계선",
+    offsetM: -0.5,
+    stepM: 0.1,
+    upTitle: "위로",
+    downTitle: "아래로",
+    resetTitle: "기본",
+    adjust: (d) => offsets.push(Math.round(d * 100) / 100),
+    reset: () => resets.push(true),
+  };
+  const values = { left: 0, right: 0 };
+  const picks = [];
+  const handle = pick.attachDesignLinePick({
+    layer,
+    design,
+    x,
+    toDisplayY: y,
+    onPick: (i) => picks.push(i),
+    shift: { valueOf: (s) => values[s], set: (s, v) => (values[s] = v) },
+    stationId: "R1",
+    ...(rockOn && { rock }),
+  });
+  const cell = handle.cell;
+  const slot = (name) => cell.querySelector(`.b06-cross-card__cell-btn--${name}`);
+  const state = () => ({
+    empty: cell.classList.contains("is-empty"),
+    title: cell.children[0].textContent,
+    value: cell.children[1].children.at(-1).textContent,
+    slots: ["left", "up", "reset", "down", "right"].filter((n) => !slot(n).hidden),
+    arrowSlots: ["left", "up", "reset", "down", "right"].filter((n) =>
+      slot(n).classList.contains(`b06-structure-panel__btn--${n}`),
+    ),
+  });
+  const hits = layer.children.filter((k) => k.classList.contains("b06-chart__design-hit"));
+  const rockHit = hits.find((k) => k.classList.contains("b06-chart__rock-hit"));
+  if (rockHit) rockHit.style = { setProperty: (k, v) => (rockHit.styleSet = v) };
+  return { handle, cell, slot, state, hits, rockHit, rocks, offsets, resets, values, picks };
+}
+
+const out = {};
+
+// ① 안 고름 — 공용 칸 = 암 ▲▼↺ · 값 · 방향키는 안 먹음(종단 계획고로 그대로)
+{
+  const c = card();
+  c.handle.setActive(null);
+  out.idle = { ...c.state(), upPassed: !press("ArrowUp") };
+  c.slot("up").click();
+  c.slot("down").click();
+  c.slot("reset").click();
+  out.idle.offsets = c.offsets;
+  out.idle.resets = c.resets.length;
+}
+
+// ② 판정 선 — 점선 위 path 하나(끊긴 두 토막 · M 둘) · 보라 선 판정 클래스 · 키 rock
+{
+  const c = card();
+  const index = c.hits.indexOf(c.rockHit);
+  c.rockHit.click();
+  out.hit = {
+    found: !!c.rockHit,
+    tag: c.rockHit?.tagName,
+    moves: (c.rockHit?.getAttribute("d").match(/M/g) ?? []).length,
+    last: index === c.hits.length - 1,
+    picked: c.picks,
+  };
+  // ③ 고름 — 제목 · ▲▼↺ · ◀▶ 막음 · ▲▼ = 암만(종단으로 안 샘)
+  c.handle.setActive(index);
+  pick.setPickedLine("R1", index);
+  out.picked = {
+    ...c.state(),
+    active: c.rockHit.classList.contains("is-active"),
+    leftBlocked: press("ArrowLeft"),
+    rightBlocked: press("ArrowRight"),
+    upTaken: press("ArrowUp"),
+    downTaken: press("ArrowDown"),
+    sideValues: { ...c.values },
+    key: pick.pickedLineAt("R1") === index,
+  };
+  out.picked.offsets = c.offsets;
+  // ④ 세로 끌기 — 위로 0.34 m(화면 px = m × 12) → 0.3 m 한 번 · 끄는 동안 점선 · 판정 선만 옮겨 보임
+  let stopped = false;
+  c.rockHit.listeners.pointerdown[0]({
+    button: 0,
+    clientX: 0,
+    clientY: 500,
+    preventDefault: () => undefined,
+    stopPropagation: () => (stopped = true),
+  });
+  fire("pointermove", { clientX: 0, clientY: 500 - 0.34 * 12 });
+  const during = { rock: c.rocks[0].styleSet, hit: c.rockHit.styleSet, value: c.state().value };
+  const before = c.offsets.length;
+  fire("pointerup", {});
+  out.drag = {
+    stopped,
+    during,
+    sent: c.offsets.slice(before),
+    clickSwallowed: (winListeners.click ?? []).length === 1,
+  };
+  // 풀면 다시 암 칸 · 방향키 안 먹음
+  c.handle.setActive(null);
+  out.released = { ...c.state(), upPassed: !press("ArrowUp") };
+  // 사면을 고르면 그 선 칸(제목 · ◀↺▶ · 값 한 줄)
+  const slope = c.handle.pieces.findIndex((p) => Math.max(p.from.offset, p.to.offset) > 3);
+  c.handle.setActive(slope);
+  out.slope = c.state();
+  pick.setPickedLine("R1", null);
+}
+
+// ⑤ 안 고른 끌기는 안 감(카드 팬) · 토사(암 없음) = 빈 칸 · 판정 선 없음
+{
+  const c = card();
+  c.handle.setActive(null);
+  let stopped = false;
+  c.rockHit.listeners.pointerdown[0]({
+    button: 0,
+    clientY: 0,
+    preventDefault: () => undefined,
+    stopPropagation: () => (stopped = true),
+  });
+  out.idleDrag = { stopped };
+  const soil = card(false);
+  soil.handle.setActive(null);
+  out.soil = { ...soil.state(), rockHit: !!soil.rockHit };
+}
+
+process.stdout.write(JSON.stringify(out));
diff --git a/resources/tester/helper_371_2_pipe_slope.cjs b/resources/tester/helper_371_2_pipe_slope.cjs
new file mode 100644
index 000000000..23be4ef11
--- /dev/null
+++ b/resources/tester/helper_371_2_pipe_slope.cjs
@@ -0,0 +1,120 @@
+/* 371-2 관 글 기울기 헬퍼 — 짝 = `test_371_2_pipe_slope_text.py`.
+ * B07 픽스처 배관 측점에 `appendCulvertOverlay` 를 가짜 SVG 로 그려 관 글 · 툴팁을 읽음.
+ */
+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 noop = new Proxy({}, { get: () => () => "" });
+
+/** 아주 작은 SVG 가짜 — 글 자리 판정에 쓰는 것만(class 고르기 · 속성 · 부모). */
+class El {
+  constructor(tag) {
+    this.tag = tag;
+    this.attrs = {};
+    this.children = [];
+    this.parentNode = null;
+    this.ownerSVGElement = null;
+    this.textContent = "";
+  }
+  setAttribute(k, v) {
+    this.attrs[k] = String(v);
+  }
+  getAttribute(k) {
+    return this.attrs[k] ?? null;
+  }
+  appendChild(c) {
+    c.parentNode = this;
+    c.ownerSVGElement = this.tag === "svg" ? this : this.ownerSVGElement;
+    this.children.push(c);
+    return c;
+  }
+  append(...cs) {
+    cs.forEach((c) => this.appendChild(c));
+  }
+  addEventListener() {}
+  all() {
+    return this.children.flatMap((c) => [c, ...c.all()]);
+  }
+  querySelectorAll(sel) {
+    return this.all().filter((e) => (e.attrs.class ?? "").split(" ").includes(sel.slice(1)));
+  }
+  querySelector(sel) {
+    return this.querySelectorAll(sel)[0] ?? null;
+  }
+}
+globalThis.document = { addEventListener: () => undefined, createElementNS: (_ns, t) => new El(t) };
+
+function loadTs(file) {
+  const full = path.resolve(file);
+  if (cache.has(full)) return cache.get(full);
+  if (full.endsWith(".json")) return JSON.parse(fs.readFileSync(full, "utf8"));
+  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 resolve = (base) =>
+    fs.existsSync(base) && fs.statSync(base).isFile() ? base : `${base}.ts`;
+  const req = (r) => {
+    if (r.startsWith("@ui/") || r.startsWith("@config/")) return noop;
+    if (r.startsWith("@util/")) return loadTs(resolve(path.join(ROOT, "common_util", r.slice(6))));
+    return loadTs(resolve(path.join(path.dirname(full), r)));
+  };
+  new Function("exports", "module", "require", js)(box.exports, box, req);
+  cache.set(full, box.exports);
+  return box.exports;
+}
+
+const { computeCulvertLayout } = loadTs(
+  path.join(ROOT, "B06_Section", "B06_Section_UI_Cross_Culvert_Geom.ts"),
+);
+const { appendCulvertOverlay } = loadTs(
+  path.join(ROOT, "B06_Section", "B06_Section_UI_Cross_Culvert.ts"),
+);
+const sections = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "fixtures", "b07_cross_overlay_sections.json"), "utf8"),
+).cross_sections;
+const section = sections.find((s) => s.culvert && !s.culvert.hidden_pipe);
+
+/** 노폭 라벨이 있는 B06 카드 꼴 svg 에 그려 관 글 · 관 툴팁을 돌려줌. */
+function draw(layout, hidePipe) {
+  const svg = new El("svg");
+  const road = new El("text");
+  road.setAttribute("class", "b06-chart__carriageway-label");
+  road.setAttribute("x", 200);
+  road.setAttribute("y", 180);
+  svg.appendChild(road);
+  const plot = new El("g");
+  svg.appendChild(plot);
+  appendCulvertOverlay(
+    plot,
+    layout,
+    (o) => o,
+    (z) => z,
+    undefined,
+    hidePipe,
+    false,
+  );
+  const titles = svg
+    .all()
+    .filter((e) => e.tag === "title")
+    .map((e) => e.textContent);
+  return {
+    infos: svg.querySelectorAll(".b06-chart__pipe-info").map((e) => e.textContent),
+    pipeTips: titles.filter((t) => t.startsWith("관매설")),
+  };
+}
+const layout = computeCulvertLayout(section, section.samples);
+const reverse = { ...layout, pipe: { ...layout.pipe, slopePct: -0.43 } };
+process.stdout.write(
+  JSON.stringify({
+    slopePct: layout.pipe.slopePct,
+    lengthM: layout.pipe.lengthM,
+    pipe: draw(layout, false),
+    reverse: draw(reverse, false),
+    hidden: draw(layout, true),
+  }),
+);
diff --git a/resources/tester/helper_b05_routeedit_cross_width.cjs b/resources/tester/helper_b05_routeedit_cross_width.cjs
index a610047b4..baa25097f 100644
--- a/resources/tester/helper_b05_routeedit_cross_width.cjs
+++ b/resources/tester/helper_b05_routeedit_cross_width.cjs
@@ -1,6 +1,7 @@
 /* 계획노선 편집 창 **측점 반폭 선 길이**(계획서 22-1) 단위검증 헬퍼 —
  * `B05_Profile_UI_RouteEdit_Cross.ts` 를 트랜스파일해 Node 로 돌린다.
- * 서버 묻기 · 그림 조각은 가짜로 채운다 — 「무슨 반폭을 묻고 · 무슨 반폭으로 선을 잡나」만 본다.
+ * 계산 묶음 · 그림 조각은 가짜로 채운다 — 「무슨 반폭으로 선을 잡나」만 본다(365-3 · 서버 길 없음 ·
+ * 묶음 그 측점 원지반 표본 = 좌우 20 m).
  */
 const fs = require("fs");
 const path = require("path");
@@ -56,7 +57,6 @@ globalThis.ResizeObserver = class {
   disconnect() {}
 };
 
-const asked = [];
 const STUBS = {
   "../A00_Common/b_svg_zoom_pan": { attachSvgZoomPan: () => {} },
   "../common_util/common_util_station": { stationLabel: (m) => String(m) },
@@ -65,17 +65,24 @@ const STUBS = {
     CROSS_PLOT_PAD: 0,
     summarizeCross: () => "",
   },
-  // 서버 흉내 — 요청 반폭을 그대로 되돌려 주고, 없으면 기본 20.
-  "./B05_Profile_Api_Replan": {
-    fetchCrossPreview: async (_project, request) => {
-      asked.push(request.cross_half_width_m ?? null);
-      return {
-        chainage_m: request.chainage_m,
-        cross_half_width_m: request.cross_half_width_m ?? 20,
-        samples: [],
-        design: null,
-      };
-    },
+  // 계산 묶음 흉내 — 측점 하나(100 m) · 원지반 표본 좌우 20 m
+  "../A00_Common/design/design_pipeline_page": {
+    pagePipeline: () => ({
+      output: (name) =>
+        name === "ground" ? { stations: [{ key: "grid:5", chainageM: 100 }] } : null,
+      input: () => null,
+      subscribe: () => () => undefined,
+    }),
+  },
+  "../A00_Common/design/design_store": {
+    useDesignStore: () => ({ subscribe: () => () => undefined }),
+  },
+  "./logic/B05_Profile_Pipeline_Detail": {
+    stationSection: (station) => ({
+      chainage_m: station.chainageM,
+      label: null,
+      samples: [-20, 0, 20].map((offset_m) => ({ offset_m, elevation_m: 100, valid: true })),
+    }),
   },
 };
 
@@ -111,17 +118,17 @@ async function run() {
   const out = {};
   out.before = cross.watched();
   await cross.open(100);
-  out.empty = { asked: asked.at(-1), watched: cross.watched() };
+  out.empty = { watched: cross.watched() };
   session.setItem("aislo:draft:cross-display:p-1:3", "15");
   await cross.refresh();
-  out.applied15 = { asked: asked.at(-1), watched: cross.watched() };
+  out.applied15 = { watched: cross.watched() };
   session.setItem("aislo:draft:cross-display:p-1:12", "8.5");
   session.setItem("aislo:draft:cross-display:p-2:99", "40");
   await cross.refresh();
-  out.latestRoute = { asked: asked.at(-1), watched: cross.watched() };
+  out.latestRoute = { watched: cross.watched() };
   session.setItem("aislo:draft:cross-display:p-1:12", "abc");
   await cross.refresh();
-  out.badValue = { asked: asked.at(-1), watched: cross.watched() };
+  out.badValue = { watched: cross.watched() };
   return out;
 }
 run().then((out) => console.log(JSON.stringify(out)));
diff --git a/resources/tester/helper_design_view_parity.cjs b/resources/tester/helper_design_view_parity.cjs
index 14d3a32da..17faa20ad 100644
--- a/resources/tester/helper_design_view_parity.cjs
+++ b/resources/tester/helper_design_view_parity.cjs
@@ -125,7 +125,7 @@ const LOCALES = {
   B06_Profile_Btn_Save: ["저장", "Save"],
   B06_Profile_Btn_Confirm: ["확정", "Confirm"],
   Design_Btn_ToCross: ["횡단 보기", "Cross view"],
-  Design_Btn_ToProfile: ["종단 보기", "Profile view"],
+  Design_Btn_ToProfile: ["노선 보기", "Route view"],
 };
 const STUBS = {
   "@ui/ui_template_locale": { ui_locales: LOCALES, currentLanguageIndex: 0 },
diff --git a/resources/tester/test_133_1_analysis_terrain.py b/resources/tester/test_133_1_analysis_terrain.py
index eba2b8ab9..896998426 100644
--- a/resources/tester/test_133_1_analysis_terrain.py
+++ b/resources/tester/test_133_1_analysis_terrain.py
@@ -138,10 +138,6 @@ def test_수치지형도_서피스_없으면_라이다만(tmp_path):
 def test_허용_목록_밖_거절(bad):
     with pytest.raises(ValidationError):
         terrain_router.ElevationRequest(points=[(0.0, 0.0)], terrain=bad)
-    with pytest.raises(ValidationError):
-        terrain_router.CrossPreviewRequest(
-            vertices=[{"x": 0, "y": 0}, {"x": 1, "y": 1}], chainage_m=0, terrain=bad
-        )
     with pytest.raises(ValidationError):
         replan.RouteInitialRequest(terrain=bad)
 
@@ -167,8 +163,8 @@ def test_화면_고르기_배선():
     assert '<option value="sheet">수치지형도</option>' in chrome
     assert 'sources?.sources.includes("las") && !!sources?.sources.includes("sheet")' in main
     assert 'saved === "sheet" || saved === "las" ? saved : (context?.design ?? fallback)' in api
-    # 모달 분석 셋(종단 띠는 345-5 에서 없앰)이 고른 지형을 실어 보냄 · [확인] 재계산은 안 실음
-    assert api.count("terrain: analysisTerrain(projectId)") == 2
+    # 모달 지반고가 고른 지형을 실어 보냄 · 횡단 미리보기 = 묶음(365-3) · [확인] 재계산은 안 실음
+    assert api.count("terrain: analysisTerrain(projectId)") == 1
     assert "terrain: analysisTerrain(projectId)" in initial_api
     replan_fn = api.split("export async function replanRoute")[1].split("export ")[0]
     assert "terrain" not in replan_fn
diff --git a/resources/tester/test_137_design_pick.py b/resources/tester/test_137_design_pick.py
index fb46749b6..5ab75f6f0 100644
--- a/resources/tester/test_137_design_pick.py
+++ b/resources/tester/test_137_design_pick.py
@@ -100,8 +100,9 @@ def test_카드_배선_하나만() -> None:
     assert "if (activeRevet === null) revetOffset?.select(section.chainage_m, null);" in view
     assert view.count("dropLine();") >= 4  # 본체 · 벽 · 카드 풂 · 면적
     assert "setLineActive(pickedLineAt(section.station_id));" in view  # 다시 그려도 되살림
-    assert "zoomBar.prepend(linePick.label);" in view  # 치수 = [+ − ⤢] 왼쪽
-    assert "chartWrap.append(linePick.panel);" in view  # 사면 이동 패널(151-3)
+    # 치수 · 이동 = 아래 띠 왼쪽 공용 칸(370-3 · 옛 [+ − ⤢] 왼쪽 치수 · 떠 있는 이동 패널 걷음)
+    assert "linePick.label" not in view and "linePick.panel" not in view
+    assert "appendCardFooter(card, section, rockBoundary, cutSlope, linePick?.cell);" in view
     css = _src("B06_Section/B06_Section_UI_Style_Cross_Areas.css")
     assert ".b06-chart__design-hit.is-active {" in css
 
diff --git a/resources/tester/test_139_4_buried_outlet.py b/resources/tester/test_139_4_buried_outlet.py
index 6ddb7d15e..259e980a9 100644
--- a/resources/tester/test_139_4_buried_outlet.py
+++ b/resources/tester/test_139_4_buried_outlet.py
@@ -54,11 +54,14 @@ def test_3도_선이_원지반을_못_만나면_복합경사(out: dict) -> None:
     assert len(study["cut"]) == 1
     tail = study["cut"][0]
     assert tail["rises"] is True and tail["grade"] == -1 and tail["endGap"] == 0
-    assert study["cutArea"] > study["cutAreaWithout"]
+    # 371-1 — 벽 자리 0.35 m 도로 쪽 · 오르는 선 0.3 m 라 면적 차가 백엔드 설계선 끝에 묻힘 → 폐회로에 듦만 봄
+    assert study["inTrim"] is True
 
 
 def test_성토_끝은_그대로(out: dict) -> None:
-    assert out["pipeBase"] == ["fill", "fill"]  # 묻히지 않은 기본 = 성토부선 그대로
+    # 371-1 — 다단 사이 시작 = 윗단 발끝 · 단이 0.5 m 내려가 기본 자료 끝 벽이 0.3 m 묻힘 → 3도 선
+    assert out["pipeBase"] == ["fill", "cut"]
+    assert out["pipeOpen"]["cut"] == []  # 묻히지 않은 끝 = 성토부선 그대로
 
 
 def test_유출_절토선은_그리고_면적에_넣음() -> None:
diff --git a/resources/tester/test_139_6_line_shift.py b/resources/tester/test_139_6_line_shift.py
index 2430c9a19..7ac959341 100644
--- a/resources/tester/test_139_6_line_shift.py
+++ b/resources/tester/test_139_6_line_shift.py
@@ -33,18 +33,17 @@ def test_화면_방향대로_그_쪽만_단추와_방향키(out: dict) -> None:
     assert right == {"left": 0, "right": 0.1}  # 우 사면 · ← = 안쪽 0 · ▶ = 바깥 0.1
 
 
-def test_치수_줄과_패널에_이동_표기(out: dict) -> None:
+def test_공용_칸_값에_이동_표기(out: dict) -> None:
+    """370-3 — 치수 · 이동은 아래 띠 공용 칸 값 한 줄(옛 우측 위 치수 · 패널 읽기 줄)."""
     assert "이동 +0.1m" in out["text"] and "노견 +" not in out["text"]
-    assert out["readout"] == "이동 0.1m"
+    assert out["text"].startswith("길이 ") and "\n" not in out["text"]
     assert out["titleLeft"] == "사면 이동 (좌)"
 
 
-def test_단추는_패널로_옮김_재설정_닫기(out: dict) -> None:
-    """151-3 — 치수 칸 [◀ ▶] 지움 · 패널 ◀ ↺ ▶ · ↺ = 그 쪽 0 · ✕ = 고름 풂 · 숨으면 방향키 안 먹음."""
-    assert out["labelButtons"] == 0
+def test_단추는_공용_칸_재설정(out: dict) -> None:
     assert out["slots"] == ["◀", "↺", "▶"]
     assert out["afterReset"] == {"left": 0, "right": 0}
-    assert out["picks"] == [out["pieceRight"]]
+    assert out["picks"] == []  # 칸 누름은 고름으로 안 번짐
     assert out["hiddenAtStart"] is True and out["hiddenAfter"] is True
     assert out["afterHidden"] == {"left": 0, "right": 0}
 
diff --git a/resources/tester/test_139_6_pipe_fit.py b/resources/tester/test_139_6_pipe_fit.py
index d2959f13a..320542c0a 100644
--- a/resources/tester/test_139_6_pipe_fit.py
+++ b/resources/tester/test_139_6_pipe_fit.py
@@ -40,10 +40,11 @@ def out(tmp_path_factory) -> dict:
 
 
 def test_안_넓힌_측점은_종전_그대로(out: dict) -> None:
-    """225-1 — 정수 맞춤 없앰: 벽은 기본 자리 · 관 길이 = 그려진 길이 0.1 m(5.772 → 5.8)."""
+    """225-1 — 정수 맞춤 없앰: 벽은 기본 자리 · 관 길이 = 그려진 길이 0.1 m(5.772 → 5.8).
+    371-1 — 기본 자리 = 성토 위 이음(끝에서 0.1 m) 기준 · 벽 0.35 m 도로 쪽(5.772 → 5.422)."""
     base = out["base"]
-    assert (base["edge"], base["pureHeight"], base["lengthM"]) == (2, 2, 5.8)
-    assert base["cut"] == pytest.approx(5.772)
+    assert (base["edge"], base["pureHeight"], base["lengthM"]) == (2, 2, 5.4)
+    assert base["cut"] == pytest.approx(5.422)
 
 
 @pytest.mark.parametrize("name, extend", [("shifted", 1.0), ("shifted2", 1.3)])
diff --git a/resources/tester/test_166_1_note_options.py b/resources/tester/test_166_1_note_options.py
index 94536b3ed..ee1341e67 100644
--- a/resources/tester/test_166_1_note_options.py
+++ b/resources/tester/test_166_1_note_options.py
@@ -107,7 +107,7 @@ def test_조합_줄_뒤에_옵션_줄_미지정도_옵션_줄():
         "group_items": None,
         "option_lines": ["옹벽: 높이 2.5m"],
     }
-    assert structure_note_lines([thing], 40.0) == ["옹벽 조합 미지정", "옹벽: 높이 2.5m"]
+    assert structure_note_lines([thing], 40.0) == ["옹벽", "옹벽: 높이 2.5m"]
 
 
 def test_화면은_구조물마다_옵션_줄을_붙임():
diff --git a/resources/tester/test_179_1_line_dims_left.py b/resources/tester/test_179_1_line_dims_left.py
index 7d9406081..e1de5b0cd 100644
--- a/resources/tester/test_179_1_line_dims_left.py
+++ b/resources/tester/test_179_1_line_dims_left.py
@@ -1,5 +1,8 @@
 # -*- coding: utf-8 -*-
-"""PLAN 179-1 — 선 길이 정보창 = 열 수 무관 늘 줌 [+ − ⤢] 왼쪽(좁은 카드 내림 규칙 지움 · 소스 시험)."""
+"""PLAN 179-1 — 선 길이 정보창 = 열 수 무관 늘 줌 [+ − ⤢] 왼쪽(좁은 카드 내림 규칙 지움 · 소스 시험).
+
+370-3 — 카드 치수는 아래 띠 공용 칸으로 옮김 · 치수 칸 꼴은 상세 모달(`_Detail_Select`)이 씀.
+"""
 
 import os
 import re
@@ -22,9 +25,15 @@ def test_좁은_카드_내림_규칙_없음():
     ]
 
 
-def test_치수_칸은_줌_막대_맨_앞():
+def test_카드_치수는_아래_띠_공용_칸():
+    """370-3 — 카드의 고른 선 치수는 줌 막대 앞 라벨을 걷고 아래 띠 왼쪽 공용 칸 값 한 줄로(상세 모달 치수는 그대로)."""
     view = _src("B06_Section/B06_Section_UI_Cross_View.ts")
-    assert "zoomBar.prepend(linePick.label);" in view
+    assert "linePick.label" not in view and "zoomBar.prepend(" not in view
+    assert "linePick?.cell" in view
+    assert "b06-cross-card__line-dims" not in _src(
+        "B06_Section/B06_Section_UI_Cross_Design_Pick.ts"
+    )
+    assert "b06-cross-card__line-dims" in _src("B06_Section/B06_Section_UI_Cross_Detail_Select.ts")
     zoom = (
         _src("B06_Section/B06_Section_UI_Style_Cross_Controls.css")
         .split(".b06-cross-card__zoom {", 1)[1]
diff --git a/resources/tester/test_186_1_outlet_fold.py b/resources/tester/test_186_1_outlet_fold.py
index 4a173b744..cae1cb7bb 100644
--- a/resources/tester/test_186_1_outlet_fold.py
+++ b/resources/tester/test_186_1_outlet_fold.py
@@ -61,10 +61,12 @@ def test_묻힌_유출_벽_설계선이_안_접힘(out: dict, case: str) -> None
 
 def test_저장값_사본_면적(out: dict) -> None:
     """접힌 폐회로(절토 27.94 · 성토 0.34 ㎡) → 노견~벽~3도 선 절토만."""
-    assert out["stored"]["cut"] == pytest.approx(34.0391, abs=1e-3)
+    # 371-1 — 성토 위 이음 = 윗면 끝에서 0.1 m · 기본 자리 새 이음 기준(34.0391 → 34.2539)
+    assert out["stored"]["cut"] == pytest.approx(34.2539, abs=1e-3)
     assert out["stored"]["fill"] == 0
     # 225-1 — 유출 벽이 관 길이 맞춤으로 밀리지 않고 기본 자리(16.8211 → 16.0929)
-    assert out["auto"]["cut"] == pytest.approx(16.0929, abs=1e-3)
+    # 371-1 — 기본 자리 = 새 이음 기준(16.0929 → 16.2613)
+    assert out["auto"]["cut"] == pytest.approx(16.2613, abs=1e-3)
 
 
 def test_절토_쪽_배관_유출도_안_접힘(out: dict) -> None:
diff --git a/resources/tester/test_194_1_berm_depth.py b/resources/tester/test_194_1_berm_depth.py
index b524a947c..c8765cb14 100644
--- a/resources/tester/test_194_1_berm_depth.py
+++ b/resources/tester/test_194_1_berm_depth.py
@@ -298,7 +298,8 @@ def test_이동_셋_분리(ui: dict) -> None:
 @node_only
 def test_소단_고름_위아래만(ui: dict) -> None:
     berm = ui["berm"]
-    assert berm["title"] == "소단 높이 (좌)" and berm["readout"] == "도로 아래 1.0m"
+    assert berm["title"] == "소단 높이 (좌)"
+    assert berm["readout"].startswith("도로 아래 1.0m · 길이 ")  # 값 한 줄(370-3 공용 칸)
     assert berm["moveHidden"] is True and berm["liftHidden"] is False
     assert berm["leftBlocked"] and berm["rightBlocked"]  # ◀▶ 막힘
     assert berm["afterSide"] == {"values": {"left": 0, "right": 0}, "sets": 0}  # 가로 안 감
@@ -332,7 +333,7 @@ def test_좌측_소단_상자_알림_카드_창구(ui: dict) -> None:
     assert chainage == 40 and change["berm_depth"] == {"side": "left", "valueM": 1.3}
     assert change["ground_type"] == "soil"  # 카드 버튼 값은 그대로 실음
     assert moves["host"] == [40, None]  # 한 번만 켬 · 다른 측점 끔은 무시
-    assert moves["none"] == {"stationId": "S7"}  # 창구 없으면 이동 패널 없음
+    assert moves["none"] == {"stationId": "S7"}  # 창구 없으면 이동 없음
     selection = (ROOT / "B06_Section" / "B06_Section_UI_Page_Structures_Selection.ts").read_text(
         encoding="utf-8"
     )
diff --git a/resources/tester/test_215_1_free_profile.py b/resources/tester/test_215_1_free_profile.py
index 2c626af39..06c5a458a 100644
--- a/resources/tester/test_215_1_free_profile.py
+++ b/resources/tester/test_215_1_free_profile.py
@@ -115,6 +115,38 @@ def test_Backspace_와_Esc_취소(out):
     assert out["enterOutsideDrawing"] is False
 
 
+def test_자유지정_되돌리기_다시하기(out):
+    # 367-3 ⑥ 점 둘 → ↶ → ↷ → 새 클릭이 ↷ 지움 · 큰 이력(apply · close) 안 건드림
+    assert out["undoEmpty"] == {"can": False, "backspace": False}
+    assert out["undo1"] == {"dots": [40, 80], "canRedo": True}
+    assert out["redo1"] == {"dots": [40, 80, 120], "canRedo": False}
+    assert out["newClick"] == {"dots": [40, 80, 100], "canRedo": False}
+    # 한 걸음 = 점 · 시작 · 범위 끝 · 범위 첫 · 같은 세로선 다시 누름은 안 쌓임
+    assert out["undoAll"] == ["drawing:2", "drawing:2", "armed:2", "range:1", "range:0"]
+    assert out["undoApplied"] == 0 and out["undoClosed"] == 0
+    assert out["redoTwice"] == {"phase": "armed", "band": [40, 160]}
+    assert out["resetClears"] == {"undo": False, "redo": False}
+
+
+def test_적용_막히면_열린_채(out):
+    # 367-3 ⑦ Enter · 끝 세로선 둘 다 apply 시도(2) · close 없음 · 점 그대로
+    assert out["blocked"] == {"tries": 2, "phase": "drawing", "dots": 2, "canUndo": True}
+
+
+def test_되돌리기_배선_자유지정_먼저():
+    panel = _read("B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts")
+    assert 'tools.mode() === "free" ? (free.undo(), freeView.redraw()) : inner.undo()' in panel
+    assert 'tools.mode() === "free" ? free.canUndo() : inner.canUndo()' in panel
+    keys = panel[panel.index('isCtrlKey(event, "z") || isCtrlKey(event, "y")') :]
+    free_at = keys.index('if (tools.mode() === "free") {')
+    assert (
+        free_at < keys.index("history.undo()")
+        and "return;" in keys[free_at : keys.index("flushHold();")]
+    )
+    profile = _read("A00_Common/design/design_profile.ts")
+    assert "function applyEdits(next: AlignmentEdits): boolean {" in profile
+
+
 def test_도구줄_직선화_오른쪽_자유지정():
     tools = _read("B05_Profile/B05_Profile_UI_Profile_Tools.ts")
     assert '"자유지정"' in tools
@@ -142,6 +174,28 @@ def test_오버레이_점선_빨강_글():
     assert ".b05-profile-freemark__line.is-over" in css
 
 
+def _css_rule(css: str, selector: str) -> str:
+    at = css.index(selector + " {")
+    return css[at : css.index("}", at)]
+
+
+def test_자유지정_녹색_넘음_빨강_띠_보라():
+    # 367-4 선 · 미리 보기 · 점 = --color-success · 넘음 빨강 · 범위 띠 · 경계 보라 그대로
+    css = _read("B05_Profile/B05_Profile_UI_Style_Table.css")
+    assert "stroke: var(--color-success);" in _css_rule(css, ".b05-profile-freemark__line")
+    assert "stroke: var(--color-success);" in _css_rule(css, ".b05-profile-freemark__dot")
+    assert "var(--color-danger" in _css_rule(css, ".b05-profile-freemark__line.is-over")
+    assert "var(--color-danger" in _css_rule(css, ".b05-profile-freemark__grade.is-over")
+    assert "--color-primary" in _css_rule(css, ".b05-profile-freemark__band")
+    assert "--color-primary" in _css_rule(css, ".b05-profile-freemark__edge")
+    # 밝음 · 어두움(명시 · OS 자동) 모두 success · danger 토큰 있음
+    theme = _read("ui_template/ui_template_theme.css")
+    auto = theme[theme.index("@media (prefers-color-scheme: dark)") :]
+    auto = auto[: auto.index("\n}\n")]
+    for block in (_css_rule(theme, ":root"), _css_rule(theme, ':root[data-theme="dark"]'), auto):
+        assert "--color-success:" in block and "--color-danger:" in block
+
+
 def test_줄_수_늘리지_않음():
     for relative in (
         "A00_Common/design/design_profile.ts",
diff --git a/resources/tester/test_218_1_loupe.py b/resources/tester/test_218_1_loupe.py
index 9568efe79..c3f5f20bd 100644
--- a/resources/tester/test_218_1_loupe.py
+++ b/resources/tester/test_218_1_loupe.py
@@ -162,6 +162,26 @@ def test_바뀌면_0_5초_뒤_다시_뜸_끄면_복제_지움(r):
     assert h["hidden"] and h["disconnected"] and h["scrollListen"] is False
     assert h["noRecaptureAfterHide"] == 0
     assert h["reuseRoot"] == 2  # 원 · 배율 글 하나씩을 다시 씀
+    assert h["bodyUntouched"] == 6  # 원 · 글은 html 바로 아래 — body 복제 · 관찰에 안 걸림(374-1)
+
+
+def test_움직이는_동안_안_뜸_멈춘_뒤_한_번(r):
+    # 374-1 디바운스 — 바뀜 뒤 계속 움직이면 안 뜸 · 마지막 움직임 0.5 초 뒤 한 번
+    assert r["debounce"] == {"heldWhileMoving": True, "afterStop": True}
+    # 이동 = 바깥 판 translate 만(합성층) · 배율 = 안쪽 상자
+    assert r["capture"]["stageMoveOnly"] == "translate(-820px, -620px)"
+    css = _read("ui_template/ui_template_loupe.css")
+    stage = css[css.index(".ui-loupe__stage {") :]
+    assert "will-change: transform;" in stage[: stage.index("}")]
+    scale = css[css.index(".ui-loupe__scale {") :]
+    assert "transform-origin: 0 0;" in scale[: scale.index("}")]
+
+
+def test_뜨는_자리_화면_전체_모달_포함():
+    src = _read("ui_template/ui_template_loupe.ts")
+    assert "sourceOf: () => Element | null = () => win.document.body," in src
+    assert "doc.documentElement.append(root, label);" in src
+    assert 'getElementById("app")' not in src
 
 
 def test_테두리_그림자_토큰():
diff --git a/resources/tester/test_224_1b_masshaul_docked.py b/resources/tester/test_224_1b_masshaul_docked.py
index 942ae8347..b1be9a1c7 100644
--- a/resources/tester/test_224_1b_masshaul_docked.py
+++ b/resources/tester/test_224_1b_masshaul_docked.py
@@ -11,7 +11,6 @@
 
 import json
 import os
-import re
 import subprocess
 from pathlib import Path
 
@@ -65,7 +64,5 @@ def test_끌기도_유토_판_안_셈():
 
 def test_뗀_유토는_노선_전체_세로():
     mass = (B05 / "B05_Profile_UI_Profile_MassHaul.ts").read_text(encoding="utf-8")
-    assert re.search(
-        r'viewRange: overlay\.classList\.contains\("is-popout"\) \? undefined : params\.axis\.viewRange',
-        mass,
-    )
+    # 367-1 붙음 · 뗌 모두 노선 전체 세로
+    assert "viewRange: undefined," in mass
diff --git a/resources/tester/test_224_1c_subpanel_popout.py b/resources/tester/test_224_1c_subpanel_popout.py
index eb8f2f684..2b8632bb1 100644
--- a/resources/tester/test_224_1c_subpanel_popout.py
+++ b/resources/tester/test_224_1c_subpanel_popout.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """224-1c(PLAN 325-3) 유토곡선 · 배수유역 [창 분할] — 종단 [창 분할]과 같은 양식 · 따로 새 창.
 
-- 단추 = 두 판 머리줄 맨 앞(유토는 접어도 남는 머리줄 · 354-1) · 글 [창 분할]/[창 결합] · 툴팁에 판 이름.
+- 단추 = 두 판 머리줄 맨 앞(유토는 펼친 때만 보임 · 367-2) · 글 [창 분할]/[창 결합] · 툴팁에 판 이름.
 - 창 이름 셋 다름(같으면 앞 창 body 를 덮어 조각이 사라짐).
 - 뗌 = 새 창 body · 뗀 유토 판 손잡이 · 리사이저는 CSS 로 감춤 · 배수 지도 관찰 rehome.
 - 붙임(단추 · 새 창 닫힘 · 페이지 떠남) = 제자리 — 종단 열 끝(종단 칸 아래) · 배수 content 끝.
diff --git a/resources/tester/test_224_2_station_snap.py b/resources/tester/test_224_2_station_snap.py
index a779c07df..dfb43a618 100644
--- a/resources/tester/test_224_2_station_snap.py
+++ b/resources/tester/test_224_2_station_snap.py
@@ -359,30 +359,3 @@ def test_측점_셈_둘_다_스냅을_읽음(tmp_path: Path, monkeypatch) -> Non
     with pytest.raises(RuntimeError):
         sections.run_section_generation(tmp_path, "route.geojson", "f", "m", False)
     assert seen["station_snap"] is True
-
-
-def test_횡단_미리보기도_스냅(tmp_path: Path, monkeypatch) -> None:
-    from B05_Profile import B05_Profile_Router_Terrain as terrain
-    from common_util.common_util_route_polyline import build_planned_polyline
-
-    monkeypatch.setattr(terrain, "build_surface_sampler", lambda *_args, **_kw: _Flat())
-    built = build_planned_polyline(_NODES, min_radius_m=40.0, simplify=False)
-    points, chain = core._clean_polyline(np.asarray(built.vertices, dtype=np.float64))
-    spans = core._design_curve_spans(points, chain, [c.as_dict() for c in built.curves])
-    assert len(spans) == 1
-    target = math.floor((spans[0][0] + spans[0][1]) / 2 + 0.5)
-    assert target % 20  # 격자 밖 자리여야 견줄 뜻이 있음
-
-    def ask(snap: bool) -> float:
-        request = terrain.CrossPreviewRequest(
-            vertices=[{"x": x, "y": y} for x, y in _NODES],
-            chainage_m=target,
-            min_radius_m=40.0,
-            station_interval_m=20.0,
-            station_snap=snap,
-        )
-        params = {"source_filter": "f", "method": "m", "smooth": False}
-        return terrain._cross_preview(tmp_path, params, request)["chainage_m"]
-
-    assert ask(True) == target
-    assert ask(False) % 20 == 0
diff --git a/resources/tester/test_225_1_pipe_round.py b/resources/tester/test_225_1_pipe_round.py
index e0dabdb2f..004a21a43 100644
--- a/resources/tester/test_225_1_pipe_round.py
+++ b/resources/tester/test_225_1_pipe_round.py
@@ -72,7 +72,8 @@ def test_좌우_한_번은_d_를_지금_자리로_묶음(out: dict) -> None:
 def test_관_길이는_벽_자리에서_0_1m_로(out: dict) -> None:
     """유출 벽을 0.1 m 씩 밀면 관 길이도 0.1 m 씩 — 정수 올림 · 길이 맞춤 이동 없음."""
     lengths = [case["lengthM"] for case in out["moved"]]
-    assert lengths == [7.9, 8.0, 8.1, 8.2]
+    # 371-1 — 기본 자리 = 성토 위 이음 기준 · 벽 0.35 m 도로 쪽(7.9 → 7.5)
+    assert lengths == [7.5, 7.6, 7.7, 7.8]
     for case in out["moved"]:
         assert case["lengthM"] == round(case["cut"], 1)
 
diff --git a/resources/tester/test_244_11_b08_milestone_auto_capture.py b/resources/tester/test_244_11_b08_milestone_auto_capture.py
index 4efdac4de..fbed19636 100644
--- a/resources/tester/test_244_11_b08_milestone_auto_capture.py
+++ b/resources/tester/test_244_11_b08_milestone_auto_capture.py
@@ -264,8 +264,10 @@ def test_화면_브라우저_캡처_없음_길찾기_뒤_자동():
         assert "캡처는 localhost" not in text, name
     state = read("B08_Quantity_UI_Milestone_State.ts")
     # 244-13 — 연결선 한 구간 [길찾기] · 거래처 쪽 구간만 자동 그림
-    assert 'if (image && seg.key === "route" && paths.has(from))' in state
-    assert "void autoRouteImage(projectId, from, routePaths(from));" in state
+    assert (
+        'if (image && seg.key === "route" && path) void autoRouteImage(projectId, from, [path]);'
+        in state
+    )
     assert "JSON.stringify({ lines, marks })" in state and "/image/auto?route=" in state
     assert "user_only=true" in state and "showToast(reason," in state
     route = read("B08_Quantity_UI_Milestone_Route.ts")
diff --git a/resources/tester/test_244_13_b08_milestone_place_leg.py b/resources/tester/test_244_13_b08_milestone_place_leg.py
index ea87c7a73..b6a019bc9 100644
--- a/resources/tester/test_244_13_b08_milestone_place_leg.py
+++ b/resources/tester/test_244_13_b08_milestone_place_leg.py
@@ -245,8 +245,8 @@ const writes = WRITES.n;
 await findSegmentKm("p1", "b1"); // 같은 km = 캐시 안 씀
 const live = liveMilestone("p1");
 console.log(JSON.stringify({{ a, b, calls: CALLS.slice(1), afterRoute, writes, again: WRITES.n,
-  route: live.routes[0].legs, base: live.bases[0].legs, path: segmentPath("g"),
-  routeLines: routePaths("g"), baseLines: routePaths("b1"),
+  route: live.routes[0].legs, base: live.bases[0].legs, path: segmentPath("p1", "g"),
+  routeLines: [segmentPath("p1", "g")], baseLines: [segmentPath("p1", "b1")],
   start: await findSegmentKm("p1", "start") }}));"""
     got = _node([CALC, LAYOUT, STATE], script, STATE_STUBS)
     assert got["a"] == "g → 병곡리 10.5 km" and got["b"] == "병곡리 → 시점 10.5 km"
@@ -268,6 +268,8 @@ console.log(JSON.stringify({{ a, b, calls: CALLS.slice(1), afterRoute, writes, a
     assert got["routeLines"] == [got["path"]] and got["baseLines"] == [
         got["path"]
     ]  # 구간마다 길 선
+    assert got["route"][0]["path"] == [[35.68, 127.9], [35.66, 127.85]]  # 373 길 선 = 구간 자료에
+    assert got["base"][0]["path"] == got["path"]
     assert got["start"] == ""  # 시점 → 중점 = 길찾기 없음
 
 
@@ -302,7 +304,7 @@ def test_화면_등록_모달_연결선_모달():
     assert "길찾기" not in mid.replace("길찾기 없음", "") and "editMap" not in mid
     assert 'if (from === "start") return openMidLeg(projectId);' in leg
     assert "void reverseAddress(projectId, lon, lat)" in leg and "void run();" in leg
-    assert "if (!manual.input.checked && !segmentPath(from).length && seg.from && seg.to)" in leg
+    assert "!manual.input.checked && !segmentPath(projectId, from).length" in leg
     for rel in (B08 + "UI_Milestone_Modal.ts", B08 + "UI_Milestone_Place.ts",
                 B08 + "UI_Milestone_LegModal.ts", KMAP, STATE, LAYOUT, CALC,
                 B08 + "UI_Milestone.ts", B08 + "UI_Milestone_Diagram.ts",
diff --git a/resources/tester/test_244_9_b08_milestone_route_map.py b/resources/tester/test_244_9_b08_milestone_route_map.py
index df41ff5d7..fe54091ec 100644
--- a/resources/tester/test_244_9_b08_milestone_route_map.py
+++ b/resources/tester/test_244_9_b08_milestone_route_map.py
@@ -11,8 +11,10 @@ import subprocess
 import sys
 from pathlib import Path
 
+import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
+from pydantic import ValidationError
 
 ROOT = Path(__file__).resolve().parents[2]
 if str(ROOT) not in sys.path:
@@ -93,12 +95,15 @@ def test_깨진_좌표_km_그대로_길_선만_없음(monkeypatch):
 
 def test_좌표_저장_안_함(tmp_path):
     route = {"id": "r1", "name": "거창군청", "legs": [{"road": None, "auto_km": 10.5}]}
-    route["path"] = [[35.6866, 127.9095], [35.66, 127.85]]  # 화면이 잘못 실어 보내도
+    route["path"] = [
+        [35.6866, 127.9095],
+        [35.66, 127.85],
+    ]  # 화면이 잘못 실어 보내도(거래처 칸 = 안 받음)
     ms.save_data(tmp_path, ms.Milestone.model_validate({"routes": [route]}))
     files = [p for p in tmp_path.rglob("*") if p.is_file()]
     assert [p.name for p in files] == ["milestone.json"]
     text = files[0].read_text(encoding="utf-8")
-    assert '"path"' not in text and "35.6866" not in text and '"auto_km": 10.5' in text
+    assert '"path": null' in text and "35.6866" not in text and '"auto_km": 10.5' in text
 
 
 def test_JS_키_길(monkeypatch):
@@ -229,10 +234,34 @@ def test_화면_자리_캡처_키_서버만():
     assert "routeMapView" not in route and "다음 지도에서 길찾기" not in route
     assert "routeMapView" not in kmap
     state = _read("B08_Quantity/B08_Quantity_UI_Milestone_State.ts")
-    assert "paths.set(from, res.path!);" in state  # 메모리만(캐시 · 서버 안 감)
+    assert "putFound(projectId, from, res.km, path);" in state  # 373 구간 자료(캐시 → [저장])
     for rel in Path(ROOT / "B08_Quantity").glob("*.ts"):  # 키 이름은 서버만
         text = rel.read_text(encoding="utf-8")
         assert "KAKAO_JS_KEY" not in text and "KAKAO_REST_API_KEY" not in text, rel
     for rel in (KMAP, "B08_Quantity/B08_Quantity_UI_Milestone_Modal.ts", LAYOUT,
                 "B08_Quantity/B08_Quantity_Router_Milestone.py"):  # fmt: skip
         assert len(_read(rel).splitlines()) <= 700
+
+
+def test_373_구간_길_선_저장_소수_5자리_점_줄임(tmp_path):
+    line = [[35.6866123, 127.9095456], [35.686612, 127.909546], [35.66, 127.85]]
+    leg = {"road": None, "auto_km": 10.5, "path": line}
+    ms.save_data(tmp_path, ms.Milestone.model_validate({"routes": [{"id": "r1", "legs": [leg]}]}))
+    saved = ms.read_data(tmp_path)["routes"][0]["legs"][0]["path"]
+    assert [list(p) for p in saved] == [
+        [35.68661, 127.90955],
+        [35.68661, 127.90955],
+        [35.66, 127.85],
+    ]
+    with pytest.raises(ValidationError):
+        ms.Milestone.model_validate({"routes": [{"id": "r1", "legs": [{"path": [[95.0, 127.0]]}]}]})
+    with pytest.raises(ValidationError):  # 상한
+        ms.Milestone.model_validate(
+            {"routes": [{"id": "r1", "legs": [{"path": [[35.0, 127.0]] * (ms.PATH_MAX + 1)}]}]}
+        )
+    # 길찾기 응답 줄이기 — 같은 점 이어짐 뺌 · 상한 안 · 두 끝 유지
+    thin = ms.thin_path([[35.0, 127.0], [35.0, 127.0], [35.00001, 127.0]])
+    assert thin == [[35.0, 127.0], [35.00001, 127.0]]
+    wavy = [[35 + i * 1e-4, 127 + (i % 2) * 1e-5] for i in range(2000)]
+    small = ms.thin_path(wavy)
+    assert len(small) <= ms.PATH_MAX and small[0] == [35.0, 127.0] and small[-1][0] == wavy[-1][0]
diff --git a/resources/tester/test_254_2_b08_milestone_diagram.py b/resources/tester/test_254_2_b08_milestone_diagram.py
index 73f092158..7fdcf1df6 100644
--- a/resources/tester/test_254_2_b08_milestone_diagram.py
+++ b/resources/tester/test_254_2_b08_milestone_diagram.py
@@ -113,8 +113,8 @@ def test_연결_점_왼쪽_위_안쪽_기준점도_돌기_취소():
     ui = _read(B08 + "UI_Milestone_Diagram.ts")
     dot = ui[ui.index("const connectDot") :]
     dot = dot[: dot.index("return dot;")]
-    # 왼쪽 위 안쪽 — 가운데 (10, 10) · 반지름 6 + 테두리 2 = 상자 안
-    assert "const cx = box.x + 10;" in dot and "const cy = box.y + 10;" in dot and "r: 6" in dot
+    # 왼쪽 위 안쪽 — 가운데 (12, 12) · 반지름 9 + 테두리 2 = 상자 안(373)
+    assert "const cx = box.x + 12;" in dot and "const cy = box.y + 12;" in dot and "r: 9" in dot
     assert (
         'if (box.kind === "route" || box.kind === "base") g.append(connectDot(box, shift));' in ui
     )
diff --git a/resources/tester/test_255_2_b08_milestone_start_pin.py b/resources/tester/test_255_2_b08_milestone_start_pin.py
index bf149c7e4..8c6644a26 100644
--- a/resources/tester/test_255_2_b08_milestone_start_pin.py
+++ b/resources/tester/test_255_2_b08_milestone_start_pin.py
@@ -113,7 +113,9 @@ def test_경로_탭_끌기_다시_길찾기():
     assert "fresh.site.start_pin = { lon, lat };" in route
     assert "await refind(touchingSegments(fresh, key));" in route
     assert "findSegmentKm(projectId, id, false)" in route  # 끌기 · 열기 = 그림 캡처 없음
-    assert "[routeId, ...chain].filter((id) => !segmentPath(id).length)" in route  # 열 때 모든 구간
+    assert (
+        "[routeId, ...chain].filter((id) => !segmentPath(projectId, id).length)" in route
+    )  # 열 때 모든 구간
     assert "status.hidden = !bad.length;" in route  # 실패 안내
     calc = _read("B08_Quantity/B08_Quantity_Milestone_Calc.ts")
     assert "start_pin?: { lon: number; lat: number } | null;" in calc
diff --git a/resources/tester/test_265_note_cad.py b/resources/tester/test_265_note_cad.py
index 79a8fee33..4199da976 100644
--- a/resources/tester/test_265_note_cad.py
+++ b/resources/tester/test_265_note_cad.py
@@ -124,12 +124,12 @@ _LINES = [
     "기슭막이 메쌓기 1.2m 기초무",
     "돌붙임 찰붙임",
     "옹벽 콘크리트 H=2.0",
-    "돌쌓기(찰) 조합 미지정",
-    "가드레일 조합 미지정",
+    "돌쌓기(찰)",
+    "가드레일",
 ]
 
 
-def test_구조물_여럿_글은_조합_이름_미지정_배관_본체_뺌_TS_파이썬_같음():
+def test_구조물_여럿_글은_조합_이름_미지정은_종류_이름만_배관_본체_뺌_TS_파이썬_같음():
     culvert = {**_culvert_set(_PIPE), "chainage_m": 40.2}
     cases = [
         _case(_THINGS, 40.0, culvert, {"pipe_length_m": 8.5}),
@@ -229,3 +229,15 @@ def test_원형_마크_L_은_사사오입_정수_TS_파이썬_같음(length, lab
     py = note_entities(40.0, culvert, design, "NO.2", [])
     assert _labels(ts["entities"])[2] == label
     assert _labels(py)[2] == label
+
+
+def test_미지정_같은_종류는_한_줄_조합_있는_같은_이름은_따로_TS_파이썬_같음():
+    things = [
+        {"name": "옹벽", "pipe": False, "at": 40.0},
+        {"name": "옹벽", "pipe": False, "at": 40.1},
+        {"name": "돌쌓기", "pipe": False, "at": 40.0, "summary_item": _B},
+        {"name": "돌쌓기", "pipe": False, "at": 40.0},
+    ]
+    [ts] = _helper("mirror", [_case(things, 40.0, None, {})])
+    lines = structure_note_lines(things, 40.0)
+    assert ts["lines"] == lines == ["옹벽", "돌붙임 찰붙임", "돌쌓기"]
diff --git a/resources/tester/test_288_underdrain_cross.py b/resources/tester/test_288_underdrain_cross.py
index 50c5526c8..c048d4bf6 100644
--- a/resources/tester/test_288_underdrain_cross.py
+++ b/resources/tester/test_288_underdrain_cross.py
@@ -1,10 +1,12 @@
 """288 맹암거 횡단 형상(요구 183-3 · 9).
 
 못박는 것
-  - 288-1 맹암거 기준 측점 = 측구 없음 · 노면 = 암거 경사로 지대 낮은 쪽 한 경사(물넘이 286 · 287 길 —
-    서버 `tilt_ranges` · `tilt_args` · TS 짝 `tilted`) · 제원 얹기 서버 `attach_underdrains` ↔ TS
-    `attachUnderdrainSpecs` 같은 값 · 형상 = 노면을 암거 높이만큼 아래로 옵셋 → 성토 쪽은 성토 사면과
-    만남 · 절토 쪽은 절토 사면을 늘여 만남 · 그 안 돌 무늬 · 높이 비면 안 그림.
+  - 288-1 맹암거 기준 측점 = 측구 없음 · 노면 = 표준 경사로 지대 낮은 쪽 한 경사
+    (물넘이 286 · 287 길 — 서버 `tilt_ranges` · `tilt_args` · TS 짝 `tilted` · 암거 경사는
+    노면에 안 감 371-3) · 제원 얹기 서버 `attach_underdrains` ↔ TS `attachUnderdrainSpecs`
+    같은 값 · 형상 = 노면을 암거 높이만큼 아래로 옵셋 → 성토 쪽은 성토 사면과 만남 ·
+    절토 쪽은 절토 사면을 늘여 만남 · 그 안 돌 무늬 · 높이 비면 안 그림.
+  - 371-3 암거 경사 = 형상 하단 경계 — 높은 쪽 노면 끝 − 높이에서 암거 경사로 낮은 쪽으로 내림.
   - 288-2 맹암거 형상 누름 = 그 구조물 id 고름(구조물 목록 창구 · 알약 · 폼 · 측점선 따라옴) · 물넘이와 같은
     판정면(보라 손잡이 아래 · 끌기 = 고름 아님 · 287-5) · 노면공 포장 범위 고름과 따로.
 
@@ -86,8 +88,9 @@ def ts(tmp_path_factory) -> dict:
 
 def test_맹암거_자리_기울기_서버(project):
     ranges = tilt.tilt_ranges(project)
-    assert ranges == [(40.0, 40.0, 4.0), (80.0, 80.0, None)]
-    assert tilt.tilt_args(40.0, ranges) == {"tilted": True, "tilt_pct": 4.0}
+    # 371-3 — 암거 경사(4 %)는 노면에 안 감 · 노면 = 표준 경사
+    assert ranges == [(40.0, 40.0, None), (80.0, 80.0, None)]
+    assert tilt.tilt_args(40.0, ranges) == {"tilted": True, "tilt_pct": None}
     assert tilt.tilt_args(80.01, ranges) == {"tilted": True, "tilt_pct": None}
     assert tilt.tilt_args(60.0, ranges) == {"tilted": False, "tilt_pct": None}
 
@@ -110,8 +113,9 @@ def test_맹암거_측점_설계_측구_없음_낮은_쪽_기울기():
         for o in range(-24, 25)
     ]
     kwargs = {"ground_type": "soil", "section_mode": "left_cut", "ditch_side": "left"}
-    got = compute_cross_design(samples, 100.4, tilted=True, tilt_pct=4.0, **kwargs)
-    assert got["ditch_enabled"] is False and got["cross_slope_pct"] == 4.0
+    got = compute_cross_design(samples, 100.4, tilted=True, tilt_pct=None, **kwargs)
+    standard = compute_cross_design(samples, 100.4, **kwargs)["cross_slope_pct"]
+    assert got["ditch_enabled"] is False and got["cross_slope_pct"] == standard
     left, right = (got["road_edges"][k]["elevation_m"] for k in ("left", "right"))
     assert left > right  # 지반이 좌로 오름 = 우가 낮음
 
@@ -131,6 +135,20 @@ def test_형상_옵셋선_성토_절토와_만남(ts):
     assert ts["drew"] is True and ts["stones"] > 0
 
 
+def test_하단_경계는_암거_경사(ts):
+    """371-3 — 노면 5 % · 암거 3 % · 높이 1 m: 하단 = 좌(높은 쪽) 끝 99.15 에서 3 % 로 우로 내림."""
+    outline = [(p["offset"], p["elevation"]) for p in ts["sloped"]]
+    expected = [
+        (3, 100.15),
+        (-3, 99.85),
+        (-4.391304, 98.928261),  # 우 성토 사면 ∩ 하단(99.15 − 0.03 × 7.391)
+        (1.872180, 99.116165),  # 좌 절토 사면을 늘인 선 ∩ 하단
+    ]
+    assert len(outline) == len(expected)
+    for got, want in zip(outline, expected):
+        assert got == pytest.approx(want, abs=1e-5)
+
+
 def test_양측절토_늘인_노면_원지반_교점에서_끊음(ts):
     """356-1 — 낮은 쪽 노면 끝도 절토(tilt_reach) = reach 에서 수직으로 끊음 · 너머 원지반 따라가지 않음."""
     outline = [(p["offset"], p["elevation"]) for p in ts["bothCut"]]
diff --git a/resources/tester/test_298_add_reanalyze.py b/resources/tester/test_298_add_reanalyze.py
index 872c99a0b..a11e4f16c 100644
--- a/resources/tester/test_298_add_reanalyze.py
+++ b/resources/tester/test_298_add_reanalyze.py
@@ -104,7 +104,7 @@ def test_B06_초안_쓰면_판이_한_번_다시_나눔():
 
 
 def test_다시_나눔은_세션_초안으로_계산만_저장_안_함():
-    load = _body(PANEL, "const loadSaved = ", "const resetPipes")
+    load = _body(PANEL, "const loadSaved = ", "const analyze = ")
     assert "readPendingPipes(projectId as string)" in load
     assert "computeDetailBasins(projectId as string, pending)" in load
     analyze = _body(PANEL, "const analyze = ", "analyzeButton.addEventListener")
diff --git a/resources/tester/test_312_empty_pipes.py b/resources/tester/test_312_empty_pipes.py
index 44ff61c69..f83c0f428 100644
--- a/resources/tester/test_312_empty_pipes.py
+++ b/resources/tester/test_312_empty_pipes.py
@@ -148,7 +148,7 @@ def test_칸_없음_파일_없음_DELETE_노선_바뀜은_자동_배치(api) ->
 
 def test_빈_목록과_None_을_가르는_자리() -> None:
     src = _read("common_util/common_util_drainage_detail.py")
-    assert "if confirmed_chainages is not None:" in src
+    assert 'if confirmed_chainages is not None and auto != "all":' in src
     router = _read("B04_PreProcess/B04_PreProcess_Router_Basins.py")
     assert "points = requested if requested is not None else stored" in router
     assert "requested or stored" not in router
@@ -161,7 +161,7 @@ def _body(rel: str, start: str, end: str) -> str:
 
 def test_화면_초안_빈_목록은_저장분으로_안_넘어감() -> None:
     load = _body(
-        "B05_Profile/B05_Profile_UI_Drainage_Panel.ts", "const loadSaved = ", "const resetPipes"
+        "B05_Profile/B05_Profile_UI_Drainage_Panel.ts", "const loadSaved = ", "const analyze = "
     )
     assert "pending !== null" in load and "pending?.length" not in load
     # B06 목록도 같은 규칙(`??`)
diff --git a/resources/tester/test_318_cross_card.py b/resources/tester/test_318_cross_card.py
index 456589481..146d0ae88 100644
--- a/resources/tester/test_318_cross_card.py
+++ b/resources/tester/test_318_cross_card.py
@@ -95,6 +95,11 @@ def test_footer_without_center_text(result: dict) -> None:
     assert footer["rock_first"].split()[-1] == "b06-cross-card__rockb"  # 암 경계 = 왼쪽 첫 칸
     assert footer["rock_classes"][-1].split()[-1] == "b06-cross-card__cutslope"
     assert footer["soil_exists"] and footer["soil_children"] == 0  # 토사도 띠는 남음(빈 띠)
+    # 370-3 — 선 공용 칸 = 왼쪽 첫 칸(암 꼴 클래스) · 암 절토 경사 = 오른쪽 그대로
+    assert footer["cell_classes"] == [
+        "linecell b06-cross-card__rockb",
+        "cutslope b06-cross-card__cutslope",
+    ]
 
 
 def test_center_wired_into_card_and_modal() -> None:
diff --git a/resources/tester/test_342_3_detail_cache.py b/resources/tester/test_342_3_detail_cache.py
index 8ea80935b..661d712aa 100644
--- a/resources/tester/test_342_3_detail_cache.py
+++ b/resources/tester/test_342_3_detail_cache.py
@@ -24,7 +24,7 @@ def setup(tmp_path, monkeypatch):
     basins._DETAIL_CACHE.clear()
     calls = SimpleNamespace(count=0)
 
-    def build(stored_path, context, points):
+    def build(stored_path, context, points, auto=None):
         calls.count += 1
         chainages = [p.chainage_m for p in points] if points else [50.0]
         return DrainageDetail(), [PipePoint(chainage_m=c, source="stream") for c in chainages]
diff --git a/resources/tester/test_342_3_drainage_stale.py b/resources/tester/test_342_3_drainage_stale.py
index 18d096861..c252f6c35 100644
--- a/resources/tester/test_342_3_drainage_stale.py
+++ b/resources/tester/test_342_3_drainage_stale.py
@@ -52,13 +52,13 @@ def _patch(monkeypatch, analysis_signature, stored):
     monkeypatch.setattr(basins, "load_pipe_points", lambda *args: stored)
     built = SimpleNamespace(called=False)
 
-    def build(stored_path, context, points):
+    def build(stored_path, context, points, auto=None):
         built.called = True
         return SimpleNamespace(pipes=[], basins=["유역"]), points or []
 
     monkeypatch.setattr(basins, "_build", build)
     monkeypatch.setattr(
-        basins, "_build_cached", lambda context, points: build("x", context, points)
+        basins, "_build_cached", lambda context, points, auto=None: build("x", context, points)
     )
     return built
 
diff --git a/resources/tester/test_345_3_route_body.py b/resources/tester/test_345_3_route_body.py
index 2a038790d..18cdbd0de 100644
--- a/resources/tester/test_345_3_route_body.py
+++ b/resources/tester/test_345_3_route_body.py
@@ -48,7 +48,9 @@ def test_Ctrl_Z_는_사진첩_한_줄(out):
 def test_종단도_Ctrl_Z_줄이_사진첩_하나():
     tools = _read("B05_Profile/B05_Profile_UI_Profile_Panel_Tools.ts")
     at = tools.index('if (isCtrlKey(event, "z") || isCtrlKey(event, "y")) {')
-    assert "undoOwner" not in tools and "history.undo()" in tools[at : at + 240]
+    assert (
+        "undoOwner" not in tools and "history.undo()" in tools[at : at + 600]
+    )  # 367-3 자유지정 분기 앞에 섬
     history = _read("B05_Profile/B05_Profile_UI_RouteEdit_History.ts")
     assert '"keydown"' not in history and "onPageHistory" in history
 
diff --git a/resources/tester/test_345_4_recommend_panel.py b/resources/tester/test_345_4_recommend_panel.py
index 341579d3a..20845504b 100644
--- a/resources/tester/test_345_4_recommend_panel.py
+++ b/resources/tester/test_345_4_recommend_panel.py
@@ -46,9 +46,9 @@ def test_적용은_본문_평면에_되돌리기_한_칸():
     assert "apply: (snapshot, message) => restoreSnapshot(snapshot, message, true)," in main
     restore = main[main.index("function restoreSnapshot(") :]
     restore = restore[: restore.index("\n  }\n")]
-    assert "applyEdit(message, record);" in restore
+    assert "applyEdit(message, record, false);" in restore  # 366-3 — 추천 적용은 측점 맞춤 안 함
     apply_edit = main[main.index("function applyEdit(") :]
-    assert "if (record) history?.commit(snapshotNow());" in apply_edit[:600]
+    assert "if (record) history?.commit(snapshotNow());" in apply_edit[:900]
     initial = _read("B05_Profile/B05_Profile_UI_RouteEdit_Initial.ts")
     on_apply = initial[initial.index("onApply: (picked) => {") :]
     assert on_apply[:500].count("params.apply(") == 1
diff --git a/resources/tester/test_345_5b_plan_visible_area.py b/resources/tester/test_345_5b_plan_visible_area.py
index 0c81d8523..5ebf869b8 100644
--- a/resources/tester/test_345_5b_plan_visible_area.py
+++ b/resources/tester/test_345_5b_plan_visible_area.py
@@ -125,16 +125,14 @@ def test_판은_덮이기만_따라_안_옮김() -> None:
     assert ".b05-route-profile.is-collapsed {\n  height: 0;" in style
 
 
-def test_처음_열기와_맞춤_단추_같은_셈() -> None:
+def test_처음_열기_맞춤_그대로_맞춤_단추_없음() -> None:
+    """366-2 — [맞춤] 단추는 지움 · 처음 열 때 등고 영역 맞춤(fitView)은 그대로."""
     view = (B05 / "B05_Profile_UI_RouteEdit_View.ts").read_text(encoding="utf-8")
     assert "return { view: fitView(meta, view, nodes, contours), rotationRad: 0 };" in view
     assert "unionArea([route, ...(contours?.features ?? [])])" in view
     chrome = (B05 / "B05_Profile_UI_RouteEdit_Chrome.ts").read_text(encoding="utf-8")
-    assert 'data-act="fit"' in chrome and ">맞춤</button>" in chrome
+    assert 'data-act="fit"' not in chrome and ">맞춤</button>" not in chrome
     editor = (B05 / "B05_Profile_UI_RouteEdit.ts").read_text(encoding="utf-8")
     assert "openingView(projectId, meta, view, planned, contours?.layer ?? null)" in editor
-    at = editor.index("""overlay.querySelector('[data-act="fit"]')!""")
-    handler = editor[at : at + 260]
-    assert "view = fitView(meta, view, planned, contours?.layer ?? null);" in handler
-    assert "rotation.set(0);" in handler
+    assert 'data-act="fit"' not in editor and "fitView" not in editor
     assert len(editor.splitlines()) <= 700
diff --git a/resources/tester/test_346_2_draft_cross_pills.py b/resources/tester/test_346_2_draft_cross_pills.py
index 2ef7bcf4e..3e424dea6 100644
--- a/resources/tester/test_346_2_draft_cross_pills.py
+++ b/resources/tester/test_346_2_draft_cross_pills.py
@@ -38,20 +38,20 @@ def out():
 def test_노선_초안_동안_카드는_새_노선_상세(out):
     cards = out["cards"]
     assert cards["before"] == "saved"
-    assert cards["afterDraft"] == ["draft-profile-1", "draft-cross-1"]
+    assert cards["afterDraft"] == ["draft-cross-1"]  # profile 차례 중간 상세는 안 그림(365-4)
     assert cards["draftNow"] == "draft-cross-1"
 
 
 def test_숨은_동안은_안_그림(out):
     cards = out["cards"]
-    assert cards["whileHidden"] == ["draft-profile-1", "draft-cross-1"]
+    assert cards["whileHidden"] == ["draft-cross-1"]
     assert cards["hiddenNow"] == "draft-cross-2"
 
 
 def test_초안_버리면_저장_노선_카드(out):
     cards = out["cards"]
     assert cards["discarded"][-1] == "saved" and cards["savedNow"] == "saved"
-    assert cards["afterStop"] == 3  # 끊은 뒤엔 안 그림
+    assert cards["afterStop"] == 2  # 끊은 뒤엔 안 그림
 
 
 def test_알약은_따라간_누가거리(out):
diff --git a/resources/tester/test_346_3_route_save.py b/resources/tester/test_346_3_route_save.py
index 31624e733..2dc07d578 100644
--- a/resources/tester/test_346_3_route_save.py
+++ b/resources/tester/test_346_3_route_save.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-"""346-3 노선 저장 서버 길 — 차례 · 관 지킴 · 새 교차점 기본 관 · 오목 보충 · 이월 열쇠 ·
+"""346-3 노선 저장 서버 길 — 차례 · 관 지킴 · 새 교차점 기본 관 · 보충 없음(369) · 이월 열쇠 ·
 초기값 규칙 ·
 배수유역 낡음 · 실패 때 옛 노선 되살림.
 
@@ -41,14 +41,11 @@ import common_util.common_util_workflow_state as workflow  # noqa: E402
 from B05_Profile.B05_Profile_Route_Save_Parts import (  # noqa: E402
     add_crossing_pipes,
     carry_cross_inputs,
-    concave_chainages,
-    fill_concave_pipes,
     follow_pipes,
     station_keys,
     vertices_of,
 )
 from common_util.common_util_drainage_pipes import (  # noqa: E402
-    PIPE_SOURCE_SPACING,
     PIPE_SOURCE_STREAM,
     PipePoint,
     analysis_route_signature,
@@ -60,7 +57,7 @@ OLD = [(0.0, 0.0), (100.0, 0.0), (200.0, 0.0), (300.0, 0.0), (400.0, 0.0)]
 NEW = [(0.0, 0.0), (100.0, 0.0), (200.0, 60.0), (300.0, 0.0), (400.0, 0.0)]
 
 
-# ── 관 따라감 · 교차점 · 오목 보충 ─────────────────────────────────────────────
+# ── 관 따라감 · 교차점 ─────────────────────────────────────────────
 
 
 def test_관은_지우지_않고_좌표를_따라감():
@@ -91,29 +88,11 @@ def test_새_교차점에만_기본_관():
     assert add_crossing_pipes(pairs, crossings, OLD, 456.0) == 0
 
 
-def test_오목_지점_보충은_새_자리의_오목만():
-    vertices = vertices_of(NEW)
-    total = vertices[-1].chainage_m
-    chainage = np.arange(0.0, total, 2.0)
-    ground = 100.0 + np.abs(chainage - 220.0) * 0.05  # 220 m 에 골(새 자리)
-    ground[chainage < 60] = (
-        100.0 + np.abs(chainage[chainage < 60] - 30.0) * 0.05
-    )  # 30 m 골(옛 자리)
-    concave = concave_chainages(chainage, ground)
-    assert any(abs(at - 220.0) < 3 for at, _ in concave)
-    pairs: list = []
-    added = fill_concave_pipes(pairs, concave, vertices, OLD)
-    places = [pipe.chainage_m for _, pipe in pairs]
-    assert added >= 1 and all(pipe.source == PIPE_SOURCE_SPACING for _, pipe in pairs)
-    assert any(abs(at - 220.0) <= 3 for at in places)
-    assert not any(at < 60 for at in places)  # 옛 노선 위 오목엔 안 둠
+def test_노선_저장은_간격_보충_없음():
+    """369 — 오목 · 100 m 간격 보충은 배수유역 [자동 제안]만 · 노선 저장 부품에 없음."""
+    import B05_Profile.B05_Profile_Route_Save_Parts as parts
 
-
-def test_간격이_좁으면_보충_없음():
-    vertices = vertices_of(NEW)
-    pairs = [(0, PipePoint(chainage_m=at)) for at in (0.0, 90.0, 180.0, 270.0, 360.0, 450.0)]
-    concave = [(220.0, 99.0)]
-    assert fill_concave_pipes(pairs, concave, vertices, OLD) == 0
+    assert not hasattr(parts, "fill_concave_pipes") and not hasattr(save, "_ground_along")
 
 
 # ── 측점 열쇠 · 횡단 이월 ──────────────────────────────────────────────────────
@@ -366,7 +345,6 @@ def chain_world(monkeypatch, tmp_path):
     monkeypatch.setattr(watershed, "_prepare", prepare)
     monkeypatch.setattr(drainage_pipes, "clear_pipe_points", watershed_must_not_run)
     monkeypatch.setattr(drainage_pipes, "drainage_dir", lambda stored: drain)
-    monkeypatch.setattr(save, "_ground_along", lambda *a: (np.zeros(0), np.zeros(0)))
     monkeypatch.setattr(b06_router, "regenerate_route_sections", regenerate)
     monkeypatch.setattr(save, "_carry_profile", _async(None, order, "profile"))
     monkeypatch.setattr(save, "_carry_cross", _async(2, order, "cross"))
@@ -416,7 +394,8 @@ def test_차례와_배수유역_뗌(chain_world):
         "confirm",
     ]
     assert result["cross_dropped"] == 2 and result["drainage_stale"] is True
-    assert result["pipes"] == {"kept": 1, "crossing": 0, "concave": 0}
+    # 456 m 노선 · 관 하나 — 100 m 간격 보충 없음(369)
+    assert result["pipes"] == {"kept": 1, "crossing": 0}
     # 관 정본 = 새 노선 지문 · 배수유역 분석 지문(옛) 과 달라 B04 가 「낡음」
     saved = json.loads(chain_world.pipes_file.read_text("utf-8"))
     assert saved["route_signature"] == route_signature(vertices_of(NEW))
diff --git a/resources/tester/test_346_3_route_save_screen.py b/resources/tester/test_346_3_route_save_screen.py
index 09367553f..53ea15f9d 100644
--- a/resources/tester/test_346_3_route_save_screen.py
+++ b/resources/tester/test_346_3_route_save_screen.py
@@ -67,7 +67,7 @@ def test_저장_뒤_가게_초안_비움_결과_한_줄(out):
     assert out["storeAfterSave"] is None
     assert out["keptAfterSave"] == 1
     assert out["summary"] == (
-        "노선 저장 — 관 지킴 3 · 새 교차 관 1 · 오목 보충 관 2 · 구조물 옮김 1 · 멀어짐 0 · "
+        "노선 저장 — 관 지킴 3 · 새 교차 관 1 · 구조물 옮김 1 · 멀어짐 0 · "
         "노선 밖 고침 3 건 · 배수유역 낡음"
     )  # 서버 cross_dropped 1 + 화면 넘김 밖 2 = 한 줄
 
diff --git a/resources/tester/test_347_2_drainage_live_ui.py b/resources/tester/test_347_2_drainage_live_ui.py
index 77940dcd9..ef94e14fd 100644
--- a/resources/tester/test_347_2_drainage_live_ui.py
+++ b/resources/tester/test_347_2_drainage_live_ui.py
@@ -51,8 +51,7 @@ def test_suggestions_collected(r):
 def test_apply_once_without_touching_input(r):
     assert r["untouched"]
     applied = {pipe["chainage_m"]: pipe for pipe in r["applied"]}
-    assert sorted(applied) == [100, 200, 300, 500]
+    assert sorted(applied) == [100, 300, 500]  # 관 자리 후보(200)는 안 더함 — [자동 제안](369)
     assert applied[100]["options"]["pipe_diameter_mm"] == 1200
-    assert applied[200]["source"] == "spacing"
     assert applied[300]["facility"] == "ford_bridge"
     assert applied[500]["facility"] == "box_culvert"  # 이미 그 종류 — 그대로
diff --git a/resources/tester/test_347_pipe_id.py b/resources/tester/test_347_pipe_id.py
index 8d2175cee..4d334b6a4 100644
--- a/resources/tester/test_347_pipe_id.py
+++ b/resources/tester/test_347_pipe_id.py
@@ -95,3 +95,7 @@ def test_screen_reconcile_carries_id():
     assert result["moved"][1]["reason"] == "confirmed"
     assert [p.get("id") for p in result["added"]] == ["a1", "b2", None]
     assert [p.get("id") for p in result["twoMoved"]] == [None, None]
+    adopt = result["adopt"]
+    assert [p["id"] for p in adopt["next"]] == ["a1", "b2"]  # 369 되돌리기 — 그 걸음 초안 id
+    assert adopt["draft"][0]["facility"] == "ford_bridge"
+    assert result["adoptOther"] is None and result["adoptNone"] is None
diff --git a/resources/tester/test_349_0n_cross_enforce_mirror.py b/resources/tester/test_349_0n_cross_enforce_mirror.py
index ddf794d18..b692157b6 100644
--- a/resources/tester/test_349_0n_cross_enforce_mirror.py
+++ b/resources/tester/test_349_0n_cross_enforce_mirror.py
@@ -221,6 +221,9 @@ def test_포장_기울임_하강_판정_서버와_같음(r, server):
         hits["tilted"] += py["tilted"]
         hits["drop"] += py["drop"] > 0
     assert all(hits.values()), hits  # 셋 다 실제로 걸림
+    # 371-3 — 맹암거 자리 = 기울임 · 경사 비움(노면 표준 · 암거 경사는 형상 하단 경계)
+    drain = [py for ts_at, py in zip(r["ts"]["at"], r["rules"]) if ts_at["chainage"] == 160.0]
+    assert drain == [{"paved": False, "tilted": True, "tilt_pct": None, "drop": 0.0}]
 
 
 KEYS = (
diff --git a/resources/tester/test_349_drainage_live_flow.py b/resources/tester/test_349_drainage_live_flow.py
index c3583ee28..16ccc91f3 100644
--- a/resources/tester/test_349_drainage_live_flow.py
+++ b/resources/tester/test_349_drainage_live_flow.py
@@ -64,10 +64,38 @@ def test_suggestions_and_apply(r):
     assert len(r["suggest"]["rows"]) == 2
     points = {p["chainage_m"]: p for p in r["applied"]["points"]}
     assert points[100]["options"]["pipe_diameter_mm"] == 1200
-    assert points[200]["source"] == "spacing"
+    assert 200 not in points  # 관 자리 후보는 [적용]이 안 더함 — [자동 제안] 몫(369)
     assert r["applied"]["remembered"] == 1
 
 
+def test_자동_제안_두_방식_초기화_세류선만_한_걸음(r):
+    assert r["proposeStale"] == {
+        "off": True,
+        "title": "B05_Drainage_Btn_Propose_Stale",
+        "calls": 0,  # 낡은 동안 끔 — 눌러도 요청 없음
+    }
+    assert r["proposeFresh"] == {"off": False, "title": "B05_Drainage_Btn_Propose_Tip"}
+    assert r["propose"] == {
+        "autos": ["all", "add", None],
+        "points": [1, 1, None],  # ① ② = 지금 관 목록 함께 · 초기화 = 목록 없이(세류선만)
+        "remembered": 3,  # 셋 다 초안
+        "records": 3,  # 답마다 사진첩 한 걸음
+    }
+    # 저장 분석이 옛 노선 — 지금 노선으로 셈 길(detail-basins 안 부름) · 같은 초안 · 한 걸음
+    assert r["proposeLive"] == {
+        "auto": "all",
+        "points": 1,
+        "resetPoints": None,
+        "resetAuto": None,
+        "detailCalls": 0,
+        "remembered": 6,  # 앞 「409 → 다시」 한 번 포함
+        "records": 6,
+    }
+    fallback = r["proposeFallback"]
+    assert fallback["sent"] == 1 and fallback["auto"] == "all"
+    assert "낡음" not in fallback["status"]  # 409 글을 오류로 안 띄움(조용히 다시)
+
+
 def test_move_while_busy_cancels(r):
     moved = r["movedWhileBusy"]
     assert moved["aborted"] and moved["veil"] and not moved["busy"]
diff --git a/resources/tester/test_353_2_contour_lock.py b/resources/tester/test_353_2_contour_lock.py
index 9dc0a4c58..38ba30392 100644
--- a/resources/tester/test_353_2_contour_lock.py
+++ b/resources/tester/test_353_2_contour_lock.py
@@ -26,10 +26,11 @@ new Function("exports", "module", js)(m.exports, m);
 const L = m.exports;
 const levels = [101, 102, 105, 102, null];
 console.log(JSON.stringify({
-  hoverFree: L.lockButtonState(102, null),
-  hoverNone: L.lockButtonState(null, null),
-  hoverLocked: L.lockButtonState(102, 102),
-  hoverOther: L.lockButtonState(105, 102),
+  hitPicked: L.lockButtonState(102, null, true),
+  hitOnly: L.lockButtonState(102, null, false),
+  hitNone: L.lockButtonState(null, null, true),
+  hitLocked: L.lockButtonState(102, 102, false),
+  hitOther: L.lockButtonState(105, 102, true),
   lock: L.toggleLock(null, 102),
   unlock: L.toggleLock(102, 105),
   pickFree: L.canPickContour(null),
@@ -50,14 +51,16 @@ def got() -> dict:
     return json.loads(run.stdout)
 
 
-def test_안_잠김_단추는_높이_있는_가닥_위에서(got) -> None:
-    assert got["hoverFree"] == {"visible": True, "pressed": False}
-    assert got["hoverNone"]["visible"] is False
+def test_안_잠김_단추는_고른_가닥을_누를_때만(got) -> None:
+    """366-1 — 지나기만 · 고르지 않은 가닥 = 안 뜸."""
+    assert got["hitPicked"] == {"visible": True, "pressed": False}
+    assert got["hitOnly"]["visible"] is False
+    assert got["hitNone"]["visible"] is False
 
 
-def test_잠김_단추는_그_높이_위에서만_눌린_모양(got) -> None:
-    assert got["hoverLocked"] == {"visible": True, "pressed": True}
-    assert got["hoverOther"]["visible"] is False
+def test_잠김_단추는_잠근_높이_아무_가닥을_누를_때_풀기(got) -> None:
+    assert got["hitLocked"] == {"visible": True, "pressed": True}
+    assert got["hitOther"]["visible"] is False
 
 
 def test_누르면_잠금_다시_누르면_풂(got) -> None:
@@ -79,3 +82,9 @@ def test_편집기_이음() -> None:
     lock = (B05 / "B05_Profile_UI_RouteEdit_ContourLock.ts").read_text("utf-8")
     assert "hitPreparedLayer(" in lock and 'setAttribute("aria-pressed"' in lock
     assert "sessionStorage" not in lock and "writeState" not in lock  # 페이지 동안만
+    # 366-1 — 지나기(pointermove)로 안 띄움 · 뗀 자리 · 다음 클릭 · 휠 · 떠남에 숨김
+    assert '"pointermove"' not in lock
+    assert 'canvas.addEventListener("pointerup", showAt);' in lock
+    assert 'canvas.addEventListener("wheel", hide' in lock
+    assert 'canvas.addEventListener("pointerleave", hideLater);' in lock
+    assert "picked: pickedContour" in edit
diff --git a/resources/tester/test_354_1_masshaul_own_panel.py b/resources/tester/test_354_1_masshaul_own_panel.py
index b92159eb4..63c9d3601 100644
--- a/resources/tester/test_354_1_masshaul_own_panel.py
+++ b/resources/tester/test_354_1_masshaul_own_panel.py
@@ -3,8 +3,8 @@
 
 - 종단 열(`b05-route-profile__column`) = [종단 칸(bodyWrap), 유토 판] · content 안이라 종단 [창 분할]
   (`.is-popout > :not(content)` 숨김)에도 같이 감 · B05 · B06 이 같은 `design_profile` 하나.
-- 유토 판은 흐름 칸(겹침 아님) · 자기 리사이저 높이 · 접으면 머리줄만(손잡이 · [창 분할] 닿음).
-- 높이 나눔 · 표 쌓기에서 빠짐(표 bottomOffset 없음) · X 동기화는 그대로.
+- 유토 판은 흐름 칸(겹침 아님) · 자기 리사이저 높이 · 접으면 높이 0 · 손잡이만 매달림 · [창 분할] 숨김(367-2).
+- 높이 나눔 · 표 쌓기에서 빠짐(표 bottomOffset 없음) · X 동기화 없음(367-1 늘 전체 맞춤).
 """
 
 import os
@@ -30,7 +30,7 @@ def test_종단_열_아래_자기_칸():
     assert 'column.className = "b05-route-profile__column";' in overlays
     assert "column.append(bodyWrap, massHaul.overlay);" in overlays
     assert "bodyWrap.append(massHaul.overlay" not in overlays
-    assert "massHaul.attachScrollSync(body);" in overlays
+    assert "massHaul.attachScrollSync" not in overlays  # 367-1 측점 연계 없앰
     profile = read("A00_Common/design/design_profile.ts")
     assert "content.append(column);" in profile
     assert sum(1 for _ in profile.splitlines()) <= 700
@@ -57,6 +57,18 @@ def test_흐름_칸_자기_높이_접으면_머리줄():
         ".b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) > :not(.b05-profile__masshaul-head)",
     )
     assert "display: none;" in hide
+    # 367-2 접음 = 높이 0 · 손잡이 판 위 경계에 매달림 · [창 분할] 숨김(뗀 창 [창 결합] 그대로)
+    folded = css_block(css, ".b05-profile__masshaul-overlay.is-collapsed:not(.is-popout)")
+    assert "height: 0;" in folded
+    head = css_block(
+        css,
+        ".b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) > .b05-profile__masshaul-head",
+    )
+    assert "top: auto;" in head and "bottom: 100%;" in head
+    assert "display: none;" in css_block(
+        css, ".b05-profile__masshaul-overlay.is-collapsed:not(.is-popout) .b05-subpanel__popout"
+    )
+    assert ".is-popout .b05-subpanel__popout" not in css
     assert "display: none;" in css_block(
         css, ".b05-route-profile.is-collapsed .b05-profile__masshaul-overlay"
     )
diff --git a/resources/tester/test_354_2_masshaul_cross_only.py b/resources/tester/test_354_2_masshaul_cross_only.py
index fe84be732..b6ad7f172 100644
--- a/resources/tester/test_354_2_masshaul_cross_only.py
+++ b/resources/tester/test_354_2_masshaul_cross_only.py
@@ -37,7 +37,7 @@ def test_저장된_종단_범례는_횡단으로(r):
     assert r["longitudinal"] == ["cross"]
     assert r["longitudinalBalance"] == ["balance", "cross"]
     assert r["cross"] == ["cross"]
-    assert r["empty"] == ["cross"] and r["broken"] == ["cross"]
+    assert r["empty"] == ["balance", "cross"] and r["broken"] == ["balance", "cross"]
 
 
 def test_기준_횡단만_계산(r):
diff --git a/resources/tester/test_354_3_scroll_echo.py b/resources/tester/test_354_3_scroll_echo.py
index 869f9df34..9e5452d8f 100644
--- a/resources/tester/test_354_3_scroll_echo.py
+++ b/resources/tester/test_354_3_scroll_echo.py
@@ -4,14 +4,13 @@
 - 메아리: scroll 은 다음 틀에 옴 → 동기 플래그로 못 막아 한 틀 전 값을 되씀 → 뒤로 튐 →
   휠 이동이 접힘. 공용 `linkScrollLeft`(Wheel.ts)가 써 넣은 값으로 온 scroll 을 무시.
   가짜 창(다음 틀 scroll) 재현 — 옛 잇기는 뒤로 튐 · 멈춤, 새 잇기는 4 경우 × 휠 쪽 둘 모두 튐 0.
-- 유토 스크롤 그리기 = 열림 · 분배 맞춤 아님 · 붙음일 때만 · 한 틀 한 번 · 다시 셈 없음.
+- 유토곡선 = 늘 전체 맞춤 · 종단과 안 이음(367-1) — 휠 · 잇기 경우는 공용 도우미 시험으로 남김.
 
 `helper_354_3_scroll_echo.cjs` 가 진짜 휠 · 잇기 TS 를 가짜 창 위에서 돌림.
 """
 
 import json
 import os
-import re
 import subprocess
 from pathlib import Path
 
@@ -64,24 +63,25 @@ def test_새_잇기는_뒤로_튐_0_끝까지(r, case):
     assert got["mass"] == (0 if balance else 1200)
 
 
-def test_유토_표_같은_도우미():
-    for name in ("MassHaul", "TableOverlay"):
-        src = (B05 / f"B05_Profile_UI_Profile_{name}.ts").read_text(encoding="utf-8")
-        assert "linkScrollLeft(main, scroll" in src
-        assert "syncing" not in src
-
-
-def test_유토_스크롤_그리기는_창_따를_때만_한_틀_한_번():
+def test_표만_잇기_유토는_안_이음():
+    # 367-1 유토곡선 = 늘 전체 맞춤 · 종단 스크롤과 안 이음
+    table = (B05 / "B05_Profile_UI_Profile_TableOverlay.ts").read_text(encoding="utf-8")
+    assert "linkScrollLeft(main, scroll" in table
+    assert "syncing" not in table
     mass = (B05 / "B05_Profile_UI_Profile_MassHaul.ts").read_text(encoding="utf-8")
-    body = mass[mass.index("function drawWindow(") :]
-    body = body[: body.index("\n  }\n")]
-    assert '!open || fitted || overlay.classList.contains("is-popout") || !lastSeries' in body
-    assert "windowState.frame" in body and "frameOf(overlay" in body
-    assert "draw(lastParams, true)" in body
-    # 다시 셈 없음 · 총괄값 · 범례는 계열이 바뀔 때만
-    assert re.search(r"reuse && lastSeries\s*\? lastSeries", mass)
+    for gone in ("linkScrollLeft", "attachWheelHorizontalScroll", "attachScrollSync", "drawWindow"):
+        assert gone not in mass, gone
+
+
+def test_유토는_늘_전체_맞춤_스크롤마다_안_그림():
+    mass = (B05 / "B05_Profile_UI_Profile_MassHaul.ts").read_text(encoding="utf-8")
+    assert "hideStations: true," in mass
+    assert "viewRange: undefined," in mass
+    assert "scroll.scrollLeft = 0;" in mass
+    assert "createMassHaulWindowState" not in mass and "scheduleMassHaulSettle" not in mass
     assert "if (series !== lastSeries) emitSummary(series);" in mass
-    # 다시 그려도 제 자리 — 종단 값으로 되쓰는 것은 처음 · 맞춤 뒤 · 창 옮김 뒤만
-    assert "scroll.scrollLeft = syncedMain.scrollLeft" not in mass
     render = (B05 / "B05_Profile_UI_Profile_Render.ts").read_text(encoding="utf-8")
-    assert "massHaul.drawWindow({" in render
+    assert "drawWindow" not in render and "massHaulUpdater" not in render
+    css = (B05 / "B05_Profile_UI_Style_MassHaul.css").read_text(encoding="utf-8")
+    block = css[css.index(".b05-profile__masshaul-scroll {") :]
+    assert "overflow-x: hidden;" in block[: block.index("}")]
diff --git a/resources/tester/test_356_b06_card_center.py b/resources/tester/test_356_b06_card_center.py
index e3150e9fa..672cd09f2 100644
--- a/resources/tester/test_356_b06_card_center.py
+++ b/resources/tester/test_356_b06_card_center.py
@@ -82,11 +82,9 @@ def test_배선():
     pick = (B06 / "B06_Section_UI_Cross_Design_Pick.ts").read_text(encoding="utf-8")
     assert "center: section.chainage_m," in pick  # designLineMoves → 카드 고름 끝 조각
     assert 'if (axis === "center") return centerShift?.step(dir);' in pick
-    # 364-7 덧 — 중심점 ◀▶ 툴팁 = 노선 좌우 · ↺ · 소단 ▲▼ 숨김
+    # 364-7 덧 — 중심점 ◀▶ 툴팁 = 노선 좌우 · ↺ 없음 · 소단 ▲▼ 없음(370-3 공용 칸 = 축에 맞는 버튼만)
     assert "`이 측점 노선을 화면 ${screen}으로 0.1 m`" in pick
-    assert '[toLeft.title, toRight.title] = [stepTitle("왼쪽"), stepTitle("오른쪽")];' in pick
-    assert 'move.controls.children[1]?.classList.toggle("is-hidden", axis === "center");' in pick
-    assert 'lift.row.classList.toggle("is-hidden", axis !== "depth");' in pick
+    assert 'title: "중심점", value: centerPreviewText(0), buttons: sideways(false)' in pick
     order = (B06 / "B06_Section_UI_Cross_Pick_Order.ts").read_text(encoding="utf-8")
     assert "layer.append(...surfaces, ...edges, ...lines, ...centers);" in order
     edit = (ROOT / "B05_Profile" / "B05_Profile_UI_RouteEdit.ts").read_text(encoding="utf-8")
diff --git a/resources/tester/test_365_page_pipeline.py b/resources/tester/test_365_page_pipeline.py
new file mode 100644
index 000000000..a77d6797b
--- /dev/null
+++ b/resources/tester/test_365_page_pipeline.py
@@ -0,0 +1,205 @@
+"""PLAN 365 sub7 — 평면 > 종단 <> 횡단 한 방향 · 묶음 주인 = 페이지 · 캐시 · 고리.
+
+못박는 것(365-1)
+  - 묶음은 페이지(종단도 한 벌 `sharedProfile`)가 세움 — 종단 보기는 다리만 받음(옵션 안 넘김).
+  - 노선 초안 둔 채 다시 열기(새로고침 · B06 바로 열기 · 편집기 없음) = B05 길과 같은 초안 상세
+    (측점 · 계획고 · 면적) · 측점을 가게에 다시 냄 · 초안 전 = 저장 상세(열 때 맡김) → 버리면 saved.
+  - 초안 동안 측점 갈아끼움은 메모리만 — 세션 상세(저장 노선)를 새 측점 + 옛 설계로 덮지 않음.
+못박는 것(365-2)
+  - 초안 동안 B06 고침(세션 칸 · 측점 열쇠) → `pipelineCross` → 묶음 cross 입력 · 카드에 보임.
+  - 고리 — 같은 입력 = 0 바퀴 · 세션만 바뀜 = 1 바퀴 · 안 맞으면 3 바퀴 뒤 「계산 불안정」 한 번.
+못박는 것(365-3)
+  - B05 오른쪽 횡단 판 = 묶음 그 측점 — 계획고 · 절토 면적 · 표본 = B06 카드 · 서버 길 없음.
+못박는 것(365-4)
+  - 저장 노선 ▲▼ 한 번 = 횡단 한 벌 — 묶음 cross 가 다시 셈 창구(상세 설계) 한 번 · 종단도 예약 끔.
+  - 중심점 좌우 = 노선 차례는 cross 전에 밀림 → cross 한 번(계획고 맞춤 차례만).
+  - B06 다시 그림 = 겹친 신호(갈아끼움 · 묶음 cross · 초안) 한 번 · profile 차례는 안 그림.
+
+짝: `helper_365_page_pipeline.cjs`(진짜 TS · 서버 창구만 가짜 · 틀 = 346-2 시험) ·
+`helper_365_swap_entry.ts` + `helper_365_swap.mjs`(진짜 상세 가게 · vite ssr).
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+if str(HERE) not in sys.path:
+    sys.path.insert(0, str(HERE))
+
+import test_346_2_pipeline_cross_page as base  # noqa: E402
+
+from common_util.common_util_surface_sampler import DtmGridSampler, dtm_grid_bytes  # noqa: E402
+
+pytestmark = base.pytestmark
+
+
+def _job(folder: Path) -> tuple[Path, Path]:
+    npz, nodes = base._fake(folder)
+    line = base._line(nodes)
+    sampler = DtmGridSampler.from_npz(npz)
+    pipes = base._pipes(line)
+    saved = base._sections(line, sampler, pipes)
+    options = base.resolve_grade_options("trunk", terrain_type="normal", paved=False, stored=None)
+    policy = base.design_ground_following_profile(saved["longitudinal"], options)[0]["policy"]
+    job = {
+        "nodes": nodes,
+        "line": line,
+        "minRadius": base.MIN_RADIUS_M,
+        "policy": policy,
+        "types": base._types(),
+        "interval": base.INTERVAL_M,
+        "pipes": pipes,
+        "standard": base.STANDARD_CROSS_SECTION,
+        "conversion": base.ONES,
+        "detail": base._saved_detail(saved),
+        "haulDelayMs": 10,
+    }
+    path = folder / "job.json"
+    path.write_text(json.dumps(job), encoding="utf-8")
+    grid = folder / "grid.bin"
+    grid.write_bytes(dtm_grid_bytes(npz))
+    return path, grid
+
+
+@pytest.fixture(scope="module")
+def r() -> dict:
+    with tempfile.TemporaryDirectory() as folder:
+        path, grid = _job(Path(folder))
+        proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
+            ["node", str(HERE / "helper_365_page_pipeline.cjs"), str(path), str(grid)],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            timeout=180,
+        )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def test_365_1_묶음_주인_페이지():
+    shared = (ROOT / "A00_Common/design/design_shared.ts").read_text(encoding="utf-8")
+    view = (ROOT / "A00_Common/design/design_view_profile.ts").read_text(encoding="utf-8")
+    assert "routeDraftBridge(projectId, profile, {" in shared  # 종단도 한 벌과 함께 세움
+    assert "draft: routeDraftBridge(activeProjectId, profilePanel)," in view  # 다리만 받음
+    assert "holdDraft" not in view and "holdDraft" in shared
+
+
+def test_365_1_초안_둔_채_열기_같은_초안(r):
+    b05, b06 = r["b05"], r["b06"]
+    assert r["kept"]  # 떠나도 세션 초안 남음
+    assert b05["rows"] and b06["rows"] == b05["rows"]  # 측점 · 계획고 · 면적 같음
+    assert b06["outcome"] == "done" and "cross" in b06["stages"]
+    assert b06["stations"] == b05["stations"] == [row[0] for row in b05["rows"]]  # 측점 다시 냄
+    assert b05["holds"] == ["saved"] and b06["holds"] == ["saved"]  # 초안 전 = 저장 상세
+
+
+def test_365_1_초안_버림_저장_정본(r):
+    d = r["dropped"]
+    assert d["detail"] is None and d["routeDraft"] is None
+    assert d["restoreWhy"] == "saved"
+
+
+def test_365_2_초안_동안_횡단_고침_카드에(r):
+    e = r["edit"]
+    assert e["before"] != "blasting_rock"
+    assert e["input"] == "blasting_rock" and e["after"] == "blasting_rock"
+    assert e["runs"] == 1 and e["sources"] == ["cross"]
+
+
+def test_365_2_고리_바퀴_수(r):
+    loop = r["loop"]
+    assert loop["same"] == 0 and loop["sameRuns"] == 0  # 같은 입력 = 안 돎
+    assert loop["once"] == 1 and loop["onceRuns"] == 1 and loop["onceGround"] == "ripping_rock"
+    assert loop["unstable"] == -1 and loop["unstableRuns"] == 3 and loop["alerts"] == 1
+
+
+def test_365_3_평면_횡단_판_카드와_같음(r):
+    p = r["pane"]
+    assert p["count"] > 5 and p["same"] == p["count"]
+    assert p["elevation"] is not None
+
+
+def test_365_3_서버_횡단_미리보기_길_없음():
+    router = (ROOT / "B05_Profile/B05_Profile_Router_Terrain.py").read_text(encoding="utf-8")
+    api = (ROOT / "B05_Profile/B05_Profile_Api_Replan.ts").read_text(encoding="utf-8")
+    edit = (ROOT / "B05_Profile/B05_Profile_UI_RouteEdit.ts").read_text(encoding="utf-8")
+    assert "cross-preview" not in router and "cross-preview" not in api
+    assert "crossPreview.refresh()" not in edit  # 묶음 cross 차례가 그림
+
+
+def test_365_4_저장_노선_계획고_횡단_한_벌(r):
+    s = r["saved"]
+    assert s["owns"] and s["openCalls"] == 1
+    assert s["gradeCalls"] == 1 and s["runs"] == 1 and s["sources"] == ["grade"]
+    assert s["fromDetail"]  # 묶음 cross = 상세 설계 그대로(엔진 따로 안 셈)
+
+
+def test_365_4_중심점_좌우_횡단_한_번(r):
+    runs = r["shiftRuns"]
+    assert [x["outcome"] for x in runs] == ["dropped", "done"], runs
+    assert [x["cross"] for x in runs] == [False, True]
+    assert runs[1]["sources"] == ["route", "grade"]  # 밀린 노선 범위 + 계획고 = 한 차례
+
+
+def test_365_4_다시_그림_한_번():
+    swap = (ROOT / "B06_Section/B06_Section_UI_Page_Station_Swap.ts").read_text(encoding="utf-8")
+    view = (ROOT / "A00_Common/design/design_view_cross.ts").read_text(encoding="utf-8")
+    profile = (ROOT / "A00_Common/design/design_profile.ts").read_text(encoding="utf-8")
+    assert 'event.stage !== "cross") return;' in swap  # profile 차례 중간 상세는 안 그림
+    body = view.split("async function refreshDetailForStructures")[1].split("loadSectionDetail")[0]
+    assert "setTimeout(next, 0)" in body  # 겹친 신호는 seq 가 앞 차례를 버림 = 한 번
+    assert "if (!pagePipeline.pipelineOwnsCross(projectId)) scheduleCrossPreview();" in profile
+
+
+@pytest.fixture(scope="module")
+def swap(tmp_path_factory) -> dict:
+    work = tmp_path_factory.mktemp("b365")
+    build = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        [
+            "node",
+            str(ROOT / "config" / "node_modules" / "vite" / "bin" / "vite.js"),
+            "build",
+            "--configLoader",
+            "runner",
+            "--ssr",
+            "../resources/tester/helper_365_swap_entry.ts",
+            "--outDir",
+            str(work),
+            "--logLevel",
+            "error",
+        ],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=300,
+    )
+    assert build.returncode == 0, build.stderr
+    bundle = work / "bundle.mjs"
+    shutil.copy(work / "helper_365_swap_entry.js", bundle)
+    proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", str(HERE / "helper_365_swap.mjs"), str(bundle)],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=120,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def test_365_1_초안_동안_세션_상세_안_덮음(swap):
+    d = swap["draft"]
+    assert d["swapped"] and d["cache"] == [0, 20, 30, 40, 60]  # 메모리 = 초안 측점
+    assert d["session"] == [0, 20, 40, 60]  # 세션 = 저장 노선 그대로
+    s = swap["saved"]
+    assert s["swapped"] and s["session"] == s["cache"] == [0, 20, 50, 60]  # 초안 없으면 세션도
diff --git a/resources/tester/test_366_3_station_fit.py b/resources/tester/test_366_3_station_fit.py
new file mode 100644
index 000000000..d816fcbef
--- /dev/null
+++ b/resources/tester/test_366_3_station_fit.py
@@ -0,0 +1,85 @@
+"""366-3 측점 스냅 = 곡선 가운데(MC)를 일반측점에 — `logic/B05_Profile_RouteEdit_StationFit.ts`
+를 Node(`helper_366_3_station_fit.cjs`)로 돌려 판정 + 편집기 이음(놓을 때 · applyEdit · 켤 때 ·
+되돌리기 · 추천 적용은 안 맞춤 · 상태줄 「측점 밖 곡선 N개」).
+
+    ./venv/Scripts/python.exe -m pytest resources/tester/test_366_3_station_fit.py -q
+"""
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+B05 = ROOT / "B05_Profile"
+HELPER = Path(__file__).with_name("helper_366_3_station_fit.cjs")
+TOL = 0.05
+
+
+@pytest.fixture(scope="module")
+def got() -> dict:
+    run = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", str(HELPER)], capture_output=True, text=True, encoding="utf-8", timeout=60
+    )
+    assert run.returncode == 0, run.stderr
+    return json.loads(run.stdout)
+
+
+def test_맞추기_전_곡선은_측점_밖(got) -> None:
+    assert got["before"]["off"] == got["before"]["curves"] == 5
+
+
+def test_MC_는_일반측점_위(got) -> None:
+    fit = got["all"]
+    assert fit["curves"] == 5 and fit["off"] == 0
+    assert max(fit["residues"]) <= TOL
+    stations = [round(mc / 20) for mc in fit["mcs"]]
+    assert all(n >= 1 for n in stations) and len(set(stations)) == len(stations)
+
+
+def test_곡선_수는_측점_수_이하(got) -> None:
+    assert got["all"]["curves"] <= got["all"]["innerStations"]
+
+
+def test_시점_종점_고정_IP_그대로_밀림은_간격_절반_안(got) -> None:
+    for case in ("all", "locked", "fromLater"):
+        moved = got[case]["moved"]
+        assert moved[0] == 0 and moved[-1] == 0
+        assert max(moved) <= 10 + 1e-6
+    assert got["locked"]["moved"][3] == 0
+
+
+def test_못_놓은_곡선은_그대로_개수(got) -> None:
+    assert got["locked"]["off"] == 1  # 고정 IP 곡선 하나만 밖 · 나머지는 맞춤
+    assert got["everyLocked"]["off"] == 5 and max(got["everyLocked"]["moved"]) == 0
+
+
+def test_고친_자리부터만(got) -> None:
+    moved = got["fromLater"]["moved"]
+    assert moved[1:4] == [0, 0, 0] and moved[4] > 0
+    assert got["fromLater"]["residues"][3:] == pytest.approx([0, 0], abs=TOL)
+
+
+def test_맞춘_선은_다시_맞춰도_그대로_간격_0_은_안_맞춤(got) -> None:
+    assert max(got["again"]) == 0 and max(got["noInterval"]) == 0
+
+
+def test_시작_자리는_고친_꺾임점_앞(got) -> None:
+    start = got["start"]
+    assert start["moved4"] == 3 and start["radius2"] == 1
+    assert start["dropLast"] == 4  # 지운 마지막 꺾임점 → 새 끝 앞 곡선부터
+    assert start["same"] == 1 and start["none"] == 1
+
+
+def test_편집기_이음() -> None:
+    edit = (B05 / "B05_Profile_UI_RouteEdit.ts").read_text("utf-8")
+    assert "fitCurveStations(" in edit
+    # 되돌리기 · 추천 [적용] · 초안 되살림이 지나는 restoreSnapshot 은 안 맞춤
+    at = edit.index("function restoreSnapshot(")
+    assert "applyEdit(message, record, false);" in edit[at : at + 700]
+    assert len(edit.splitlines()) <= 700
+    edits = (B05 / "logic" / "B05_Profile_UI_RouteEdit_Edits.ts").read_text("utf-8")
+    assert "측점 밖 곡선 " in edits
+    chrome = (B05 / "B05_Profile_UI_RouteEdit_Chrome.ts").read_text("utf-8")
+    assert "곡선 가운데(MC)를 가까운 일반측점에" in chrome
diff --git a/resources/tester/test_369_drainage_auto.py b/resources/tester/test_369_drainage_auto.py
new file mode 100644
index 000000000..e342a71ea
--- /dev/null
+++ b/resources/tester/test_369_drainage_auto.py
@@ -0,0 +1,134 @@
+"""369 배수 구조물 자리 — 기본 = 세류선 교차만 · [자동 제안] 두 방식(all · add).
+
+- 기본(auto 없음) = 세류선 교차 관만 · 100 m 보충 없음 · 관 자리 후보는 셈.
+- all = 세류선 + 100 m 보충으로 다시(지금 목록 무시) · 같은 자리(0.05 m) 관은 속성 · id 유지 ·
+  나머지 = 새 관(등록부 기본값).
+- add = 지금 목록 그대로 + 빈 구간 보충 · 더한 관 = 새 관(등록부 기본값).
+- 틀린 auto = 400 · 저장본 열쇠에 auto.
+"""
+
+import asyncio
+from pathlib import Path
+from uuid import uuid4
+
+import numpy as np
+
+from B04_PreProcess import B04_PreProcess_Router_Basins as basins
+from B04_PreProcess.B04_PreProcess_Engine_Watershed_Grid import GridSpec
+from common_util.common_util_drainage_context import DrainageContext
+from common_util.common_util_drainage_detail import RoadRouting, build_detail
+from common_util.common_util_drainage_pipes import PipePoint
+from common_util.common_util_route_geometry import RouteVertex, StructureCandidate
+
+VERTICES = [RouteVertex(0.0, 0.0, 100.0, 0.0), RouteVertex(300.0, 0.0, 90.0, 300.0)]
+CONTEXT = DrainageContext(stored_path="x", project_root=Path("."), vertices=VERTICES)
+
+
+def _routing() -> RoadRouting:
+    spec = GridSpec(x_min=-5.0, y_max=5.0, cell_m=1.0, n_rows=10, n_cols=310)
+    road_index = np.arange(5 * 310 + 5, 5 * 310 + 305, dtype=np.int32)
+    road_slot = np.full(spec.size, -1, dtype=np.int32)
+    road_slot[road_index] = np.arange(road_index.size)
+    return RoadRouting(
+        spec=spec,
+        road_slot=road_slot,
+        path_length=np.zeros(spec.size, np.float32),
+        elevation=np.full(spec.size, 95.0, np.float32),
+        road_cell_index=road_index,
+        road_chainage=np.arange(road_index.size, dtype=np.float64),
+        strength=np.ones(road_index.size, np.int64),
+        base_pipes=[StructureCandidate(chainage_m=150.0, x=150.0, y=0.0, reason="stream")],
+    )
+
+
+def _detail(tmp_path, chainages=None, auto=None):
+    return build_detail(tmp_path / "없음", VERTICES, chainages, _routing(), [], auto)
+
+
+def test_기본은_세류선_교차만(tmp_path):
+    detail = _detail(tmp_path)
+    assert [(p.chainage_m, p.reason) for p in detail.pipes] == [(150.0, "stream")]
+    assert len(detail.pipe_candidates) == 2  # 0~150 · 150~300 이 100 m 넘음 — 제안만
+
+
+def test_all_은_세류선_더하기_100m_보충_지금_목록_무시(tmp_path):
+    detail = _detail(tmp_path, [10.0, 150.02], "all")
+    reasons = [p.reason for p in detail.pipes]
+    places = [p.chainage_m for p in detail.pipes]
+    assert reasons.count("stream") == 1 and reasons.count("spacing") == 2
+    assert 150.02 in places and 10.0 not in places  # 세류선 150 m 0.5 m 안의 지금 관 = 그 자리
+    gaps = np.diff([0.0, *places, 300.0])
+    assert gaps.max() <= 100.0 and not detail.pipe_candidates
+
+
+def test_add_는_지금_목록_더하기_빈_구간_보충(tmp_path):
+    detail = _detail(tmp_path, [20.0], "add")
+    places = [p.chainage_m for p in detail.pipes]
+    assert 20.0 in places and len(places) == 3  # 20 ~ 300 = 280 m → 보충 둘
+    assert np.diff([0.0, *places, 300.0]).max() <= 100.0
+    # auto 없음 = 목록 그대로(보충은 후보만)
+    plain = _detail(tmp_path, [20.0])
+    assert [p.chainage_m for p in plain.pipes] == [20.0] and len(plain.pipe_candidates) == 2
+
+
+def _build(tmp_path, monkeypatch, points, auto):
+    monkeypatch.setattr(basins, "drainage_dir", lambda stored: tmp_path / "없음")
+    return basins._build("x", CONTEXT, points, _routing(), [], auto=auto)
+
+
+def test_all_같은_자리_관은_속성_id_유지_새_관은_기본값(tmp_path, monkeypatch):
+    kept = PipePoint(
+        chainage_m=150.3,  # 세류선 150 m 에서 0.3 m — 노선 따라감으로 어긋난 같은 관
+        source="user",
+        facility="ford_bridge",
+        options={"ford_width_m": 4.0},
+        id="keep",
+    )
+    gone = PipePoint(chainage_m=10.0, source="user", options={"pipe_diameter_mm": 600}, id="gone")
+    _, carried = _build(tmp_path, monkeypatch, [gone, kept], "all")
+    ford = [p for p in carried if p.id == "keep"]
+    assert len(ford) == 1 and ford[0].facility == "ford_bridge" and ford[0].source == "user"
+    assert ford[0].chainage_m == 150.3  # 그 자리 그대로
+    assert all(p.id != "gone" for p in carried)
+    fresh = [p for p in carried if p.id != "keep"]
+    assert len(fresh) == 2 and all(p.source == "spacing" for p in fresh)
+    assert all((p.options or {}).get("pipe_diameter_mm") for p in fresh)  # 등록부 관경
+
+
+def test_add_더한_관은_기본값_지금_관은_그대로(tmp_path, monkeypatch):
+    mine = PipePoint(chainage_m=20.0, source="user", id="mine")
+    _, carried = _build(tmp_path, monkeypatch, [mine], "add")
+    assert [p.id for p in carried].count("mine") == 1
+    assert next(p for p in carried if p.id == "mine").options is None  # 옛 빈칸 = 미확정 유지
+    added = [p for p in carried if p.id != "mine"]
+    assert len(added) == 2 and all(p.source == "spacing" for p in added)
+    assert all((p.options or {}).get("pipe_diameter_mm") for p in added)
+
+
+def test_틀린_auto_는_400_열쇠에_auto(tmp_path, monkeypatch):
+    async def load(project_id):
+        return CONTEXT, ""
+
+    monkeypatch.setattr(basins, "load_drainage_context", load)
+    monkeypatch.setattr(basins, "drainage_dir", lambda stored: tmp_path)
+    result = asyncio.run(basins._resolve(uuid4(), {"auto": "spacing"}, use_stored=False))
+    assert result.status_code == 400
+    points = [PipePoint(chainage_m=20.0)]
+    keys = {basins._detail_key(CONTEXT, points, auto) for auto in basins.AUTO_MODES}
+    assert len(keys) == 3
+
+
+def test_낡은_분석에_auto_는_409(monkeypatch):
+    async def load(project_id):
+        return CONTEXT, ""
+
+    monkeypatch.setattr(basins, "load_drainage_context", load)
+    monkeypatch.setattr(basins, "analysis_route_signature", lambda stored: "옛 노선")
+    points = [{"chainage_m": 20.0}]
+    for auto in ("all", "add"):
+        result = asyncio.run(
+            basins._resolve(uuid4(), {"points": points, "auto": auto}, use_stored=False)
+        )
+        assert result.status_code == 409  # 말없이 그대로 돌려주지 않음 — 낡음 까닭
+    kept = asyncio.run(basins._resolve(uuid4(), {"points": points}, use_stored=False))
+    assert kept[-1] is True  # auto 없음 = 관 자리만 낡음으로(그대로)
diff --git a/resources/tester/test_370_2_toe_stop.py b/resources/tester/test_370_2_toe_stop.py
new file mode 100644
index 000000000..e40accd7e
--- /dev/null
+++ b/resources/tester/test_370_2_toe_stop.py
@@ -0,0 +1,79 @@
+"""PLAN 370-2 — B06 사면 이동 멈춤 · 교차점 손잡이 · 고름 이어받기(요구 240-14).
+
+짝: `B06_Section/logic/B06_Section_UI_Cross_Fit.ts`(`extendStop` · `toePoints`) ·
+`B06_Section/B06_Section_UI_Cross_Design_Pick.ts`(손잡이 · 키 이어받기). 실제 TS 를
+`helper_370_2_toe_stop.cjs` 가 Node 로 돌린다.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+
+import pytest
+
+HERE = os.path.dirname(__file__)
+ROOT = os.path.join(HERE, "..", "..")
+if ROOT not in sys.path:
+    sys.path.insert(0, ROOT)
+
+from config.config_system import STANDARD_CROSS_SECTION  # noqa: E402
+
+pytestmark = pytest.mark.skipif(
+    not os.path.isdir(os.path.join(ROOT, "config", "node_modules")),
+    reason="프론트엔드 의존성 미설치",
+)
+
+
+@pytest.fixture(scope="module")
+def out(tmp_path_factory) -> dict:
+    standard = tmp_path_factory.mktemp("std") / "standard.json"
+    standard.write_text(json.dumps(STANDARD_CROSS_SECTION), encoding="utf-8")
+    proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", os.path.join(HERE, "helper_370_2_toe_stop.cjs"), str(standard)],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stderr
+    return json.loads(proc.stdout)
+
+
+def test_노견_끝이_원지반을_지나면_그_자리에_한_번_섬(out) -> None:
+    stop = out["stop"]
+    low, high = stop["crossing"]
+    assert low < stop["value"] < high
+    assert stop["gap"] < 2e-3  # 노견 끝 = 원지반
+    assert stop["noCross"] == 0.1  # 안 지나면 걸음 그대로
+    assert abs(stop["fromStop"] - round(stop["value"] + 0.1, 1)) < 1e-9  # 멈춘 뒤엔 다시 안 섬
+    assert stop["leftNoGround"] == 0.1  # 지반 없으면 그대로
+
+
+def test_교차점_손잡이_쪽마다_늘_보임(out) -> None:
+    toe = out["toe"]
+    assert toe["count"] == len(toe["sides"]) == 2
+    assert toe["centerClass"] is True  # 중심점 원과 같은 고르기 차례
+    assert toe["rightOnGround"] is True
+    assert abs(toe["rightCx"] - toe["rightX"]) < 1e-9
+
+
+def test_손잡이를_고르면_그_쪽_사면_좌우_이동(out) -> None:
+    got = out["toePick"]
+    assert got["active"] is True and got["panelOpen"] is True
+    assert got["title"] == "교차점 이동 (우)"  # 아래 띠 공용 칸(370-3)
+    assert got["value"].startswith("노선에서 ")
+    assert len(got["sent"]) == 1 and got["sent"][0]["side"] == "right"
+    low, high = out["stop"]["crossing"]
+    assert abs(got["sent"][0]["valueM"] - out["stop"]["value"]) < 1e-9  # ◀▶ 도 멈춤 자리
+    assert low < got["sent"][0]["valueM"] < high
+
+
+def test_절에서_성으로_넘어가도_고름_유지(out) -> None:
+    inherit = out["inherit"]
+    assert inherit["cutIndex"] >= 0 and inherit["before"] == inherit["cutIndex"]
+    assert inherit["farMode"] == "left_cut"  # 우 = 성토로 넘어감
+    assert inherit["afterIndex"] is not None
+    assert inherit["label"] == "교차점 이동 (우)"
diff --git a/resources/tester/test_370_3_rock_cell.py b/resources/tester/test_370_3_rock_cell.py
new file mode 100644
index 000000000..c1e579be8
--- /dev/null
+++ b/resources/tester/test_370_3_rock_cell.py
@@ -0,0 +1,93 @@
+"""PLAN 370-3 — B06 암 경계선 고름 · 방향키 · 세로 끌기 · 아래 띠 공용 칸(요구 240-22).
+
+짝: `B06_Section/B06_Section_UI_Cross_Design_Pick.ts`(rock 축 · 판정 선) ·
+`B06_Section/B06_Section_UI_Cross_Line_Cell.ts`(공용 칸) · `B06_Section_UI_Cross_Center.ts`(`bindAxisDrag`).
+실제 TS 를 `helper_370_3_rock_cell.cjs` 가 Node 로 돌린다.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+HELPER = Path(__file__).parent / "helper_370_3_rock_cell.cjs"
+B06 = ROOT / "B06_Section"
+
+pytestmark = pytest.mark.skipif(
+    not (ROOT / "config" / "node_modules").is_dir(), reason="프론트엔드 의존성 미설치"
+)
+
+
+@pytest.fixture(scope="module")
+def out() -> dict:
+    done = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", str(HELPER)], cwd=str(ROOT), capture_output=True, text=True, encoding="utf-8"
+    )
+    assert done.returncode == 0, done.stderr
+    return json.loads(done.stdout)
+
+
+def test_안_고르면_공용_칸은_암_버튼과_값(out: dict) -> None:
+    idle = out["idle"]
+    assert idle["title"] == "암 경계선" and idle["value"] == "-0.5m"
+    assert idle["slots"] == ["up", "reset", "down"]
+    assert idle["upPassed"] is True  # 안 고르면 ▲▼ = 종단 계획고 그대로
+    assert idle["offsets"] == [0.1, -0.1] and idle["resets"] == 1
+
+
+def test_암_경계선_판정_선(out: dict) -> None:
+    hit = out["hit"]
+    assert hit["found"] and hit["tag"] == "path" and hit["moves"] == 2  # 끊긴 두 토막 한 판정
+    assert hit["last"] and hit["picked"] == [3]  # 조각 셋 뒤 · 누르면 고름
+
+
+def test_암_고름은_위아래만_암_키는_암만(out: dict) -> None:
+    got = out["picked"]
+    assert got["active"] and got["key"]  # 키 rock 으로 기억
+    assert got["title"] == "암 경계선" and got["slots"] == ["up", "reset", "down"]
+    assert got["leftBlocked"] and got["rightBlocked"]  # ◀▶ 막음
+    assert got["upTaken"] and got["downTaken"]  # ▲▼ = 암(종단으로 안 샘)
+    assert got["sideValues"] == {"left": 0, "right": 0}
+    assert got["offsets"][:2] == [0.1, -0.1]
+
+
+def test_세로_끌기는_놓을_때_한_번(out: dict) -> None:
+    drag = out["drag"]
+    assert drag["stopped"] is True  # 카드 팬으로 안 번짐
+    assert drag["during"]["rock"] == drag["during"]["hit"]  # 점선 · 판정 선 같이
+    dy = float(drag["during"]["rock"].split()[1].removesuffix("px"))
+    assert abs(dy - (-0.3 * 12)) < 1e-9  # 위로 0.3 m(화면 px = m × 12)
+    assert drag["during"]["value"] == "-0.2m — 놓으면 반영"
+    assert drag["sent"] == [0.3]  # 0.34 m → 걸음 0.1 맞춤 · 한 번
+    assert drag["clickSwallowed"] is True
+    assert out["idleDrag"]["stopped"] is False  # 안 고르면 끌기 아님
+
+
+def test_풀면_암_칸_사면_고르면_그_선_칸(out: dict) -> None:
+    assert out["released"]["title"] == "암 경계선" and out["released"]["upPassed"]
+    slope = out["slope"]
+    assert slope["title"] == "사면 이동 (좌)" and slope["slots"] == ["left", "reset", "right"]
+    assert slope["value"].startswith("길이 ") and "\n" not in slope["value"]
+    assert slope["arrowSlots"] == slope["slots"]  # 숨은 버튼은 방향키 슬롯 없음
+
+
+def test_토사는_빈_칸_판정_선_없음(out: dict) -> None:
+    soil = out["soil"]
+    assert soil["empty"] is True and soil["slots"] == [] and soil["rockHit"] is False
+
+
+def test_배선_떠_있는_선_조정창_걷음() -> None:
+    pick = (B06 / "B06_Section_UI_Cross_Design_Pick.ts").read_text(encoding="utf-8")
+    assert "buildPanelShell" not in pick and "b06-cross-card__line-dims" not in pick
+    view = (B06 / "B06_Section_UI_Cross_View.ts").read_text(encoding="utf-8")
+    assert "rockBoundary && rockCellSpec(section, rockBoundary)" in view
+    chrome = (B06 / "B06_Section_UI_Cross_Card_Chrome.ts").read_text(encoding="utf-8")
+    assert "if (lineCell) {" in chrome
+    detail = (B06 / "B06_Section_UI_Cross_Detail_Pick.ts").read_text(encoding="utf-8")
+    assert ".b06-chart__design-hit:not(.b06-chart__rock-hit)" in detail  # 상세 표 강조에 안 섞임
+    css = (B06 / "B06_Section_UI_Style_Cross.css").read_text(encoding="utf-8")
+    assert ".b06-cross-card__linecell.is-empty {" in css and "text-overflow: ellipsis;" in css
diff --git a/resources/tester/test_371_2_pipe_slope_text.py b/resources/tester/test_371_2_pipe_slope_text.py
new file mode 100644
index 000000000..5ce087c98
--- /dev/null
+++ b/resources/tester/test_371_2_pipe_slope_text.py
@@ -0,0 +1,49 @@
+"""PLAN 371-2 — B06 횡단 카드 관 글 L 뒤 기울기(요구 240-16).
+
+규칙: 「관매설 {관종}Φ…m/m, L=8 m (7.6), S=2.5%」(소수 한 자리 · 역경사 0.0) ·
+툴팁 「매설 경사」 지움 · 세월교 · 박스 흙막이 세트(hidden_pipe = 관 숨김)는 관 글 없음 ·
+B07 덧그림(노폭 라벨 없음)도 없음(225-1).
+짝 = `helper_371_2_pipe_slope.cjs`.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+HELPER = Path(__file__).parent / "helper_371_2_pipe_slope.cjs"
+
+pytestmark = pytest.mark.skipif(
+    not (ROOT / "config" / "node_modules").is_dir(), reason="프론트엔드 의존성 미설치"
+)
+
+
+@pytest.fixture(scope="module")
+def out() -> dict:
+    done = subprocess.run(  # noqa: S603 — 고정 실행 파일
+        ["node", str(HELPER)], cwd=str(ROOT), capture_output=True, text=True, encoding="utf-8"
+    )
+    assert done.returncode == 0, done.stderr
+    return json.loads(done.stdout)
+
+
+def test_관_글_L_뒤에_기울기_소수_한_자리(out: dict) -> None:
+    slope = f"{out['slopePct']:.1f}"
+    assert out["pipe"]["infos"] == [f"관매설 파형강관 Φ1000m/m, L=8 m (7.5), S={slope}%"]
+
+
+def test_역경사는_0_0(out: dict) -> None:
+    assert out["reverse"]["infos"][0].endswith(", S=0.0%")
+
+
+def test_툴팁에_매설_경사_없음(out: dict) -> None:
+    tips = out["pipe"]["pipeTips"]
+    assert tips and all("매설 경사" not in tip for tip in tips)
+
+
+def test_관_숨김_세트는_관_글_없음(out: dict) -> None:
+    assert out["hidden"] == {"infos": [], "pipeTips": []}
diff --git a/resources/tester/test_373_b08_milestone_place_path.py b/resources/tester/test_373_b08_milestone_place_path.py
new file mode 100644
index 000000000..dae94ac6d
--- /dev/null
+++ b/resources/tester/test_373_b08_milestone_place_path.py
@@ -0,0 +1,78 @@
+"""373 B08 거리이정표 — 연결 없이 소재지 넣기 · 구간 길 선 저장 · 다시 이음 · 시점 미연결 · 녹색 점.
+
+화면 코드는 소스 확인 + node 로 실제 TS(`findSegmentKm` · `reachesSite`)를 돌림. 서버 쪽 `path` 칸은
+`test_244_9_b08_milestone_route_map.py`.
+"""
+
+from resources.tester.test_244_13_b08_milestone_place_leg import (
+    CALC,
+    LAYOUT,
+    STATE,
+    STATE_STUBS,
+    _node,
+    _read,
+)
+
+B08 = "B08_Quantity/B08_Quantity_"
+ROW = [{"item": "철근", "dest": "start", "note": ""}]
+DATA = {
+    "site": {"mid_station_m": None, "mid_road": "비포장"},
+    "bases": [
+        {"id": "b1", "name": "병곡리", "address": "", "dir": None, "lon": 127.85, "lat": 35.66,
+         "legs": [{"road": None, "km": None}], "to": "site", "linked": False},
+    ],
+    "routes": [
+        {"id": "g", "name": "g", "address": "", "to": "b1", "dir": None, "lon": 127.9,
+         "lat": 35.68, "linked": True, "legs": [{"road": "2차포장", "km": 23.8}], "rows": ROW},
+    ],
+}  # fmt: skip
+FAIL_STUBS = STATE_STUBS.replace(
+    'if (url.includes("/directions")) return {',
+    'if (url.includes("/directions") && (globalThis as any).FAIL)'
+    ' return { km: null, reason: "카카오 실패", path: [] };\n'
+    '  if (url.includes("/directions")) return {',
+)
+
+
+def test_373_안_이은_기준점에_이으면_시점_미연결_실패면_옛_거리_선_지움():
+    script = f"""const DATA = {__import__("json").dumps(DATA)};
+await loadMilestone("p1");
+const a = await findSegmentKm("p1", "g", false);
+const first = liveMilestone("p1");
+const open = reachesSite(first, "g");
+first.bases[0].linked = true;
+const closed = reachesSite(first, "g");
+(globalThis as any).FAIL = true;
+const b = await findSegmentKm("p1", "g", false);
+const after = liveMilestone("p1").routes[0].legs;
+console.log(JSON.stringify({{ a, b, open, closed, first: first.routes[0].legs, after,
+  line: segmentPath("p1", "g") }}));"""
+    got = _node([CALC, LAYOUT, STATE], script, FAIL_STUBS)
+    assert got["a"] == "g → 병곡리 10.5 km — 시점 미연결" and got["open"] is False
+    assert got["closed"] is True
+    assert got["first"][0]["path"] == [[35.68, 127.9], [35.66, 127.85]]  # 구간 자료에 길 선
+    assert got["b"] == "g → 병곡리 — 카카오 실패"
+    assert got["after"] == [{"road": "2차포장", "km": 23.8, "auto_km": None}]  # 사용자 km 만 남음
+    assert got["line"] == []
+
+
+def test_373_화면_소재지_지도_누름_저장된_선_녹색_점():
+    route = _read(B08 + "UI_Milestone_Route.ts")
+    assert (
+        'label: "소재지"' in route
+        and "openPlaceModal(projectId, { add: false, id: routeId })" in route
+    )
+    assert "onClick: (lon, lat) => void moveTo(routeId, lon, lat)," in route  # 연결 없어도 누름
+    assert "center: () => startPoint(liveMilestone(projectId))," in route  # 점 없으면 시점 쪽
+    assert "reachesSite(d, routeId)" in route and "시점 미연결" in route
+    leg = _read(B08 + "UI_Milestone_LegModal.ts")
+    assert "path: leg.path," in leg and "...(path ? { path } : {})" in leg  # 모달이 선 안 지움
+    assert "{ ...l, auto_km: null, path: null }" in leg  # 수기 = 선 지움
+    diagram = _read(B08 + "UI_Milestone_Diagram.ts")
+    assert "route.legs = [{ road: null, km: null }];" in diagram  # 다시 이음 = 옛 거리 · 선 지움
+    state = _read(B08 + "UI_Milestone_State.ts")
+    assert "paths" not in state.replace("path:", "").replace("segmentPath", "")  # 메모리 표 없음
+    assert "path?: Array<[number, number]> | null;" in _read(CALC)
+    css = _read(B08 + "UI_Milestone.css")
+    dot = css[css.index(".b08-milestone__connect {") :]
+    assert "opacity: 0.85;" in dot[: dot.index("}")]
diff --git a/resources/tester/test_b05_routeedit_cross_width.py b/resources/tester/test_b05_routeedit_cross_width.py
index 2242aaf25..4f7420a55 100644
--- a/resources/tester/test_b05_routeedit_cross_width.py
+++ b/resources/tester/test_b05_routeedit_cross_width.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 """계획노선 편집 창 — **측점 반폭 선 길이**(계획서 22-1) 회귀검증.
 
-파란 선 = 우측 패널 「횡단 반폭(m)」 적용값 양쪽. 적용한 적이 없으면 서버 기본값.
-선 길이는 서버가 덮은 반폭(= 횡단 미리보기 원지반 선 범위)을 그대로 쓴다.
+파란 선 = 우측 패널 「횡단 반폭(m)」 적용값 양쪽. 적용한 적이 없으면 원지반 선 범위
+(계산 묶음 그 측점 표본 · 365-3).
 Node 헬퍼(`helper_b05_routeedit_cross_width.cjs`)가 TS 를 트랜스파일해 돌린다.
 """
 
@@ -31,21 +31,17 @@ def test_측점을_고르기_전에는_선이_없다(results):
     assert results["before"] is None
 
 
-def test_적용한_적_없으면_서버_기본값_양쪽(results):
-    assert results["empty"]["asked"] is None
+def test_적용한_적_없으면_원지반_범위_양쪽(results):
     assert results["empty"]["watched"] == {"chainageM": 100, "leftM": 20, "rightM": 20}
 
 
 def test_적용값이_있으면_그_값_양쪽(results):
-    assert results["applied15"]["asked"] == 15
     assert results["applied15"]["watched"] == {"chainageM": 100, "leftM": 15, "rightM": 15}
 
 
 def test_노선이_여럿이면_최신_노선_값_다른_프로젝트는_무시(results):
-    assert results["latestRoute"]["asked"] == 8.5
     assert results["latestRoute"]["watched"]["leftM"] == 8.5
 
 
 def test_망가진_값은_기본값으로(results):
-    assert results["badValue"]["asked"] is None
     assert results["badValue"]["watched"]["rightM"] == 20
diff --git a/resources/tester/test_b05_routeedit_initial.py b/resources/tester/test_b05_routeedit_initial.py
index 7cce14368..43647248b 100644
--- a/resources/tester/test_b05_routeedit_initial.py
+++ b/resources/tester/test_b05_routeedit_initial.py
@@ -208,11 +208,34 @@ def test_노선_추천_다듬기_23_3():
         return open(os.path.join(page, name), encoding="utf-8").read()
 
     chrome = read("B05_Profile_UI_RouteEdit_Chrome.ts")
-    # 345-4 — [노선 추천]은 좌측 칸 · 머리 구분선은 [3D](tools) 뒤 · 되돌리기 앞 둘 그대로
-    tools = chrome.index('data-slot="tools"')
-    divider = chrome.index("b05-route__view-separator", tools)  # 352-1 — 3D 도구줄 구분선 그대로
-    assert tools < divider < chrome.index('data-act="contour-minor"')
-    assert chrome.count("b05-route__view-separator") == 2
+    # 366-2 — [?] | ↶ ↷ | 3D | ⟲ ⟳ · 1m 등고선 · 절/성토선 · 거리 재기 | 측점 스냅 · 분석 지형(맨 오른쪽)
+    bar = chrome[
+        chrome.index("b05-routeedit__tools") : chrome.index('<div class="b05-routeedit__hint">')
+    ]
+    order = [
+        'data-act="hint-toggle"',
+        "|",
+        'data-act="undo"',
+        'data-act="redo"',
+        "|",
+        'data-slot="tools"',
+        "|",
+        'data-act="rotate-ccw"',
+        'data-act="rotate-cw"',
+        'data-act="contour-minor"',
+        'data-act="footprint"',
+        'data-act="measure"',
+        "|",
+        'data-act="station-snap"',
+        'class="b05-routeedit__terrain"',
+    ]
+    at = 0
+    for mark in order:
+        key = "b05-route__view-separator" if mark == "|" else mark
+        at = bar.index(key, at) + 1
+    assert bar.count("b05-route__view-separator") == 4
+    assert chrome.count("b05-route__view-separator") == 4
+    assert "b05-routeedit__spin" not in chrome  # 회전 = 도구줄(추천 모달 CSS 는 남음)
     shared = read("B05_Profile_UI_RouteEdit_Recommend_Map.ts")
     for name in ("bindRouteEditNavigation", "createMapRotation", "fitCanvas", "metricToScreen"):
         assert f"{name}(" in shared
diff --git a/resources/tester/test_b06_cross_design_mirror.py b/resources/tester/test_b06_cross_design_mirror.py
index c3789c971..f0554ff98 100644
--- a/resources/tester/test_b06_cross_design_mirror.py
+++ b/resources/tester/test_b06_cross_design_mirror.py
@@ -61,6 +61,22 @@ def _dip_ground() -> list[dict]:
     return samples
 
 
+def _ridge_ground() -> list[dict]:
+    """우측 −4 m 까지 노면보다 높은 평지(절토) · 그 너머 급히 내려가는 마루(370-1)."""
+    return [
+        {"offset_m": o, "elevation_m": round(100.3 - 0.6 * max(0.0, -o - 4.0), 4), "valid": True}
+        for o in (-12.0 + i * 0.5 for i in range(49))
+    ]
+
+
+def _rise_ground() -> list[dict]:
+    """좌측 +3 m 까지 노면보다 낮은 평지(성토) · 그 너머 오르막(370-1)."""
+    return [
+        {"offset_m": o, "elevation_m": round(99.6 + 0.4 * max(0.0, o - 3.0), 4), "valid": True}
+        for o in (-12.0 + i * 0.5 for i in range(49))
+    ]
+
+
 # 갈래를 골고루 태운다 — 지반유형 셋 · 단면유형 · 측구 형식 · 포장 · 2단 경사 · 세월교
 # 노면 하강 · 곡선부 확폭(바깥쪽 좌/우) · 지반선 결측 구간.
 CASES = [
@@ -214,8 +230,8 @@ CASES = [
         },
     },
     {
-        # 노견 끝 근처에서 지반이 설계면을 넘는 자리 — 단면유형 · 측구 판정은 옮기기 전 노견에서
-        "name": "노견 확장 — 판정은 옮기기 전 노견",
+        # 노견 끝 근처에서 지반이 설계면을 넘는 자리 — 단면유형 · 측구 판정은 옮긴 노견에서(370-1)
+        "name": "노견 확장 — 판정은 옮긴 노견",
         "samples": _ground(-0.05),
         "design_elevation_m": 100.0,
         "options": {
@@ -226,6 +242,30 @@ CASES = [
             "shoulder_extend_left_m": 2.5,
         },
     },
+    {
+        # 370-1 — 우 절토 마루를 넘겨 옮김 = 그 쪽 성토 1:n 으로 원지반까지(원지반 직선 아님)
+        "name": "마루 너머 = 성토 1:n",
+        "samples": _ridge_ground(),
+        "design_elevation_m": 100.0,
+        "options": {
+            "ground_type": "soil",
+            "section_mode": "right_cut",
+            "ditch_side": "right",
+            "shoulder_extend_right_m": 3.0,
+        },
+    },
+    {
+        # 370-1 — 좌 성토를 오르막으로 옮김 = 그 쪽 절토(측구 자동 판정 따름)
+        "name": "성 → 절 넘어감",
+        "samples": _rise_ground(),
+        "design_elevation_m": 100.0,
+        "options": {
+            "ground_type": "soil",
+            "section_mode": "left_cut",
+            "ditch_side": "left",
+            "shoulder_extend_left_m": 2.5,
+        },
+    },
     {
         # 151-2 — 곡선부 확폭과 사면 이동이 같은 쪽에 겹침(확폭 출력엔 이동 몫 안 섞임)
         "name": "확폭 좌 + 사면 이동 좌 0.4",
@@ -490,3 +530,33 @@ def test_사면_이동은_노견째_평행이동_늘어난_폭은_차도() -> No
     both = by_name["확폭 좌 + 사면 이동 좌 0.4"]
     assert both["widening_left_m"] == curve["widening_left_m"] > 0
     assert abs(both["carriageway_width_m"] - (curve["carriageway_width_m"] + 0.4)) < 1e-9
+
+
+def _outer_slope(result: dict, side: str, skip: float = 0.0) -> float:
+    """노면 끝에서 `skip`(측구 폭) 바깥 설계선 한 마디의 기울기(dz / 바깥 거리)."""
+    sign = 1.0 if side == "left" else -1.0
+    start_offset = result["road_edges"][side]["offset_m"] + sign * skip
+    line = sorted(result["design_line"], key=lambda p: sign * p["offset_m"])
+    index = next(i for i, p in enumerate(line) if abs(p["offset_m"] - start_offset) < 1e-6)
+    start, nxt = line[index], line[index + 1]
+    return (nxt["elevation_m"] - start["elevation_m"]) / abs(nxt["offset_m"] - start["offset_m"])
+
+
+def test_절성_넘어가면_그_쪽_사면_기울기로_원지반까지() -> None:
+    """370-1 — 옮긴 노견에서 절/성 판정 · 마루 너머 = 성토 1:n · 성 → 절 = 절토 1:n + 측구 자동."""
+    by_name = dict(zip((case["name"] for case in CASES), _python_results(), strict=True))
+    soil = STANDARD_CROSS_SECTION["soil"]
+    ridge = by_name["마루 너머 = 성토 1:n"]
+    assert ridge["section_mode"] == "left_cut"  # 우 = 성토
+    assert ridge["ditch_enabled"] is False  # 우 측구 자동 판정 따라 빠짐
+    assert ridge["fill_area_m2"] > 0
+    assert abs(_outer_slope(ridge, "right") + 1.0 / soil["fill_slope_ratio"]) < 1e-3
+    rise = by_name["성 → 절 넘어감"]
+    assert rise["section_mode"] == "left_cut"  # 좌 = 절토
+    assert rise["ditch_enabled"] is True and rise["ditch_side"] == "left"
+    assert (
+        abs(
+            _outer_slope(rise, "left", soil["ditch"]["top_width_m"]) - 1.0 / soil["cut_slope_ratio"]
+        )
+        < 1e-3
+    )
diff --git a/resources/tester/test_b06_wall_shape_unified.py b/resources/tester/test_b06_wall_shape_unified.py
index c64546122..1f56901bd 100644
--- a/resources/tester/test_b06_wall_shape_unified.py
+++ b/resources/tester/test_b06_wall_shape_unified.py
@@ -36,6 +36,9 @@ writeFileSync(process.argv[2], JSON.stringify({
   under: buildRevetWallGeometry({
     anchor, outward: 1, height: 2, material: "dry", role: "outlet", roadElevation: 103,
   }).topJoint.elevation,
+  fill: (({ fillTop, topJoint, points }) => [fillTop.offset, fillTop.elevation, topJoint.offset, points[2].offset, points[2].elevation])(
+    buildRevetWallGeometry({ anchor, outward: 1, height: 2.5, material: "dry", role: "outlet" }),
+  ),
   dry: revetWallSpec({ revet_form: "돌쌓기(메)" }, { h: 3.0 }, true, 0.3).pureHeight,
   concrete: revetWallSpec({ revet_form: "콘크리트" }, { h: 7.5 }, true, 0.3).pureHeight,
 }));
@@ -84,6 +87,11 @@ def test_벽_외곽_한_벌_높이_입력_그대로_노면_멈춤(tmp_path: Path
     assert got["under"] == pytest.approx(102.0), "노면 아래 벽이 잘림"
     assert got["dry"] == pytest.approx(3.0), "돌쌓기(메) 3.0 이 잘림"
     assert got["concrete"] == pytest.approx(7.5), "콘크리트 7.5 가 잘림"
+    # 371-1 — 성토 위 이음 = 윗면 사면 쪽 끝에서 0.1 m 안 · 무늬 이음선(topJoint)은 그대로
+    fill_offset, fill_elevation, joint_offset, front_offset, front_elevation = got["fill"]
+    assert fill_offset == pytest.approx(front_offset - 0.1), "성토 위 이음이 끝에서 0.1 m 아님"
+    assert fill_elevation == pytest.approx(front_elevation), "성토 위 이음이 윗면 표고 아님"
+    assert joint_offset == pytest.approx(front_offset - 0.45), "무늬 이음선이 옮겨짐"
 
 
 def test_네_벽이_공용_함수로_서고_형태_한도가_없다() -> None:
diff --git a/resources/tester/test_design_view_parity.py b/resources/tester/test_design_view_parity.py
index 7618fb22d..b2bcb5af3 100644
--- a/resources/tester/test_design_view_parity.py
+++ b/resources/tester/test_design_view_parity.py
@@ -95,7 +95,7 @@ def test_아래_단추는_네_개_보기_전환_글자만_따라감(results):
         # [확정]은 종단 보기에서도 켜진다(한 벌 저장이 횡단 자료를 같은 페이지에서 얻음).
         assert views[name]["dockDisabled"] == [False, False, False, False]
     assert views["profile"]["dockLabels"][3] == "횡단 보기"
-    assert views["cross"]["dockLabels"][3] == "종단 보기"
+    assert views["cross"]["dockLabels"][3] == "노선 보기"
     assert views["back"]["dockLabels"][3] == "횡단 보기"
 
 
diff --git a/resources/tester/test_m02_hopyo_screen.py b/resources/tester/test_m02_hopyo_screen.py
index d36d273b2..33ac9f123 100644
--- a/resources/tester/test_m02_hopyo_screen.py
+++ b/resources/tester/test_m02_hopyo_screen.py
@@ -287,7 +287,7 @@ def test_엑셀_보기_창_행과_호표():
     assert sheet["at"] == [None, 3, 3, 3, 4, 4, None]  # 22행 → 제3호표 · 범위 밖 = 없음
     assert sheet["span"] == "B20:O24"  # 제3호표 영역 = B열 ~ 끝 열(열 폭 정보 O)
     assert sheet["last"] == ["AA", "A"]
-    assert sheet["rows"] == ["4345:4345", "93:101"]  # 단가산출 행 전체
+    assert sheet["rows"] == ["B4345:F4345", "B93:F101"]  # 단가산출 행 B~F 열
 
 
 # ── 소스 ──────────────────────────────────────────────────────────────
@@ -348,7 +348,10 @@ def test_좌측_판_자리와_권한():
     assert "size:" not in up and "엑셀 올리기" not in hopyo_side
     assert "buildHopyoView" not in hopyo_side
     assert 'row.addEventListener("click", () => void showSheet(f));' in hopyo_side
-    assert "onClose:" in hopyo_side and "onDeleted: () => void refresh()," in hopyo_side
+    assert (
+        "onClose:" in hopyo_side
+        and "onDeleted: opt.canWrite ? () => void refresh() : undefined," in hopyo_side
+    )
     assert 'accept: ".xls,.xlsx"' in hopyo_side and "input.hidden = true;" in hopyo_side
     assert "disabled: !opt.canWrite," in hopyo_side and "pageScope()" in hopyo_side
     assert "buildHopyoLedger({ scope, canWrite: opt.canWrite })" in hopyo_side  # [별칭 장부]
@@ -524,3 +527,11 @@ def test_명사형_단추와_별칭_장부_풀이_359():
         'label: "지우기"',
     ):
         assert gone not in every, gone
+
+
+def test_372_2_저장은_개인_층에_삭제는_화면_층_권한():
+    side = _text("M02_MasterTemplete_Hopyo_Side.ts")
+    open_ = side.split("sheet.openHopyoSheet({")[1].split("});")[0]
+    assert 'target: { layer: "personal", owner: null },' in open_
+    assert "canWrite: true," in open_  # 만들기 = 개인 층 · 화면 층 무관
+    assert "onDeleted: opt.canWrite ? () => void refresh() : undefined," in open_
diff --git a/resources/tester/test_m02_hopyo_seam.py b/resources/tester/test_m02_hopyo_seam.py
index ad7c77fac..01e8b0895 100644
--- a/resources/tester/test_m02_hopyo_seam.py
+++ b/resources/tester/test_m02_hopyo_seam.py
@@ -53,7 +53,7 @@ def test_실제_응답_화면_도우미(client):
     assert states == {"맞음": 122, "다른 점": 86, "후보": 60}  # 268 줄 · 셈 끝
     assert got["count"]["top"] == 9  # 「후보」 줄 1순위 근거 맞음(근거 맞는 줄은 거의 숫자로 풀림)
     assert got["at"] == [None, 3, 3, 3, None, 4]  # 25행 = 호표 사이 빈 줄
-    assert got["span"] == "B20:O24" and got["rows"] == "4229:4244"
+    assert got["span"] == "B20:O24" and got["rows"] == "B4229:F4244"
     by = {x["이름"]: x for x in got["lines"]}
     dig = by["구조물터파기(인력100%)"]
     assert dig["source"] == "출처 건설품셈 3-2-1 · 직종 특별인부 · 단가산출 4229–4244행"
diff --git a/resources/tester/test_m02_labor_national.py b/resources/tester/test_m02_labor_national.py
index 80f18a17c..3bf5cc93a 100644
--- a/resources/tester/test_m02_labor_national.py
+++ b/resources/tester/test_m02_labor_national.py
@@ -120,3 +120,15 @@ def test_확인_창_세_칸_만들기_값(client):
     assert seoul["대상"][0]["세칸"]["자재구분"] == "사급"  # 고른 자재 이름(-사급) 먼저
     rows = (M02 / "M02_MasterTemplete_Hopyo_CheckRows.ts").read_text(encoding="utf-8")
     assert "...markCells(p?.세칸 ??" in rows
+
+
+def test_복사_때_실무자료_본뜬과_전국자재_지킴():
+    from M02_MasterTemplete import M02_Labor_Ref as refs
+
+    ref = {"층": "personal", "주인": "7/42", "키": "SC-000001"}
+    mine = {"층": "실무자료", "키": "HP-000001 제1호표", "전국자재": [REMICON]}
+    kept = refs.origin_mark({"본뜬": mine}, ref)["본뜬"]
+    assert kept["키"] == "HP-000001 제1호표" and kept["전국자재"] == [REMICON]  # 덮지 않음
+    assert kept["복사원본"] == ref  # 원본 참조는 다른 칸
+    assert refs.origin_mark({"본뜬": None}, ref)["본뜬"] == ref  # 보통 문서 = 옛 그대로
+    assert refs.origin_mark({"본뜬": {"층": "system", "키": "A"}}, ref)["본뜬"] == ref
diff --git a/ui_template/ui_template_locale_b2.ts b/ui_template/ui_template_locale_b2.ts
index 3470286fa..9240f1b4a 100644
--- a/ui_template/ui_template_locale_b2.ts
+++ b/ui_template/ui_template_locale_b2.ts
@@ -34,8 +34,8 @@ export const ui_locales_b2 = {
   // (2026-08-19 사용자 지시 4).
   B05_Drainage_Btn_Analyze: ["유역 재분할", "Recompute sub-basins"],
   B05_Drainage_Btn_Analyze_Tip: [
-    "B04에서 분석해 둔 배수유역을 불러와, 지금 배치된 배관을 기준으로 세부유역(관이 담당하는 구역)을 다시 나눕니다. 관이 부족한 구간은 자동으로 보충합니다. B04 분석 결과가 없으면 B04에서 먼저 실행해야 합니다.",
-    "Reloads the B04 drainage analysis and re-splits sub-basins around the current culverts, adding culverts where spacing requires. Run the analysis in B04 first if none exists.",
+    "B04에서 분석해 둔 배수유역을 불러와, 지금 배치된 배관을 기준으로 세부유역(관이 담당하는 구역)을 다시 나눕니다. 관을 더하지 않습니다 — 간격 보충은 [자동 제안]. B04 분석 결과가 없으면 B04에서 먼저 실행해야 합니다.",
+    "Reloads the B04 drainage analysis and re-splits sub-basins around the current culverts without adding any — use [Auto suggest] to fill spacing gaps. Run the analysis in B04 first if none exists.",
   ],
   B05_Drainage_Btn_DeleteSelected: ["관 삭제", "Delete selected culvert"],
   B05_Drainage_Btn_DeleteSelected_Tip: [
@@ -44,8 +44,8 @@ export const ui_locales_b2 = {
   ],
   B05_Drainage_Btn_Auto: ["배관 배치 초기화", "Reset culvert layout"],
   B05_Drainage_Btn_Auto_Tip: [
-    "손으로 넣거나 옮기거나 지운 배관을 모두 버리고, 계곡부·간격 기준으로 프로그램이 자동 배치한 상태로 되돌립니다. 유역 구획도 함께 다시 나뉩니다.",
-    "Discards every manual culvert edit and restores the automatic placement (valley crossings + spacing rule); sub-basins are re-split as well.",
+    "손으로 넣거나 옮기거나 지운 배관을 모두 버리고, 세류선(계곡)이 노선과 만나는 자리에만 배관을 둡니다. 유역 구획도 함께 다시 나뉩니다. 초안이라 [저장] 때 남습니다.",
+    "Discards every manual culvert edit and keeps culverts only where streams cross the route; sub-basins are re-split as well. This is a draft — it is kept on [Save].",
   ],
   B05_Drainage_Menu_Add: ["배수관 추가", "Add culvert"],
   B05_Drainage_Menu_Delete: ["배수관 삭제", "Remove culvert"],
@@ -108,7 +108,7 @@ export const ui_locales_b2 = {
   ],
 
   /* --- B05_Profile 경로 설계 --- */
-  B05_Route_Title: ["종단설계", "Profile Design"],
+  B05_Route_Title: ["노선설계", "Route Design"],
   B05_Route_Group_Points: ["경로 제어점", "Route Control Points"],
   B05_Route_Point_BP: ["시점 (BP)", "Begin (BP)"],
   B05_Route_Point_EP: ["종점 (EP)", "End (EP)"],
@@ -146,7 +146,7 @@ export const ui_locales_b2 = {
   B05_Route_Btn_GoCross: ["횡단 이동", "Go to Cross"],
   /* 좌측 패널 아래 단추 [보기 전환] — 가려는 쪽 이름(계획서 24-2b). */
   Design_Btn_ToCross: ["횡단 보기", "Cross view"],
-  Design_Btn_ToProfile: ["종단 보기", "Profile view"],
+  Design_Btn_ToProfile: ["노선 보기", "Route view"],
   B05_Route_TempSave_Success: ["변경 내용을 저장했습니다.", "Changes saved."],
   B05_Route_TempSave_Failed: ["저장에 실패했습니다.", "Failed to save."],
   B05_Route_Reset_Confirm: [
@@ -800,7 +800,7 @@ export const ui_locales_b2 = {
     "Failed to load the material summary.",
   ],
   B08_Quantity_Haul_Missing: [
-    "운반계획이 아직 없습니다. 종단설계에서 [확정]을 누르면 만들어집니다.",
+    "운반계획이 아직 없습니다. 노선설계에서 [확정]을 누르면 만들어집니다.",
     "No haul plan yet. Press [Confirm] on the profile design to build it.",
   ],
   B08_Quantity_Haul_Excluded: ["내역 제외", "Not billed"],
@@ -1047,4 +1047,28 @@ export const ui_locales_b2 = {
   ],
   B06_Std_Note_Rock: ["암", "Rock"],
   B06_Std_Note_Paved: ["포장", "Paved"],
+  B05_Drainage_Btn_Propose: ["자동 제안", "Auto suggest"],
+  B05_Drainage_Btn_Propose_Tip: [
+    "관 자리를 프로그램이 정합니다(세류선 교차 + 최대 간격 보충) — 두 방식 중 고름. 초안이라 [저장] 때 남습니다.",
+    "Let the program place culverts (stream crossings + max spacing rule) — choose one of two ways. This is a draft — it is kept on [Save].",
+  ],
+  B05_Drainage_Btn_Propose_Stale: [
+    "노선 · 관 자리가 바뀌어 배수유역이 낡음 — [업데이트] 뒤 자동 제안",
+    "Drainage basins are out of date — run [Update] first",
+  ],
+  B05_Drainage_Propose_Title: ["관 자리 자동 제안", "Auto-suggest culvert positions"],
+  B05_Drainage_Propose_All: ["전체 자동", "Fully automatic"],
+  B05_Drainage_Propose_All_Hint: [
+    "세류선 교차 + 최대 간격 규칙으로 관 자리를 새로 정함(같은 자리 관은 시설 · 관경 유지)",
+    "Re-place every culvert by stream crossings + max spacing (culverts at the same spot keep their facility and size)",
+  ],
+  B05_Drainage_Propose_Add: ["지정 포함 추가", "Add to my culverts"],
+  B05_Drainage_Propose_Add_Hint: [
+    "지금 관은 그대로 두고 간격이 먼 구간에만 관을 더함",
+    "Keep the current culverts and add culverts only where the spacing is too long",
+  ],
+  Design_Pipeline_Unstable: [
+    "계산 불안정 — 입력과 결과가 세 바퀴 안에 안 맞음",
+    "Calculation unstable — inputs and results did not settle in three rounds",
+  ],
 } as const satisfies Record<string, LocaleEntry>;
diff --git a/ui_template/ui_template_locale_common.ts b/ui_template/ui_template_locale_common.ts
index ddad8eb97..b7eb7c462 100644
--- a/ui_template/ui_template_locale_common.ts
+++ b/ui_template/ui_template_locale_common.ts
@@ -80,7 +80,7 @@ export const ui_locales_common = {
    * 워크플로우 공통 (B04~B09 상단 진행 단계 라벨)
    * ------------------------------------------------------------------------ */
   WF_Step_Surface: ["전처리", "Preprocess"],
-  WF_Step_Route: ["종단설계", "Profile Design"],
+  WF_Step_Route: ["노선설계", "Route Design"],
   WF_Step_ProfileCross: ["횡단설계", "Cross Design"],
   WF_Step_DesignDetail: ["상세설계", "Detail Design"],
   WF_Step_Quantity: ["수량산출", "Quantity"],
diff --git a/ui_template/ui_template_loupe.css b/ui_template/ui_template_loupe.css
index 5961245a9..c3471fca1 100644
--- a/ui_template/ui_template_loupe.css
+++ b/ui_template/ui_template_loupe.css
@@ -24,13 +24,20 @@
   display: none;
 }
 
-/* 복제를 놓는 판 — 화면(뷰포트) 크기 · fixed 자식의 기준 상자 */
+/* 복제를 놓는 판 — 화면(뷰포트) 크기 · 움직임은 translate 만(합성층 · 374-1) */
 .ui-loupe__stage {
   position: absolute;
   left: 0;
   top: 0;
   width: 100vw;
   height: 100dvh;
+  will-change: transform;
+}
+
+/* 배율 상자 — 배율 바꿀 때만 scale · fixed 자식의 기준 상자 */
+.ui-loupe__scale {
+  position: absolute;
+  inset: 0;
   transform-origin: 0 0;
 }
 
@@ -55,6 +62,8 @@
   border-radius: 9px;
   background: var(--color-bg);
   color: var(--color-accent);
+  /* html 바로 아래라 body 글꼴을 안 물려받음 */
+  font-family: var(--font-body);
   font-size: 11px;
   line-height: 18px;
   box-shadow: 0 0 0 1px var(--color-accent);
diff --git a/ui_template/ui_template_loupe.ts b/ui_template/ui_template_loupe.ts
index 68a0cfee4..a7768fb54 100644
--- a/ui_template/ui_template_loupe.ts
+++ b/ui_template/ui_template_loupe.ts
@@ -5,9 +5,10 @@
  * 켜는 법 둘 — 오른쪽 단추를 0.4 초 넘게 누르고 있는 동안 · Z 키를 누르고 있는 동안 · 떼면 꺼짐.
  * 켜 있는 동안 휠 = 배율(220-1 · 1.5 ~ 6배 · 한 칸 0.25 · 켤 때마다 2배) · 화면 스크롤 · 그래프 휠 줌은 막음.
  * 길게 누른 우클릭은 뗀 뒤 메뉴(우리 메뉴 · 브라우저 메뉴)를 안 띄움 · 짧게 누르면 지금 우클릭 그대로.
- * 그리기 — 켤 때 `#app` 을 한 번 떠서(DOM 복제 + 2D canvas 그림 복사 · SVG 그대로) 원 안에 놓고, 움직일 때 transform 만 바꿈.
- * 화면 밖 상자는 속을 비우고 크기만 남김 · 켜 있는 동안 화면이 바뀌면 0.5 초 뒤 다시 뜸 · 끄면 복제를 지움.
- * 스크롤(221-2) — 뜰 때 스크롤 칸마다 scrollTop · Left 를 복제에 옮김 · 켜진 동안 어느 칸이든 스크롤하면 그 화면 틀(rAF 한 번)에 위치를 맞추고 0.5 초 뒤 다시 뜸(비워 둔 화면 밖 칸을 채움).
+ * 그리기 — 켤 때 지금 보이는 화면 전체(`body` · 모달 포함 · 374-1)를 한 번 떠서(DOM 복제 + 2D canvas 그림 복사 · SVG 그대로) 원 안에 놓고,
+ * 움직일 때 바깥 판(합성층) translate 만 바꿈 · 배율은 안쪽 상자 scale. 원 · 배율 글은 `html` 바로 아래(복제 · 관찰에 안 걸림).
+ * 화면 밖 상자는 속을 비우고 크기만 남김 · 켜 있는 동안 화면이 바뀌면 멈춘 뒤 0.5 초에 한 번 다시 뜸(움직이는 동안 안 뜸) · 끄면 복제를 지움.
+ * 스크롤(221-2) — 뜰 때 스크롤 칸마다 scrollTop · Left 를 복제에 옮김 · 켜진 동안 어느 칸이든 스크롤하면 그 화면 틀(rAF 한 번)에 위치를 맞추고 멈춘 뒤 0.5 초에 다시 뜸(비워 둔 화면 밖 칸을 채움).
  * WebGL canvas 는 그림이 남아 있을 때만 옮겨짐.
  * CAD 영역(cad_host 상자 · iframe · 221-1) — 커서가 그 위면 켜지 않고 · 켜진 채 들어가면 숨김(나오면 다시) · 휠도 CAD 로 · 복제는 빈칸.
  * ========================================================================== */
@@ -28,7 +29,7 @@ export const LOUPE_ZOOM_STEP = 0.25;
 const LOUPE_LABEL_H = 18;
 /** 오른쪽 단추를 이만큼(ms) 넘게 누르면 켬 */
 export const LOUPE_HOLD_MS = 400;
-/** 켜 있는 동안 화면이 바뀌면 이만큼(ms) 뒤 다시 뜸 */
+/** 켜 있는 동안 화면이 바뀌면 멈춘 뒤 이만큼(ms) 지나 다시 뜸 */
 export const LOUPE_REFRESH_MS = 500;
 /** 화면 끝과 원 사이 여백(px) — 테두리가 안 잘리게 */
 export const LOUPE_EDGE = 4;
@@ -242,11 +243,12 @@ export function initLoupe(
 /** 원 · 복제 · 다시 뜨기를 맡음 — `sourceOf()` 가 뜰 영역 */
 export function createLoupeView(
   win: Window,
-  sourceOf: () => Element | null = () => win.document.getElementById("app"),
+  sourceOf: () => Element | null = () => win.document.body,
 ): LoupeView {
   const doc = win.document;
   let root: HTMLElement | null = null;
-  let stage: HTMLElement | null = null;
+  let stage: HTMLElement | null = null; // 이동만(합성층)
+  let scaler: HTMLElement | null = null; // 배율만 · 복제를 담음
   let label: HTMLElement | null = null;
   let zoom = LOUPE_ZOOM;
   let at: [number, number] = [0, 0]; // 마지막 커서 — 배율만 바뀔 때 다시 놓음
@@ -263,23 +265,28 @@ export function createLoupeView(
     root.style.width = root.style.height = `${LOUPE_DIAMETER}px`;
     stage = doc.createElement("div");
     stage.className = "ui-loupe__stage";
+    scaler = doc.createElement("div");
+    scaler.className = "ui-loupe__scale";
+    stage.append(scaler);
     const cross = doc.createElement("div");
     cross.className = "ui-loupe__cross";
     root.append(stage, cross);
     label = doc.createElement("div");
     label.className = "ui-loupe__zoom";
     label.setAttribute("aria-hidden", "true");
-    doc.body.append(root, label);
+    // body 밖 — body 를 뜨고 지켜보므로 원이 자기 복제 · 자기 움직임 관찰에 안 걸림
+    doc.documentElement.append(root, label);
   };
   const capture = (): void => {
     const source = sourceOf();
     const t0 = win.performance?.now() ?? 0;
-    stage!.replaceChildren();
-    if (source) sync = captureInto(source, stage!, win);
+    scaler!.replaceChildren();
+    if (source) sync = captureInto(source, scaler!, win);
     root!.dataset.captureMs = String(Math.round((win.performance?.now() ?? 0) - t0));
   };
+  /** 다시 뜨기 미룸 — 바뀜 · 스크롤 · 움직임마다 처음부터(멈춘 뒤 한 번 · 374-1) */
   const refresh = (): void => {
-    if (refreshTimer) return;
+    win.clearTimeout(refreshTimer);
     refreshTimer = win.setTimeout(() => {
       refreshTimer = 0;
       if (observer) capture();
@@ -316,16 +323,18 @@ export function createLoupeView(
     move(x, y) {
       if (!root || !stage || !label) return;
       at = [x, y];
+      if (refreshTimer) refresh(); // 움직이는 동안 안 뜸
       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 - zoom * x}px, ${r - zoom * y}px) scale(${zoom})`;
+      stage.style.transform = `translate(${r - zoom * x}px, ${r - zoom * y}px)`;
       const labelTop = Math.min(top + LOUPE_DIAMETER + 4, win.innerHeight - LOUPE_LABEL_H - 4);
       label.style.transform = `translate(${left + r}px, ${labelTop}px) translateX(-50%)`;
     },
     setZoom(z) {
       zoom = z;
       if (label) label.textContent = `×${z}`;
+      if (scaler) scaler.style.transform = `scale(${z})`;
       view.move(...at);
     },
     hide() {
@@ -336,7 +345,7 @@ export function createLoupeView(
       win.cancelAnimationFrame(syncFrame);
       syncFrame = 0;
       win.removeEventListener("scroll", onScroll, true);
-      stage?.replaceChildren(); // 복제를 지움
+      scaler?.replaceChildren(); // 복제를 지움
       if (root) root.hidden = label!.hidden = true;
     },
   };
diff --git a/ui_template/ui_template_theme.css b/ui_template/ui_template_theme.css
index c670ebc04..fc1bd6fe8 100644
--- a/ui_template/ui_template_theme.css
+++ b/ui_template/ui_template_theme.css
@@ -370,6 +370,9 @@
     --color-primary-text: #16121f;
     --color-accent: var(--color-lavender-wash);
     --color-focus-ring: var(--color-lavender-wash);
+
+    --color-success: #3fbb6f;
+    --color-danger: #e8695a;
     --panel-handle-border: #e0b64a;
     --map-route-locked: #f472b6;
   }