'데이터 필드 배선' → '값 가져오기' — 개발자 말을 걷어낸다

사용자가 "어떻게 사용하는지 모르겠다, 개발자가 아닌 사람도 쓸 수 있어야 한다" 고 했다.
화면을 열어 보니 낱말만 문제가 아니었다.

## 낱말

- 창 제목 '데이터 필드 배선' → <b>'값 가져오기'</b>. 전산실에서 '배선'은 랜선·전원이고,
  '배선 지우기' 는 데이터소스나 쿼리가 지워지는 것처럼 읽힌다(실제로는 이 컨트롤 속성만 빈다).
- 인스펙터 행 라벨 '데이터 필드' → '값 가져오기'. 빈 상태 '(배선 없음)' → <b>'(가져오지 않음)'</b> —
  대화상자의 지우기 버튼과 <b>글자까지 같게</b> 두어, 누르면 무엇이 되는지 미리 읽히게 했다.
- '필드' → '가져올 컬럼'. 앱은 이미 결과 창에서 '컬럼 N개', 배선 실패 문구에서
  '결과에 X 컬럼이 없습니다' 로 컬럼을 쓴다 — 낱말을 하나 더 만들지 않는다.
- '형태 Select/Rows' 를 화면에서 지웠다. .NET DataTable API 이름이라
  <b>SQL 을 아는 사람이 오히려 더 확실히 오해한다</b>(여기의 Select 는 SQL SELECT 가 아니다).
- '필터' → '행 조건'. WHERE 연상을 끊는다 — 서버로 가지 않고 이미 받아 온 표를 거르는 식이라
  NVL·TO_CHAR·|| 가 통하지 않는다. 되는 예와 안 되는 예를 나란히 적었다.

## 화면이 "무엇을 먼저 하나"의 답을 '지우기'로 주고 있었다

네 칸(형태·필터·행 번호·필드)이 같은 굵기로 나란히 있어 넷 다 채워야 하는 것처럼 보였다.
정작 검증이 요구하는 <b>필수는 둘</b>(데이터소스·컬럼)이고, 그 둘이 화면에서 가장 눈에 안 띄는
자리에 있었다. 게다가 선언 순서 때문에 첫 Tab 정지점이 '배선 지우기' 였다.

①②③ 으로 다시 세웠다 — ① 가져올 데이터소스 ② 가져올 컬럼, ③ '여러 행 중에서 고르기' 는 접는다.
접는 근거는 실측이다: 조건을 쓴 배선이 <b>0건</b>, 행 번호가 0 인 것이 98%.
기본값이 아닐 때만 접힌 머리에 칩('3번째 행' · '조건 있음')을 띄워 숨지 않게 했다.
초기 포커스도 다음 할 일로 보낸다.

## 첫 화면이 굳이 어려운 쪽으로 열리고 있었다

새 배선이 레거시 편집기와 같은 Select 형으로 시작해서, 처음 여는 사람이
<b>평생 안 쓸 개념(조건)</b>을 먼저 봤다. 새 배선을 Rows 형으로 바꿨다.

<b>동작은 같다.</b> 조건이 비면 Select("")(0) 과 Rows(0) 이 같은 행을 가리키고,
해석기 자신이 그 등가를 코드로 인정한다 — DataTableFieldPicker 는 조건이 비어 있으면
필터 경로를 아예 타지 않는다. 기존 값의 형태는 그대로 유지한다(원문을 안 건드리는 것이
왕복 무손실의 조건이다).

## 사용자를 창 밖으로 내보내던 문구

"필드 후보는 쿼리를 실행해야 알 수 있어 목록으로 제시하지 않습니다" —
이 창은 <b>모달이라 밖이 잠겨 있다</b>. 취소 → 데이터소스 찾기 → 쿼리 편집기 → 검증 실행 →
컬럼명 외우기 → 다시 열기. 레거시 편집기는 이 목록을 이미 보여 줬으므로
그 문구는 퇴행을 설명하는 문장이었다.

이제 데이터소스를 고르면 그 조회 결과의 컬럼 이름을 보여 준다. 실행은 이 창이 하지 않는다 —
호출부가 MDataTableRunner 를 함수로 감싸 넘기므로 접속·치환·캐시·실패 처리가 한 군데에 남는다.
창은 데이터소스별로 <b>한 번만</b> 묻는다(Refresh 가 키 입력마다 도는데 그때마다 조회하면 타이핑이 끊긴다).
못 읽으면 <b>왜</b> 못 읽는지 말하고 직접 입력 칸을 남긴다.

## 원문은 없애지 않고 접었다

'저장될 값'에 MDataTable1.Select("")(0).Item("") 이 큰 자리로 보이던 것을
사람 말 한 줄로 바꿨다 — "서식을 열면 — MDataTable2 조회 결과의 첫 행에서 ALGYON 값을
가져와 이 칸에 넣습니다." 원문은 접힌 '저장 형식' 줄로 내리고 복사 버튼을 붙였다.

없애지는 않았다. 인스펙터 툴팁·진단 덤프·레거시 문서가 전부 이 표기로 이야기되고,
이 속성에는 자유 텍스트 편집 경로가 없어 무엇이 저장되는지 볼 수 있는 곳이 이 줄뿐이다.

## 곁가지로 고친 조용한 결함 둘

- <b>행 번호가 조용히 0 이 됐다</b>. 전각 '１' 을 넣으면 파싱 실패가 그대로 0 이 되어
  아무 말 없이 첫 행을 가리켰다. 이제 이유를 말하고 확인을 막는다.
- <b>형태를 바꾸면 조건이 조용히 사라졌다</b>. Rows 조립은 Filter 를 아예 쓰지 않는데
  화면은 칸을 흐리게만 해서 값이 살아 있는 것처럼 보였다. 다시 열면 영구히 없어진다.
  이제 명시적 버튼이고, 버려지는 조건 원문을 확인 문구에 적어 보여 준다.
- 데이터소스가 0개일 때 '데이터소스를 선택하세요'(따를 수 없는 지시) 대신 다음 행동을 말한다.

## 판정

- 단위 시험 388 · edit-smoke 405건 전건 통과 (옛 문구를 기대한 검사 4건도 새 낱말로 갱신)
- --dialog-shots 69장 전건 통과 — 다크·라이트 양쪽을 눈으로 확인
- --modal-check · --maxrect · --scale-budget 전건 통과
- --db-render P062 md5 8d683835f5d81e7bb41c79071d6bf954 불변
- <b>저장되는 문자열은 한 글자도 바꾸지 않았다</b> — 화면 문구와 배치만 바뀐다

## 남은 것

컬럼 목록과 값 확인은 DB 접속이 있어야 동작한다. 오프라인 설계에서는 여전히 직접 입력이고,
그때 컬럼명 대소문자 함정이 남는다. '가져올 값 확인'(현재 환자로 실제 한 칸을 뽑아 보여 주기)은
이번에 넣지 않았다 — 환자 세션까지 이 창에 들이는 일이라 별건이다.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/SheetMe.Core/Catalog/ControlRegistry.cs

@@ -66,7 +66,9 @@ public static class ControlRegistry
         /// </summary>
         public static PropertyDef DataTableField => new()
         {
-            Key = "DataTableField", Label = "데이터 필드", Editor = PropEditorKind.DataTableField,
+            // 라벨에 '배선' 을 쓰지 않는다 — 전산실에서 배선은 랜선·전원이다.
+            // '값 가져오기' 는 방향이 이름에 들어 있어 형제 속성(데이터 태그)과도 구별된다.
+            Key = "DataTableField", Label = "값 가져오기", Editor = PropEditorKind.DataTableField,
         };
     }
 

src/SheetMe.Core/Serialization/LegacyTypeCatalog.cs

@@ -14,6 +14,17 @@ public static class LegacyTypeCatalog
     /// <summary>페이지 루트 클래스 단축명</summary>
     public const string HostClassName = "MDesignerHost";
 
+    /// <summary>
+    /// 데이터소스의 <b>중립</b> 타입명 — 레거시 클래스명은 <c>MDataTable</c> 이고 여기서 이 이름으로 바뀐다.
+    ///
+    /// <b>상수로 두는 이유.</b> 두 이름이 공존해서 실제로 사고가 났다.
+    /// 배선 실행기가 레거시 이름(<c>MDataTable</c>)으로 컨트롤을 찾고 있었는데,
+    /// 서식을 XML 에서 읽으면 그 시점에 이미 중립 이름으로 바뀌어 있어 <b>한 개도 못 찾았다</b> —
+    /// 실사용 서식의 데이터소스 배선이 전부 "이 서식에 없습니다"로 죽었다.
+    /// 문자열을 각자 적는 한 같은 일이 또 난다.
+    /// </summary>
+    public const string DataTableType = "DataTable";
+
     /// <summary>페이지 루트 AQN (실샘플 sheetdesign.xml 원문 확인)</summary>
     public const string HostAqn =
         "M.EMR.UserControl.MDesignerHost, M.EMR.UserControl, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
@@ -42,7 +53,7 @@ public static class LegacyTypeCatalog
         ["MPictureBox"] = "PictureBox",
         ["MCalcBox"] = "CalcBox",
         ["MButton"] = "Button",
-        ["MDataTable"] = "DataTable",
+        ["MDataTable"] = DataTableType,
         // Spread 는 읽기 매핑만(렌더) — E_SpdMst 디자인 없이는 신규 생성 불가하므로 쓰기 매핑/팔레트 미등록
         ["Spread"] = "Spread",
     };

src/SheetMe.Designer/Behaviors/LayerListBehavior.cs

@@ -138,6 +138,58 @@ public static class LayerListBehavior
         {
             syncing.Remove(list);
         }
+        RevealPrimary(list, designer);
+    }
+
+    /// <summary>
+    /// 캔버스에서 고른 것을 목록이 <b>따라오게</b> 한다 — 조상을 펴고 그 행으로 스크롤한다.
+    ///
+    /// <b>왜 필요한가.</b> 1,067개짜리 서식에서 종이 한가운데 컨트롤을 클릭하면
+    /// 목록에는 아무 변화가 없는 경우가 흔했다 — 행이 뷰포트 밖이거나, 조상이 접혀 있어
+    /// <b>행 자체가 만들어지지 않았거나</b>. 강조를 해도 눈에 안 보이니 선택이 안 된 것으로 읽힌다.
+    /// 반대 방향(목록 더블클릭 → 캔버스)은 이미 잘 되어 있어 비대칭이 더 눈에 띄었다.
+    ///
+    /// <b>펴기는 한 번만 시도한다.</b> 편 결과로 목록이 다시 만들어지면 재구성 이벤트가
+    /// 이 경로를 한 번 더 부르는데, 그때는 행이 있으므로 스크롤만 하고 끝난다.
+    /// 행이 끝내 없으면(검색·타입 필터에 걸려 빠진 경우) 아무것도 하지 않는다 —
+    /// 필터를 사용자가 건 것이라 임의로 풀면 그쪽이 더 놀랍다.
+    /// </summary>
+    private static void RevealPrimary(ListBox list, DesignerViewModel designer)
+    {
+        if (designer.Selection.Primary is not { } primary)
+        {
+            return;
+        }
+        if (RowOf(list, primary) is { } row)
+        {
+            list.ScrollIntoView(row);
+            return;
+        }
+        if (!designer.ExpandLayerPathTo(primary))
+        {
+            return; // 펼 것이 없는데도 행이 없다 = 필터에 걸린 것이다
+        }
+        // 재구성은 비동기로 도는 경로가 있다 — 한 틱 뒤에 다시 찾아본다
+        list.Dispatcher.BeginInvoke(new Action(() =>
+        {
+            if (RowOf(list, primary) is { } revealed)
+            {
+                list.ScrollIntoView(revealed);
+            }
+        }), System.Windows.Threading.DispatcherPriority.Background);
+    }
+
+    /// <summary>이 컨트롤을 담고 있는 목록 행 — 없으면 null(접혔거나 필터에 걸렸다)</summary>
+    private static object? RowOf(ListBox list, ControlViewModel control)
+    {
+        foreach (var row in list.Items)
+        {
+            if (DesignerViewModel.ControlsOfLayerRow(row).Contains(control))
+            {
+                return row;
+            }
+        }
+        return null;
     }
 
     /// <summary>현재 선택으로부터 강조돼야 할 행들</summary>

src/SheetMe.Designer/Diagnostics/DbSmoke.cs

@@ -2266,7 +2266,7 @@ public static class DbSmoke
                         probeDoc.Pages.Add(probePage);
                         var probeSource = new SheetMe.Core.Models.ControlElement
                         {
-                            Type = "MDataTable", Id = "MDataTable1",
+                            Type = SheetMe.Core.Serialization.LegacyTypeCatalog.DataTableType, Id = "MDataTable1",
                             Bounds = new SheetMe.Core.Models.LayoutRect { X = 0, Y = 0, W = 20, H = 20 },
                         };
                         // 스칼라 치환과 DataRow 치환을 한 문장에 넣는다 — 둘은 다른 코드 경로다

src/SheetMe.Designer/Diagnostics/DialogShots.cs

@@ -462,7 +462,7 @@ public static class DialogShots
         {
             var source = new SheetMe.Core.Models.ControlElement
             {
-                Type = "MDataTable", Id = id,
+                Type = SheetMe.Core.Serialization.LegacyTypeCatalog.DataTableType, Id = id,
                 Bounds = new SheetMe.Core.Models.LayoutRect { X = 0, Y = 0, W = 20, H = 20 },
             };
             source.Props.SetText("Query", query);

src/SheetMe.Designer/Diagnostics/EditSmoke.cs

@@ -392,7 +392,7 @@ public static class EditSmoke
                 }
                 host.Children.Add(new ControlElement
                 {
-                    Type = "MDataTable", Id = "안쪽데이터소스",
+                    Type = SheetMe.Core.Serialization.LegacyTypeCatalog.DataTableType, Id = "안쪽데이터소스",
                     Bounds = new LayoutRect { X = 10, Y = 90, W = 120, H = 40 },
                 });
                 boxedPage.Controls.Add(host);
@@ -736,7 +736,7 @@ public static class EditSmoke
                 fieldDoc.Pages.Add(fieldPage);
                 var source = new ControlElement
                 {
-                    Type = "MDataTable", Id = "MDataTable1",
+                    Type = SheetMe.Core.Serialization.LegacyTypeCatalog.DataTableType, Id = "MDataTable1",
                     Bounds = new LayoutRect { X = 0, Y = 0, W = 20, H = 20 },
                 };
                 source.Props.SetText("Query", "SELECT 'ㄱ' NAM FROM DUAL");
@@ -1112,6 +1112,243 @@ public static class EditSmoke
                     $"ValueText='{choiceRow.ValueText}' IsMixed={choiceRow.IsMixed}");
             }
 
+            // 15-a0000000) 끄는 동안 치수·좌표가 캔버스에 보인다.
+            //
+            // 전에는 숫자가 300px 떨어진 인스펙터에만 떴다 — 끌고, 손 떼고, 오른쪽을 보고, 다시 끈다.
+            // 간격 수치 칩은 균등 스냅이 성립할 때만 나타나므로 "지금 몇 px 인가"는 알 방법이 없었다.
+            {
+                var badge = new DesignerViewModel(new FormDesignDataBusiness().CreateNew());
+                badge.AddControlAt("Label", new Point(80, 80));
+                var one = badge.Pages[0].Controls[0];
+                badge.Selection.SetSingle(one);
+                Check("치수 칩: 평소에는 안 보인다", !badge.Overlay.ShowDragBadge);
+
+                var world = badge.WorldBoundsOf(one);
+                var grab = new Point(world.X + world.Width / 2, world.Y + world.Height / 2);
+                var noSnap = new PointerContext(false, false, true, 1);
+                badge.Interaction.PointerDown(grab, noSnap);
+                badge.Interaction.PointerMove(new Point(grab.X + 30, grab.Y + 10), noSnap);
+                Check("치수 칩: 끄는 동안 좌표가 보인다",
+                    badge.Overlay.ShowDragBadge && badge.Overlay.DragBadgeText.StartsWith("X ", StringComparison.Ordinal),
+                    badge.Overlay.DragBadgeText);
+
+                badge.Interaction.PointerUp(new Point(grab.X + 30, grab.Y + 10), noSnap);
+                Check("치수 칩: 놓으면 사라진다", !badge.Overlay.ShowDragBadge);
+
+                // 크기 조절일 때는 <b>크기</b>를 보여 준다 — 지금 바꾸고 있는 값이 그것이다
+                badge.Selection.SetSingle(one);
+                var bounds = badge.WorldBoundsOf(one);
+                var handles = ViewModels.SelectionOverlayViewModel.HandlePositions(bounds);
+                badge.Interaction.PointerDown(handles[4], noSnap); // 우하단
+                badge.Interaction.PointerMove(new Point(handles[4].X + 25, handles[4].Y + 12), noSnap);
+                Check("치수 칩: 크기 조절 중에는 크기가 보인다",
+                    badge.Overlay.ShowDragBadge && badge.Overlay.DragBadgeText.Contains('×'),
+                    badge.Overlay.DragBadgeText);
+                badge.Interaction.PointerUp(new Point(handles[4].X + 25, handles[4].Y + 12), noSnap);
+            }
+
+            // 15-a000000) 패널 안에 그린 마퀴는 그 안의 것을 고른다.
+            //
+            // 전에는 마퀴가 최상위만 훑어서, 패널 안 체크박스 5개를 한 번에 고르려고
+            // 패널 안쪽을 끌면 패널만 잡히거나 아무것도 안 잡혔다 —
+            // 결국 Ctrl+클릭 반복이나 레이어 목록으로 우회했다.
+            // 컨테이너 자식은 전체 컨트롤의 18.3%(실측)라 드문 경우가 아니다.
+            {
+                var mq = new DesignerViewModel(new FormDesignDataBusiness().CreateNew());
+                mq.AddControlAt("CheckBox", new Point(100, 100));
+                mq.AddControlAt("CheckBox", new Point(100, 140));
+                mq.Selection.Set(mq.Pages[0].Controls.ToList(), mq.Pages[0].Controls[0]);
+                mq.GroupSelection();
+                var box = mq.Pages[0].Controls.OfType<ViewModels.Controls.ContainerViewModel>().First();
+                var boxWorld = mq.WorldBoundsOf(box);
+
+                // ① 패널 <b>안쪽</b>을 끈다 — 자식이 잡혀야 한다
+                var inside = new Rect(boxWorld.X + 2, boxWorld.Y + 2,
+                    Math.Max(1, boxWorld.Width - 4), Math.Max(1, boxWorld.Height - 4));
+                var innerHits = mq.MarqueeHits(inside);
+                Check("마퀴: 패널 안에 그리면 안의 것이 잡힌다",
+                    innerHits.Count == box.Children.Count
+                    && innerHits.All(h => ReferenceEquals(h.Parent, box)),
+                    $"{innerHits.Count}개 (패널 자식 {box.Children.Count}개)");
+
+                // ② 패널을 <b>걸치도록</b> 끈다 — 예전처럼 패널 자체가 잡혀야 한다
+                var across = new Rect(boxWorld.X - 20, boxWorld.Y - 20, boxWorld.Width + 40, 30);
+                var outerHits = mq.MarqueeHits(across);
+                Check("마퀴: 패널에 걸치면 패널이 잡힌다(기존 동작 유지)",
+                    outerHits.Count == 1 && ReferenceEquals(outerHits[0], box),
+                    $"{outerHits.Count}개 — {string.Join(",", outerHits.Select(h => h.Type))}");
+            }
+
+            // 15-a00000) 태그 행이 사실대로 말하는가.
+            {
+                // 카탈로그에 없는 이름은 표식이 붙어야 한다 — 그러나 <b>막지는 않는다</b>.
+                // 인라인으로 직접 치는 것이 주 경로인데 검증이 하나도 없어서,
+                // 한 글자 틀려도 조용히 커밋되고 미리보기에서 빈칸으로만 드러났다.
+                var tagRow2 = new ViewModels.Inspector.TagPickerRowViewModel("데이터 태그",
+                    "데이터 태그 선택", SheetMe.Core.Catalog.LegacyTagCatalog.DataInterfaceTags,
+                    new[] { "PAT_이름" });
+
+                tagRow2.Initialize("PAT_이름");
+                Check("태그: 카탈로그에 있는 이름은 표식이 없다", !tagRow2.IsUnknownTag);
+
+                tagRow2.ValueText = "PAT_이룸"; // 한 글자 오타
+                Check("태그: 카탈로그에 없는 이름에 표식이 붙는다", tagRow2.IsUnknownTag);
+                Check("태그: 그래도 값은 그대로 둔다(사이트 커스텀 태그)", tagRow2.ValueText == "PAT_이룸",
+                    tagRow2.ValueText);
+
+                tagRow2.Initialize(string.Empty);
+                Check("태그: 빈 값은 표식 대상이 아니다", !tagRow2.IsUnknownTag);
+                tagRow2.Initialize(null, isMixed: true);
+                Check("태그: 값이 갈리면 표식을 내지 않는다", !tagRow2.IsUnknownTag);
+
+                // 로그인 사용자 태그 — 피커가 쓰던 5-인자판은 면허·전문의·직종·부서·부서전화를
+                // 빈 문자열로 채워, 종이에는 값이 찍히는데 피커에서만 "비어 있습니다"가 나왔다
+                var withFields = SheetMe.Core.Catalog.TagPreviewCatalog.FromUser(
+                    "ETC_로그인_의사면허번호", "011825", "홍길동", "010", "02",
+                    "면허12345", "전문의678", "의사", "내과", "1234");
+                var withoutFields = SheetMe.Core.Catalog.TagPreviewCatalog.FromUser(
+                    "ETC_로그인_의사면허번호", "011825", "홍길동", "010", "02");
+                Check("태그: 면허번호는 10-인자판에서만 값이 나온다",
+                    withFields == "면허12345" && withoutFields.Length == 0,
+                    $"10인자='{withFields}' 5인자='{withoutFields}'");
+            }
+
+            // 15-a0000) 레이어 목록이 계층과 범위를 말하는가.
+            //
+            // 사용자가 콕 집어 "레이어 구분이 잘 안 된다"고 한 곳이다. 원인은 색이 아니라 <b>산수</b>였다 —
+            // 셰브론이 자식 없는 행에서 Collapsed 로 사라지며 폭 16 이 통째로 없어지는데
+            // 컨테이너 자식 들여쓰기도 정확히 16 이라, 부모와 자식의 아이콘이 같은 x 에 놓였다.
+            {
+                var tree = new DesignerViewModel(new FormDesignDataBusiness().CreateNew());
+                tree.AddControlAt("RadioButton", new Point(100, 100));
+                tree.AddControlAt("RadioButton", new Point(100, 140));
+                tree.Selection.Set(tree.Pages[0].Controls.ToList(), tree.Pages[0].Controls[0]);
+                tree.GroupSelection();
+                var wrapped = tree.Pages[0].Controls.OfType<ViewModels.Controls.ContainerViewModel>().First();
+
+                Check("레이어: 컨테이너가 자식 수를 말한다", wrapped.LayerChildCountText == "(2)",
+                    wrapped.LayerChildCountText);
+
+                // 둘째 줄은 <b>항상</b> 있어야 한다 — 없으면 1줄/2줄이 섞여 훑는 리듬이 깨진다.
+                // 세 갈래를 다 본다: 문구 없음 / 문구가 타입명 그대로(갓 놓은 것) / 사람이 쓴 문구.
+                var fresh = wrapped.Children[0];    // 갓 놓은 라디오 — 문구가 "라디오버튼"이다
+                Check("레이어: 갓 놓은 것은 둘째 줄이 이름뿐이다(타입명 중복 없음)",
+                    fresh.LayerSubText == fresh.Id,
+                    $"'{fresh.LayerName}' / '{fresh.LayerSubText}'");
+
+                // 접힌 조상 때문에 <b>행 자체가 없는</b> 상태를 편다.
+                // 접기는 레이어 목록만의 개념이라 캔버스에는 자식이 그대로 보인다 —
+                // 종이에서 클릭했는데 목록에 아무 반응이 없으면 어느 쪽이 맞는지 알 수 없다.
+                wrapped.IsLayerExpanded = false;
+                tree.RebuildLayerRows();
+                var hiddenChild = wrapped.Children[0];
+                Check("자동 스크롤: 접히면 자식 행이 목록에 없다",
+                    !tree.LayerRows.Any(r => DesignerViewModel.ControlsOfLayerRow(r).Contains(hiddenChild)));
+
+                Check("자동 스크롤: 조상을 펴면 true 를 돌려준다", tree.ExpandLayerPathTo(hiddenChild));
+                tree.RebuildLayerRows();
+                Check("자동 스크롤: 편 뒤에는 행이 생긴다",
+                    tree.LayerRows.Any(r => DesignerViewModel.ControlsOfLayerRow(r).Contains(hiddenChild)));
+                Check("자동 스크롤: 이미 펴져 있으면 false(무한 재구성 방지)",
+                    !tree.ExpandLayerPathTo(hiddenChild));
+
+                var bare = new ControlElement
+                {
+                    Type = "TextBox", Id = "TextBox9",
+                    Bounds = new LayoutRect { X = 10, Y = 10, W = 100, H = 20 },
+                };
+                var bareDoc = new FormDocument();
+                var barePage = new FormPage { Width = 720, Height = 856 };
+                barePage.Controls.Add(bare);
+                bareDoc.Pages.Add(barePage);
+                var bareVm = new DesignerViewModel(bareDoc).Pages[0].Controls[0];
+                Check("레이어: 문구가 없는 행도 둘째 줄이 있다", bareVm.LayerSubText.Length > 0,
+                    $"'{bareVm.LayerName}' / '{bareVm.LayerSubText}'");
+                Check("레이어: 문구가 없으면 둘째 줄은 타입명이다", bareVm.LayerSubText == "텍스트박스",
+                    bareVm.LayerSubText);
+                Check("레이어: 같은 글자를 두 줄에 두 번 쓰지 않는다",
+                    !bareVm.LayerSubText.Contains(bareVm.Id, StringComparison.Ordinal),
+                    $"Id={bareVm.Id} 둘째줄='{bareVm.LayerSubText}'");
+
+                bare.Props.SetText("Text", "환자명");
+                var named = new DesignerViewModel(bareDoc).Pages[0].Controls[0];
+                Check("레이어: 사람이 쓴 문구면 타입·이름을 함께 보여 준다",
+                    named.LayerSubText == "텍스트박스 · TextBox9",
+                    $"'{named.LayerName}' / '{named.LayerSubText}'");
+
+                // 중첩까지 센다 — "이걸 지우면 몇 개가 같이 지워지나"가 그 수다.
+                // 중첩 구조는 모델로 직접 짠다(Ctrl+G 를 두 번 겹치는 경로는 이 검사의 대상이 아니다).
+                var nestDoc = new FormDocument();
+                var nestPage = new FormPage { Width = 720, Height = 856 };
+                nestDoc.Pages.Add(nestPage);
+                var outerModel = new ControlElement
+                {
+                    Type = "Panel", Id = "바깥",
+                    Bounds = new LayoutRect { X = 20, Y = 20, W = 300, H = 200 },
+                };
+                var innerModel = new ControlElement
+                {
+                    Type = "Panel", Id = "안쪽",
+                    Bounds = new LayoutRect { X = 10, Y = 10, W = 200, H = 120 },
+                };
+                for (var i = 0; i < 2; i++)
+                {
+                    innerModel.Children.Add(new ControlElement
+                    {
+                        Type = "RadioButton", Id = $"보기{i}",
+                        Bounds = new LayoutRect { X = 10, Y = 10 + (i * 30), W = 100, H = 20 },
+                    });
+                }
+                outerModel.Children.Add(innerModel);
+                nestPage.Controls.Add(outerModel);
+                var nested = new DesignerViewModel(nestDoc);
+
+                var outer = nested.Pages[0].Controls.OfType<ViewModels.Controls.ContainerViewModel>().First();
+                var inner = outer.Children.OfType<ViewModels.Controls.ContainerViewModel>().First();
+                Check("레이어: 자식 수는 중첩까지 센다", outer.LayerChildCountText == "(3)",
+                    $"{outer.LayerChildCountText} (바깥 = 안쪽 패널 1 + 라디오 2)");
+
+                // 컨테이너를 고르면 그 안이 밴드로 묶여야 한다
+                nested.Selection.SetSingle(outer);
+                Check("레이어: 고른 컨테이너의 안쪽이 범위로 표시된다",
+                    inner.Highlight == LayerHighlight.Navy && outer.Highlight == LayerHighlight.Blue,
+                    $"바깥={outer.Highlight} 안쪽={inner.Highlight}");
+                Check("레이어: 손자까지 범위에 들어간다",
+                    inner.Children.All(c => c.Highlight == LayerHighlight.Navy),
+                    string.Join(",", inner.Children.Select(c => c.Highlight.ToString())));
+            }
+
+            // 15-a000) 데이터소스를 <b>실사용과 같은 경로</b>로 만들었을 때도 러너가 찾는가.
+            //
+            // 이 검사가 없어서 배선 전체가 실사용에서 죽어 있는 것을 오래 못 봤다.
+            // 러너는 레거시 클래스명("MDataTable")으로 컨트롤을 찾고 있었는데, 서식을 XML 에서 읽으면
+            // 그 순간 중립 이름("DataTable")으로 바뀌어 있어 <b>한 개도 못 모았다</b> —
+            // 모든 DataTableField 가 "이 서식에 없습니다"로 실패해 종이에서 빈칸이 됐다.
+            // 그런데 진단들이 ControlElement 를 <b>손으로</b> 만들며 같은 레거시 이름을 써서
+            // 러너의 오타와 짝이 맞아 전부 초록이었다. 그래서 여기서는 손으로 만들지 않는다.
+            {
+                Check("타입명: 레거시 MDataTable 은 중립 DataTable 로 읽힌다",
+                    SheetMe.Core.Serialization.LegacyTypeCatalog.DataTableType == "DataTable");
+
+                var dsDoc = new DesignerViewModel(new FormDesignDataBusiness().CreateNew());
+                dsDoc.AddControlAt("DataTable", new Point(60, 60)); // 팔레트가 쓰는 그 경로
+                var made = dsDoc.Pages[0].Controls.Single(c => c.Type == "DataTable");
+                made.Model.Props.SetText("Query", "SELECT 1 FROM DUAL");
+
+                var runner = new Services.MDataTableRunner(dsDoc.Document, null);
+                Check("배선: 팔레트로 만든 데이터소스를 러너가 찾는다",
+                    runner.Names.Count == 1 && runner.Names[0] == made.Id,
+                    runner.Names.Count == 0 ? "0개 — 러너가 타입명을 잘못 보고 있다"
+                        : string.Join(",", runner.Names));
+
+                // 이름으로 가리키는 배선이 실제로 그 데이터소스에 닿는가(값은 DB 없이 못 내지만
+                // '이 서식에 없습니다'로 떨어지면 안 된다)
+                var spec = SheetMe.Core.Catalog.DataTableFieldSpec.Parse($"{made.Id}.Rows(0).Item(\"NAM\")");
+                var reason = spec is null ? "(형식 파싱 실패)" : runner.Resolve(spec).Text;
+                Check("배선: '이 서식에 없습니다'로 떨어지지 않는다",
+                    !reason.Contains("이 서식에 없습니다", StringComparison.Ordinal), reason);
+            }
+
             // 15-a00) 아이콘 기본색이 검정으로 떨어지지 않는다.
             //
             // 색도 리소스 키도 안 준 아이콘이 <c>Brushes.Black</c> 으로 칠해지고 있었다.
@@ -2278,22 +2515,25 @@ public static class EditSmoke
                 designer.Inspector.SelectedTab = ViewModels.Inspector.InspectorTab.Data;
                 var dtfRow = designer.Inspector.Rows
                     .OfType<ViewModels.Inspector.DataTableFieldRowViewModel>().FirstOrDefault();
-                Check("배선: 전용 편집 행이 붙는다", dtfRow is not null);
+                Check("값 가져오기: 전용 편집 행이 붙는다", dtfRow is not null);
                 if (dtfRow is null)
                 {
                     designer.Inspector.SelectedTab = previousTab;
                     goto skipWiring;
                 }
-                Check("배선: 값이 없으면 안내 문구", dtfRow.Summary == "(배선 없음)", dtfRow.Summary);
+                // 빈 상태 문구는 대화상자의 지우기 버튼과 <b>글자까지 같다</b> —
+                // 그 버튼을 누르면 무엇이 되는지 미리 읽히게 하려는 것이다
+                Check("값 가져오기: 값이 없으면 지우기 버튼과 같은 말을 쓴다",
+                    dtfRow.Summary == "(가져오지 않음)", dtfRow.Summary);
 
                 // 운영 다수파인 Rows 형을 읽어야 한다(1,624건, 76%)
                 dtfRow.ValueText = $"{source.Id}.Rows(0).Item(\"ALGYON\")";
-                Check("배선: Rows 형을 읽는다", dtfRow.Summary.Contains(source.Id) && dtfRow.Summary.Contains("ALGYON"),
+                Check("값 가져오기: 저장된 값을 사람 말로 요약한다", dtfRow.Summary.Contains(source.Id) && dtfRow.Summary.Contains("ALGYON"),
                     dtfRow.Summary);
 
                 // 해석 못 하는 값은 조용히 고치지 않고 경고로 드러낸다
                 dtfRow.ValueText = "MDataTable1.Rows";
-                Check("배선: 미완성 값은 경고로 드러낸다", dtfRow.Summary.StartsWith("⚠"), dtfRow.Summary);
+                Check("값 가져오기: 미완성 값은 경고로 드러낸다", dtfRow.Summary.StartsWith("⚠"), dtfRow.Summary);
 
                 dtfRow.ValueText = string.Empty;
                 designer.Inspector.SelectedTab = previousTab;

src/SheetMe.Designer/Services/InteractionController.cs

@@ -233,20 +233,21 @@ public sealed class InteractionController
                 designer.ReassignPagesAfterMove(origBounds.Keys.ToList());
                 designer.Overlay.ClearGuides();
                 designer.Snap.EndDrag();
+                designer.Overlay.ClearDragBadge();
                 break;
 
             case Mode.Resize:
                 designer.Overlay.ClearGuides();
                 designer.Snap.EndDrag();
+                designer.Overlay.ClearDragBadge();
                 break;
 
             case Mode.Marquee:
                 var rect = RectFrom(downPoint, world);
                 designer.Overlay.UpdateMarquee(null);
-                var hits = designer.ControlsIntersecting(rect)
-                    .SelectMany(designer.GroupMatesOf)
-                    .Distinct()
-                    .ToList();
+                // 마퀴 전용 규칙 — 그룹은 넓히되 컨테이너 자식은 부모로 되돌리지 않는다.
+                // GroupMatesOf 를 그대로 쓰면 패널 안쪽을 정확히 골라 놓고도 결과가 패널 하나가 된다.
+                var hits = designer.MarqueeHits(rect);
                 if (ctx.Ctrl || ctx.Shift)
                 {
                     var merged = designer.Selection.Items.Union(hits).ToList();
@@ -285,6 +286,7 @@ public sealed class InteractionController
             {
                 designer.Overlay.ClearGuides();
                 designer.Snap.EndDrag();
+                designer.Overlay.ClearDragBadge();
                 mode = Mode.None;
                 origBounds.Clear();
                 downControl = null;
@@ -443,6 +445,11 @@ public sealed class InteractionController
         }
 
         designer.Selection.NotifyBoundsChanged();
+        // 끄는 동안 지금 값을 보여 준다 — 숫자가 인스펙터에만 있으면 끌다 말고 오른쪽을 봐야 한다
+        if (designer.SelectionWorldBounds() is { } movedBounds)
+        {
+            designer.Overlay.SetDragBadge(movedBounds, resizing: false);
+        }
     }
 
     private void DoResize(Point world, PointerContext ctx)
@@ -509,6 +516,10 @@ public sealed class InteractionController
         }
 
         designer.Selection.NotifyBoundsChanged();
+        if (designer.SelectionWorldBounds() is { } sizedBounds)
+        {
+            designer.Overlay.SetDragBadge(sizedBounds, resizing: true);
+        }
     }
 
     /// <summary>드래그 첫 실변경 시 1회 스냅샷 — 드래그 전체 = Undo 1스텝</summary>

src/SheetMe.Designer/Services/MDataTableRunner.cs

@@ -1,5 +1,6 @@
 using SheetMe.Core.Catalog;
 using SheetMe.Core.Models;
+using SheetMe.Core.Serialization;
 using SheetMe.Data.Stores;
 
 namespace SheetMe.Designer.Services;
@@ -141,7 +142,13 @@ public sealed class MDataTableRunner : IDataFieldResolver
     {
         foreach (var control in controls)
         {
-            if (control.Type == "MDataTable")
+            // <b>중립 타입명으로 비교한다.</b> 여기가 레거시 클래스명("MDataTable")을 보고 있어서
+            // 실사용 서식에서는 데이터소스를 <b>한 개도 못 모았다</b> — XML 에서 읽는 순간
+            // LegacyTypeCatalog 가 이미 "DataTable" 로 바꿔 두기 때문이다.
+            // 그 결과 모든 DataTableField 배선이 "데이터소스 X 이 이 서식에 없습니다"로 실패해
+            // 미리보기·인쇄에서 빈칸이 됐고, 미리보기의 '데이터소스...' 버튼은 영영 회색이었다.
+            // 진단들이 ControlElement 를 손으로 만들며 같은 레거시 이름을 써서 초록으로 통과하고 있었다.
+            if (string.Equals(control.Type, LegacyTypeCatalog.DataTableType, StringComparison.Ordinal))
             {
                 queries[control.Id] = control.Props.GetText("Query") ?? string.Empty;
             }

src/SheetMe.Designer/ViewModels/Controls/ControlViewModel.cs

@@ -199,6 +199,33 @@ public abstract class ControlViewModel : ViewModelBase, ILayerRow
     /// <summary>이름 칸을 그릴지 — 문구와 이름이 다를 때만</summary>
     public bool HasLayerId => LayerId.Length > 0;
 
+    /// <summary>
+    /// 레이어 행 둘째 줄 — <b>항상</b> 있다. 그래야 행 높이가 일정하다.
+    ///
+    /// 전에는 표시명이 곧 Id 인 행(문구가 없는 컨트롤)에서 둘째 줄이 통째로 빠져
+    /// 목록에 1줄과 2줄이 섞였다. 훑을 때 리듬이 깨지고, 어느 행이 무엇인지
+    /// 눈이 매번 다시 자리를 잡아야 했다.
+    ///
+    /// <b>타입명을 앞에 둔다.</b> 아이콘만으로는 타입이 안 갈리는 짝이 실제로 있다 —
+    /// 라벨과 마스크입력이 같은 글리프를 쓰고, 리스트박스와 체크리스트도 같다.
+    /// 이름(Id)은 표시명과 다를 때만 뒤에 붙인다 — 같으면 윗줄과 같은 글자를 두 번 쓰는 셈이다.
+    /// 이름을 계속 보여 주는 이유는 그것이 <b>외부 참조 키</b>이기 때문이다(수식·액션 대상·이벤트 규약).
+    /// </summary>
+    public string LayerSubText
+    {
+        get
+        {
+            var typeName = SheetMe.Core.Catalog.ControlRegistry.Find(Type)?.DisplayName ?? Type;
+            // 이름이 곧 표시명이면(문구 없는 컨트롤) 타입만 — 같은 글자를 두 번 쓰지 않는다
+            if (!HasLayerId)
+            {
+                return typeName;
+            }
+            // 갓 놓은 컨트롤은 문구가 타입명 그대로다("라디오버튼") — 윗줄이 이미 타입을 말했으므로 이름만
+            return LayerName == typeName ? LayerId : $"{typeName} · {LayerId}";
+        }
+    }
+
     /// <summary>레이어 잠금 토글 아이콘명</summary>
     public string LockIcon => Model.Locked ? "lock" : "unlock";
 

src/SheetMe.Designer/ViewModels/Controls/TypedControlViewModels.cs

@@ -136,6 +136,30 @@ public abstract class ContainerViewModel : ControlViewModel
     /// <summary>레이어 목록에서 펼침 셰브론을 그릴지 — 자식이 있을 때만</summary>
     public override bool HasLayerChildren => Children.Count > 0;
 
+    /// <summary>
+    /// 레이어 목록에 붙는 자식 수 — 접혀 있어도 <b>무엇이 딸려 있는지</b> 알 수 있어야 한다.
+    ///
+    /// 페이지 행에는 (7), 그룹 폴더에는 (3)이 이미 붙는데 컨테이너만 없었다.
+    /// 그래서 접힌 패널이 3개를 품었는지 300개를 품었는지 펴 보기 전에는 알 수 없었고,
+    /// 그 패널을 지우거나 옮기기 전에 무엇이 함께 가는지도 알 수 없었다.
+    /// 중첩까지 세어 실제로 딸려 가는 수를 말한다.
+    /// </summary>
+    public string LayerChildCountText => $"({CountAll(Children)})";
+
+    private static int CountAll(IEnumerable<ControlViewModel> items)
+    {
+        var total = 0;
+        foreach (var item in items)
+        {
+            total++;
+            if (item is ContainerViewModel container)
+            {
+                total += CountAll(container.Children);
+            }
+        }
+        return total;
+    }
+
     protected ContainerViewModel(ControlElement model) : base(model) { }
 
     /// <summary>시각 재해석 — 자식에게 상속 컨텍스트 전파(WinForms Font/ForeColor 상속)</summary>

src/SheetMe.Designer/ViewModels/DesignerViewModel.cs

@@ -864,21 +864,70 @@ public sealed class DesignerViewModel : ViewModelBase
         var result = new List<ControlViewModel>();
         foreach (var page in Pages)
         {
-            foreach (var vm in page.Controls)
-            {
-                if (vm.Model.Hidden || vm.Model.Locked)
-                {
-                    continue;
-                }
-                if (worldRect.IntersectsWith(WorldBoundsOf(vm)))
-                {
-                    result.Add(vm);
-                }
-            }
+            CollectIntersecting(page.Controls, worldRect, result);
         }
         return result;
     }
 
+    /// <summary>
+    /// 마퀴에 걸리는 것을 모은다 — <b>컨테이너 안에 그린 마퀴는 그 안의 것을 고른다</b>.
+    ///
+    /// 전에는 최상위만 훑어서, 패널 안 체크박스 5개를 한 번에 고르려고 패널 안쪽을 끌면
+    /// 패널만 잡히거나 아무것도 안 잡혔다 — 결국 Ctrl+클릭 반복이나 레이어 목록으로 우회했다.
+    /// 컨테이너 자식은 전체 컨트롤의 18.3%(실측 18,749/컨테이너 4,099개)라 드문 경우가 아니다.
+    ///
+    /// <b>규칙은 '담김'이다.</b> 마퀴가 컨테이너 사각형 <b>안에</b> 들어가 있으면
+    /// 사용자는 그 안의 것을 고르려는 것이다(내 상자가 패널보다 작으니까).
+    /// 걸치기만 하면 예전처럼 컨테이너 자체가 잡힌다 — 패널을 통째로 고르는 조작이 그대로 남는다.
+    /// 모드도 수정키도 없이 그린 모양만으로 갈리므로 예측할 수 있다.
+    /// </summary>
+    private void CollectIntersecting(IEnumerable<ControlViewModel> controls, Rect worldRect,
+        List<ControlViewModel> result)
+    {
+        foreach (var vm in controls)
+        {
+            if (vm.Model.Hidden || vm.Model.Locked)
+            {
+                continue;
+            }
+            var bounds = WorldBoundsOf(vm);
+            if (!worldRect.IntersectsWith(bounds))
+            {
+                continue;
+            }
+            if (vm is ContainerViewModel container && bounds.Contains(worldRect))
+            {
+                CollectIntersecting(container.Children, worldRect, result);
+                continue;
+            }
+            result.Add(vm);
+        }
+    }
+
+    /// <summary>
+    /// 마퀴가 최종적으로 고를 것 — 그룹은 통째로 넓히되 <b>컨테이너 자식은 그대로 둔다</b>.
+    ///
+    /// 클릭 선택은 <see cref="GroupMatesOf"/> 를 쓰는데 그것은 자식을 부모 컨테이너로 되돌린다
+    /// (패널 안의 것을 집으면 패널이 움직여야 하므로 옳다). 마퀴에 그것을 그대로 쓰면
+    /// 안쪽을 정확히 골라 놓고도 결과가 다시 패널 하나가 되어, 위 규칙이 아무 일도 하지 않는다.
+    /// </summary>
+    public List<ControlViewModel> MarqueeHits(Rect worldRect)
+    {
+        var hits = ControlsIntersecting(worldRect);
+        var result = new List<ControlViewModel>();
+        foreach (var vm in hits)
+        {
+            // 그룹(GroupId)은 페이지 최상위 개념이다 — 컨테이너 자식에는 붙지 않는다
+            if (vm.Parent is null && vm.Model.GroupId is not null)
+            {
+                result.AddRange(GroupMatesOf(vm));
+                continue;
+            }
+            result.Add(vm);
+        }
+        return result.Distinct().ToList();
+    }
+
     /// <summary>오버레이(선택 박스/핸들) 재계산</summary>
     public void RefreshOverlay()
     {
@@ -2611,6 +2660,19 @@ public sealed class DesignerViewModel : ViewModelBase
             => total.TryGetValue(id, out var t) && t > 0
                && selected.TryGetValue(id, out var s) && s == t;
 
+        // 조상 중에 '선택된 컨테이너'가 있는가 — 선택한 패널의 <b>범위</b>를 목록에 그리기 위한 판정
+        static bool HasSelectedContainerAncestor(ControlViewModel viewModel)
+        {
+            for (var parent = viewModel.Parent; parent is not null; parent = parent.Parent)
+            {
+                if (parent.IsSelected)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         var states = new LayerHighlight[LayerRows.Count];
         for (var i = 0; i < LayerRows.Count; i++)
         {
@@ -2620,6 +2682,12 @@ public sealed class DesignerViewModel : ViewModelBase
                 ControlViewModel c when c.Model.GroupId is { } gid && GroupFullySelected(gid) => LayerHighlight.Navy,
                 ControlViewModel c when c.IsSelected => LayerHighlight.Blue,
                 LayerGroupViewModel g when GroupFullySelected(g.GroupId) => LayerHighlight.Blue,
+                // 선택한 컨테이너 안에 있는 것 — 그룹 판정보다 <b>뒤에</b> 둔다(그룹 색을 이기면 안 된다).
+                //
+                // 캔버스에서 패널을 끌면 자식이 전부 따라 움직이는데 목록은 그 사실을 말하지 않았다.
+                // 밴드가 붙으면 "이걸 지우면 무엇이 같이 지워지나"가 선택 즉시 보인다 —
+                // 접었다 펴 보지 않아도 된다.
+                ControlViewModel c when HasSelectedContainerAncestor(c) => LayerHighlight.Navy,
                 _ => LayerHighlight.None,
             };
         }
@@ -2712,6 +2780,46 @@ public sealed class DesignerViewModel : ViewModelBase
 
     /// <summary>페이지 펼침 상태 — 기본은 펼침. 키를 인덱스가 아니라 <b>페이지 인스턴스</b>로 잡는다
     /// (인덱스로 잡으면 페이지를 중간에 끼우거나 지웠을 때 엉뚱한 페이지가 접힌다)</summary>
+    /// <summary>
+    /// 이 컨트롤의 행이 목록에 <b>나타나도록</b> 조상을 전부 편다 — 실제로 편 것이 있으면 true.
+    ///
+    /// <b>왜 필요한가.</b> 접기는 레이어 목록만의 개념이라 캔버스에는 자식이 그대로 보인다.
+    /// 그래서 종이 한가운데 컨트롤을 클릭했는데 그 조상이 접혀 있으면
+    /// 목록에는 <b>행 자체가 없어</b> 아무 반응이 없다 — 사용자 눈에는 선택이 안 된 것으로 보이고,
+    /// 캔버스와 목록 중 어느 쪽이 맞는지 판단할 단서를 잃는다.
+    /// 접기·검색·그룹을 쓸수록 어긋나므로, 기존 기능이 오히려 신뢰를 깎고 있었다.
+    ///
+    /// 반대 방향(목록 더블클릭 → 캔버스로 스크롤)은 <see cref="RevealControl"/> 로 이미 있다 —
+    /// 이것은 <b>그 역방향을 잇는 일</b>이지 새 기능이 아니다.
+    /// </summary>
+    public bool ExpandLayerPathTo(ControlViewModel viewModel)
+    {
+        var changed = false;
+
+        // 페이지 마디 — 공개 메서드를 쓴다(목록 재구성 요청까지 함께 도는 경로다)
+        if (PageOf(viewModel) is { } page && !IsPageExpanded(page))
+        {
+            SetPageExpanded(page, true);
+            changed = true;
+        }
+        // 그룹 폴더 — 그룹 멤버는 폴더가 접히면 행이 안 만들어진다
+        if (viewModel.Model.GroupId is { } groupId && !IsGroupExpanded(groupId))
+        {
+            SetGroupExpanded(groupId, true);
+            changed = true;
+        }
+        // 컨테이너 조상 — 자기 자신은 펴지 않는다(자기 행은 이미 있다)
+        for (var parent = viewModel.Parent; parent is not null; parent = parent.Parent)
+        {
+            if (!parent.IsLayerExpanded)
+            {
+                parent.IsLayerExpanded = true;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+
     public bool IsPageExpanded(PageViewModel page) => !collapsedPages.Contains(page);
 
     /// <summary>페이지 펼침/접기</summary>

src/SheetMe.Designer/ViewModels/Inspector/InspectorViewModel.cs

@@ -918,13 +918,21 @@ public sealed class InspectorViewModel : ViewModelBase
             PropEditorKind.DataInterfaceTag => new TagPickerRowViewModel(def.Label,
                 "데이터 태그 선택 — 자동 채움 원천(bzDataInterface)", LegacyTagCatalog.DataInterfaceTags,
                 LegacyTagUsageCatalog.SuggestFor(def.Key, controlType)),
+            // 액션은 값이 아니라 동작이다 — 피커가 데이터 태그용 값·사유 칸을 그리면 안 된다
             PropEditorKind.DataActionTag => new TagPickerRowViewModel(def.Label,
                 "액션 태그 선택 — 더블클릭/버튼 액션(EN_DataActionTyp)", LegacyTagCatalog.DataActionTags,
-                LegacyTagUsageCatalog.SuggestFor(def.Key, controlType)),
-            PropEditorKind.SqlQuery => new QueryRowViewModel(def.Label),
+                LegacyTagUsageCatalog.SuggestFor(def.Key, controlType)) { IsActionTag = true },
+            // 컨트롤 이름을 넘긴다 — 안 넘기면 인스펙터로 연 편집기에서만 《컨트롤명》 칩이 사라져
+            // 같은 창이 진입 경로에 따라 능력이 달라진다
+            PropEditorKind.SqlQuery => new QueryRowViewModel(def.Label) { ControlNamesOf = ControlNames },
             PropEditorKind.Mask => new MaskRowViewModel(def.Label),
             // 배선 대상 목록은 '지금 이 서식'의 데이터소스다 — 런타임도 같은 서식 안에서만 이름을 찾는다
-            PropEditorKind.DataTableField => new DataTableFieldRowViewModel(def.Label, DataTableNames),
+            PropEditorKind.DataTableField => new DataTableFieldRowViewModel(def.Label, DataTableNames)
+            {
+                // 컬럼 목록과 대상 컨트롤 이름도 함께 준다 — 창이 사용자를 밖으로 내보내지 않게 한다
+                OwnerLabelOf = () => designer.Selection.Primary?.Id ?? string.Empty,
+                ColumnsOf = DataSourceColumns,
+            },
             _ => new TextRowViewModel(def.Label),
         };
         // 선의 방향·굵기는 값만 바꾸는 것이 아니라 <b>크기까지</b> 바꾼다(ApplyLineChange).
@@ -952,6 +960,67 @@ public sealed class InspectorViewModel : ViewModelBase
     /// 레거시 편집기는 열려 있는 <b>모든</b> 디자인 서피스를 훑어 다른 서식의 데이터소스까지 섞어 보여 주고,
     /// 그걸 고르면 런타임에 조용히 실패한다(bzMDataTableField.vb:18-63). 우리는 현재 문서로 한정한다.
     /// </summary>
+    /// <summary>
+    /// 이 서식의 모든 컨트롤 이름 — 쿼리 편집기의 《컨트롤명》 치환 후보다.
+    ///
+    /// 데이터소스 아이콘에서 편집기를 열면 이 목록이 넘어가는데 인스펙터의 쿼리 행에서는
+    /// 안 넘어가서, 같은 창이 진입 경로에 따라 능력이 달랐다.
+    /// </summary>
+    private IReadOnlyList<string> ControlNames()
+    {
+        var names = new List<string>();
+        void Visit(SheetMe.Core.Models.ControlElement element)
+        {
+            if (element.Id.Length > 0)
+            {
+                names.Add(element.Id);
+            }
+            foreach (var child in element.Children)
+            {
+                Visit(child);
+            }
+        }
+        foreach (var page in designer.Document.Pages)
+        {
+            foreach (var control in page.Controls)
+            {
+                Visit(control);
+            }
+        }
+        names.Sort(StringComparer.Ordinal);
+        return names;
+    }
+
+    /// <summary>
+    /// 데이터소스의 조회 결과 컬럼 이름 — 못 읽으면 null(미접속·쿼리 실패).
+    ///
+    /// 값 가져오기 창이 컬럼을 목록으로 보여 줄 수 있게 하는 재료다. 전에는 그 창이
+    /// "컬럼 후보는 목록으로 제시하지 않습니다" 라고 적어 두고 사용자를 밖으로 보냈는데,
+    /// 그 창은 모달이라 밖이 잠겨 있다 — 취소하고 쿼리를 열어 컬럼명을 외워 다시 와야 했다.
+    ///
+    /// 실행은 <see cref="Services.MDataTableRunner"/> 가 한다 — 접속·치환·캐시·실패 처리가
+    /// 이미 그 한 군데에 있고, 여기서 다시 만들면 두 벌이 된다.
+    /// 러너가 데이터소스별로 결과를 캐시하므로 창이 여러 번 물어도 조회는 한 번이다.
+    /// </summary>
+    private IReadOnlyList<string>? DataSourceColumns(string name)
+    {
+        try
+        {
+            var patient = Services.PatientSession.Current;
+            var runner = new Services.MDataTableRunner(designer.Document,
+                patient is null ? null
+                    : new Services.PatientQueryVariableSource(patient, Services.UserSession.Current.UidCod));
+            var result = runner.Run(name);
+            return result.Ok && result.Columns.Count > 0 ? result.Columns : null;
+        }
+        catch
+        {
+            // 컬럼 목록은 <b>도움</b>이다 — 못 읽는다고 창이 안 열려서는 안 된다.
+            // 창은 null 을 받으면 이유를 적고 직접 입력 칸을 남긴다.
+            return null;
+        }
+    }
+
     private IReadOnlyList<string> DataTableNames()
     {
         var names = new List<string>();

src/SheetMe.Designer/ViewModels/Inspector/PropertyRows.cs

@@ -503,6 +503,29 @@ public sealed class TagPickerRowViewModel : PropertyRowViewModel
     /// <summary>피커 대화상자 제목</summary>
     public string PickerTitle { get; }
 
+    /// <summary>
+    /// 액션 태그 행인가 — 액션은 <b>값이 아니라 동작</b>이라 피커의 값·사유 칸 뜻이 다르다.
+    /// 데이터 태그용 문구를 그대로 쓰면 149종 전부에서 그 칸이 거짓이 된다.
+    /// </summary>
+    public bool IsActionTag { get; init; }
+
+    /// <summary>
+    /// 카탈로그에 없는 이름인가 — <b>값은 건드리지 않고</b> 표식만 낸다.
+    ///
+    /// 인라인 완성으로 직접 치는 것이 이 행의 주 경로인데 거기에는 검증이 하나도 없었다.
+    /// 'PAT_이룸' 처럼 한 글자 틀리면 아무 표시 없이 커밋되고, 그 사실은 미리보기에서
+    /// <b>빈칸</b>으로만 드러난다 — 빈칸의 원인이 오타인지 이 환자에게 자료가 없어서인지 가릴 수 없다.
+    ///
+    /// 막지는 않는다. 사이트마다 카탈로그에 없는 커스텀 태그를 쓰기 때문이다(글꼴 행과 같은 규칙).
+    /// </summary>
+    public bool IsUnknownTag => !IsMixed && ValueText.Length > 0
+        && !string.Equals(ValueText, "None", StringComparison.Ordinal)
+        && !Choices.Contains(ValueText, StringComparer.Ordinal);
+
+    /// <summary>경고 문구 — 툴팁으로 보인다</summary>
+    public string UnknownTagHint => $"'{ValueText}' 은(는) 카탈로그에 없는 이름입니다. "
+        + "사이트 전용 태그면 그대로 두고, 오타면 고치세요 — 값이 안 나오면 종이에서 빈칸이 됩니다.";
+
     /// <summary>
     /// 한 줄에 하나꼴로 접히는 긴 한글 태그를 몇 개까지 깔지.
     /// 인스펙터 폭이 좁아 칩이 세로로 쌓인다 — 8개를 넘기면 다른 속성이 화면 밖으로 밀린다.
@@ -676,13 +699,16 @@ public sealed class TagPickerRowViewModel : PropertyRowViewModel
             if (e.PropertyName == nameof(ValueText))
             {
                 OnPropertyChanged(nameof(ShowSuggestions));
+                // 값이 바뀌면 '카탈로그에 없음' 표식도 다시 판정한다
+                OnPropertyChanged(nameof(IsUnknownTag));
+                OnPropertyChanged(nameof(UnknownTagHint));
             }
         };
     }
 
     private void OnBrowse()
     {
-        var dialog = new Views.TagPickerDialogView(PickerTitle, Choices, ValueText, preferredAll)
+        var dialog = new Views.TagPickerDialogView(PickerTitle, Choices, ValueText, preferredAll, IsActionTag)
         {
             Owner = System.Windows.Application.Current.MainWindow,
         };
@@ -756,9 +782,20 @@ public sealed class QueryRowViewModel : PropertyRowViewModel
 
     protected override void OnValueApplied() => OnPropertyChanged(nameof(Summary));
 
+    /// <summary>
+    /// 이 서식의 컨트롤 이름 — 편집기의 《컨트롤명》 치환 후보가 된다.
+    ///
+    /// 안 넘기면 <b>같은 창이 진입 경로에 따라 능력이 달라진다</b> —
+    /// 데이터소스 아이콘에서 열면 컨트롤 변수 칩이 나오는데
+    /// 인스펙터의 쿼리 행에서 열면 그 칩이 통째로 사라졌다.
+    /// 목록은 문서마다 다르므로 카탈로그가 아니라 호출부가 준다.
+    /// </summary>
+    public Func<IReadOnlyList<string>>? ControlNamesOf { get; init; }
+
     private void OnEdit()
     {
-        var dialog = new Views.QueryEditorWindow(Label, ValueText)
+        var dialog = new Views.QueryEditorWindow(Label, ValueText,
+            showVariables: true, controlNames: ControlNamesOf?.Invoke())
         {
             Owner = System.Windows.Application.Current.MainWindow,
         };
@@ -931,7 +968,12 @@ public sealed class DataTableFieldRowViewModel : PropertyRowViewModel
 {
     private readonly Func<IReadOnlyList<string>> tablesOf;
 
-    /// <summary>사람이 읽는 요약 — 배선이 없으면 안내 문구</summary>
+    /// <summary>
+    /// 사람이 읽는 요약. <b>'배선' 이라는 낱말을 쓰지 않는다</b> —
+    /// 전산실에서 배선은 랜선·전원이고, '배선 없음' 은 데이터소스가 없는 것처럼 읽힌다.
+    /// 빈 상태 문구는 대화상자의 지우기 버튼과 <b>글자까지 같게</b> 둔다 —
+    /// 그 버튼을 누르면 무엇이 되는지 미리 보이게 하려는 것이다.
+    /// </summary>
     public string Summary
     {
         get
@@ -942,19 +984,40 @@ public sealed class DataTableFieldRowViewModel : PropertyRowViewModel
             }
             if (ValueText.Length == 0)
             {
-                return "(배선 없음)";
+                return "(가져오지 않음)";
             }
             var spec = SheetMe.Core.Catalog.DataTableFieldSpec.Parse(ValueText);
             return spec is null
                 // 해석 못 하는 값은 원문을 그대로 보여 준다 — 조용히 고쳐 쓰지 않는다
                 ? $"⚠ 형식을 알 수 없음: {ValueText}"
-                : $"{spec.TableName} · {spec.Field}" + (spec.RowIndex == 0 ? string.Empty : $" · {spec.RowIndex}행");
+                // 행 0 은 '첫 행' 이다. 그 밖은 사람이 세는 번호(0 → 1번째)로 적는다.
+                // 조건이 있으면 그 사실을 덧붙인다 — 조건이 화면 어디에도 안 보인 채
+                // 결과를 바꾸는 상태를 남기지 않는다.
+                : $"{spec.TableName} · {spec.Field}"
+                    + (spec.RowIndex == 0 ? string.Empty : $" · {spec.RowIndex + 1}번째 행")
+                    + (spec.Form == SheetMe.Core.Catalog.DataTableFieldForm.Select && spec.Filter.Length > 0
+                        ? " · 조건 있음" : string.Empty);
         }
     }
 
     /// <summary>편집기 열기</summary>
     public M.Framework.WPF.ICustomCommand? EditCommand { get; set; }
 
+    /// <summary>
+    /// 대상 컨트롤 이름 — 창 제목에 넣는다. 모달이라 인스펙터가 가려져서,
+    /// 여러 칸을 연달아 채울 때 지금 어느 칸 차례인지 알 방법이 없었다.
+    /// </summary>
+    public Func<string>? OwnerLabelOf { get; init; }
+
+    /// <summary>
+    /// 데이터소스 이름 → 그 조회 결과의 컬럼 이름(없으면 null).
+    ///
+    /// 전에는 창이 '컬럼 후보는 목록으로 제시하지 않습니다' 라고 적어 두고 사용자를 밖으로 보냈는데,
+    /// 그 창은 모달이라 밖이 잠겨 있다 — 취소하고 쿼리를 열어 컬럼명을 외워 다시 와야 했다.
+    /// 실행은 이 행이 하지 않는다(호출부가 이미 만들어 둔 러너를 함수로 받는다).
+    /// </summary>
+    public Func<string, IReadOnlyList<string>?>? ColumnsOf { get; init; }
+
     public DataTableFieldRowViewModel(string label, Func<IReadOnlyList<string>> tablesOf) : base(label)
     {
         this.tablesOf = tablesOf;
@@ -970,7 +1033,8 @@ public sealed class DataTableFieldRowViewModel : PropertyRowViewModel
 
     private void OnEdit()
     {
-        var dialog = new Views.DataTableFieldDialogView(ValueText, tablesOf())
+        var dialog = new Views.DataTableFieldDialogView(ValueText, tablesOf(),
+            OwnerLabelOf?.Invoke(), ColumnsOf)
         {
             Owner = System.Windows.Application.Current.MainWindow,
         };

src/SheetMe.Designer/ViewModels/SelectionOverlayViewModel.cs

@@ -116,6 +116,10 @@ public sealed class SelectionOverlayViewModel : ViewModelBase
     private double selW;
     private double selH;
     private bool showHandles;
+    private string dragBadgeText = string.Empty;
+    private bool showDragBadge;
+    private double dragBadgeX;
+    private double dragBadgeY;
     private bool hasMarquee;
     private double marX;
     private double marY;
@@ -189,6 +193,43 @@ public sealed class SelectionOverlayViewModel : ViewModelBase
     /// <summary>탭순서 배지 목록(탭순서 편집 모드 전용)</summary>
     public ObservableCollection<TabBadgeInfo> TabBadges { get; } = new();
 
+    /// <summary>
+    /// 끄는 동안 보여 주는 치수·좌표 — <b>드래그 중에만</b> 있다.
+    ///
+    /// 전에는 숫자가 300px 떨어진 인스펙터에만 떴다. 라벨 폭을 종이 칸에 맞추려면
+    /// 끌고, 손 떼고, 오른쪽을 보고, 다시 끄는 왕복이 붙었다.
+    /// 간격 수치 칩은 <b>균등 스냅이 성립하는 순간에만</b> 나타나므로
+    /// "지금 이게 몇 px 인가"는 드래그 중에 알 방법이 없었다.
+    /// </summary>
+    public string DragBadgeText { get => dragBadgeText; private set => SetProperty(ref dragBadgeText, value); }
+
+    /// <summary>치수 칩을 보일지</summary>
+    public bool ShowDragBadge { get => showDragBadge; private set => SetProperty(ref showDragBadge, value); }
+
+    /// <summary>치수 칩 X(월드) — 선택 상자 좌하단 바깥</summary>
+    public double DragBadgeX { get => dragBadgeX; private set => SetProperty(ref dragBadgeX, value); }
+
+    /// <summary>치수 칩 Y(월드)</summary>
+    public double DragBadgeY { get => dragBadgeY; private set => SetProperty(ref dragBadgeY, value); }
+
+    /// <summary>
+    /// 끄는 동안의 치수·좌표를 갱신한다 — 이동이면 좌표, 크기 조절이면 크기를 보여 준다.
+    /// 사용자가 지금 <b>바꾸고 있는 값</b>을 보여 주는 것이 요점이다.
+    /// </summary>
+    public void SetDragBadge(Rect bounds, bool resizing)
+    {
+        DragBadgeText = resizing
+            ? $"{Math.Round(bounds.Width)} × {Math.Round(bounds.Height)}"
+            : $"X {Math.Round(bounds.X)} · Y {Math.Round(bounds.Y)}";
+        // 선택 상자 <b>아래</b>에 둔다 — 위에 두면 위쪽으로 끌 때 커서가 칩을 밀고 다닌다
+        DragBadgeX = bounds.X;
+        DragBadgeY = bounds.Bottom + (6 * InverseZoom);
+        ShowDragBadge = true;
+    }
+
+    /// <summary>드래그가 끝났다 — 칩을 치운다</summary>
+    public void ClearDragBadge() => ShowDragBadge = false;
+
     /// <summary>
     /// 잠긴 컨트롤의 테두리 — <b>편집 크롬</b>이라 종이에는 그려지지 않는다.
     ///

src/SheetMe.Designer/Views/DataTableFieldDialogView.xaml

@@ -1,29 +1,58 @@
 <Window x:Class="SheetMe.Designer.Views.DataTableFieldDialogView"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="데이터 필드 배선" Width="560" Height="520"
+        Title="값 가져오기" Width="620" Height="560"
         WindowStartupLocation="CenterOwner" ShowInTaskbar="False"
         Style="{StaticResource ThemedDialogWindow}">
+    <!--
+        이 창은 "조회 결과의 한 칸을 이 컨트롤에 채우는" 설정이다.
+
+        <b>왜 다시 썼나.</b> 전에는 네 칸(형태·필터·행 번호·필드)이 같은 굵기로 나란히 있어서
+        넷 다 채워야 하는 것처럼 보였다. 정작 <b>필수는 둘</b>(데이터소스·컬럼)이고
+        그 둘이 화면에서 가장 눈에 안 띄는 자리에 있었다.
+        게다가 선언 순서 때문에 첫 Tab 정지점이 '배선 지우기' 라,
+        화면이 "무엇을 먼저 하나"의 답을 '지우기' 로 주고 있었다.
+
+        실사용 근거: 조건(필터)을 쓴 배선이 <b>0건</b>이고 행 번호는 98%가 0 이다.
+        그래서 그 둘은 접어 두고, 기본값이 아닐 때만 칩으로 드러낸다.
+    -->
     <DockPanel Margin="16">
-        <TextBlock DockPanel.Dock="Top" Foreground="{DynamicResource B.Muted}" TextWrapping="Wrap" Margin="0,0,0,10"
-                   Text="데이터소스(조회 결과)의 한 칸을 이 컨트롤에 꽂습니다. 형식이 어긋나면 런타임이 아무 경고 없이 값을 비워 두므로, 문법은 여기서 조립합니다."/>
+        <TextBlock DockPanel.Dock="Top" Foreground="{DynamicResource B.Muted}" TextWrapping="Wrap" Margin="0,0,0,12"
+                   Text="서식이 열릴 때 데이터소스가 받아 온 조회 결과에서 한 칸을 읽어 이 칸을 자동으로 채웁니다. 고를 것은 둘입니다 — ① 어느 데이터소스에서, ② 그 결과의 어느 컬럼을."/>
 
-        <!-- 아래쪽 버튼 -->
-        <StackPanel DockPanel.Dock="Bottom" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,12,0,0">
-            <Button Content="배선 지우기" Padding="12,4" Click="OnClear"/>
-            <Button x:Name="OkButton" Content="적용" Padding="18,4" Margin="8,0,0,0"
-                    Style="{StaticResource Primary}" Click="OnApply" IsDefault="True"/>
-            <Button Content="취소" Padding="18,4" Margin="8,0,0,0" IsCancel="True"/>
-        </StackPanel>
+        <!-- 아래쪽 버튼. '가져오지 않음' 은 왼쪽으로 떼어 확인·취소와 섞이지 않게 한다 -->
+        <DockPanel DockPanel.Dock="Bottom" Margin="0,12,0,0" LastChildFill="False">
+            <Button DockPanel.Dock="Left" Content="가져오지 않음" Padding="12,4" Click="OnClear"
+                    ToolTip="이 칸을 자동으로 채우지 않습니다 — 데이터소스나 쿼리는 지워지지 않습니다"/>
+            <StackPanel DockPanel.Dock="Right" Orientation="Horizontal">
+                <Button x:Name="OkButton" Content="확인" Padding="18,4"
+                        Style="{StaticResource Primary}" Click="OnApply" IsDefault="True"/>
+                <Button Content="취소" Padding="18,4" Margin="8,0,0,0" IsCancel="True"/>
+            </StackPanel>
+        </DockPanel>
 
-        <!-- 조립 결과 미리보기 + 검증 메시지 -->
+        <!-- 사람 말 한 줄 + 접힌 저장 형식 -->
         <Border DockPanel.Dock="Bottom" Margin="0,12,0,0" Padding="10,8" CornerRadius="6"
                 Background="{DynamicResource B.Input}" BorderBrush="{DynamicResource B.InputBorder}" BorderThickness="1">
             <StackPanel>
-                <TextBlock Text="저장될 값" FontSize="10.5" Foreground="{DynamicResource B.Muted}"/>
-                <TextBlock x:Name="PreviewText" FontFamily="Consolas" FontSize="12" TextWrapping="Wrap" Margin="0,3,0,0"/>
+                <TextBlock x:Name="PlainText" TextWrapping="Wrap" FontSize="12.5"/>
                 <TextBlock x:Name="ProblemText" FontSize="11" TextWrapping="Wrap" Margin="0,5,0,0"
                            Foreground="{DynamicResource B.Danger}" Visibility="Collapsed"/>
+                <!--
+                    저장 원문을 없애지 않고 접어 둔다. 인스펙터 툴팁·진단 덤프·레거시 문서가
+                    전부 이 표기로 이야기되므로 원문을 들고 온 사람이 대조할 자리가 있어야 한다.
+                    다만 큰 자리를 주면 창이 '문법 조립하는 곳' 으로 스스로를 재정의한다 —
+                    아무것도 안 고른 상태의 첫 표시가 마침표로 시작하는 것도 그 탓이었다.
+                -->
+                <Expander x:Name="RawExpander" Margin="0,6,0,0" Header="저장 형식">
+                    <DockPanel Margin="0,4,0,0">
+                        <Button DockPanel.Dock="Right" Content="복사" Padding="8,2" VerticalAlignment="Top"
+                                Margin="6,0,0,0" Click="OnCopyRaw"/>
+                        <TextBlock x:Name="RawText" FontFamily="Consolas" FontSize="11.5" TextWrapping="Wrap"
+                                   Foreground="{DynamicResource B.Muted}"
+                                   ToolTip="레거시 XML 에 이 글자 그대로 들어갑니다"/>
+                    </DockPanel>
+                </Expander>
             </StackPanel>
         </Border>
 
@@ -34,39 +63,67 @@
                 <ColumnDefinition Width="*"/>
             </Grid.ColumnDefinitions>
 
-            <!-- 데이터소스 -->
+            <!-- ① 데이터소스 -->
             <DockPanel Grid.Column="0">
-                <TextBlock DockPanel.Dock="Top" Text="데이터소스" Margin="0,0,0,4"/>
+                <TextBlock DockPanel.Dock="Top" Text="① 가져올 데이터소스" FontWeight="SemiBold" Margin="0,0,0,4"/>
                 <TextBlock x:Name="NoTableHint" DockPanel.Dock="Bottom" FontSize="11" TextWrapping="Wrap"
                            Margin="0,6,0,0" Foreground="{DynamicResource B.Warning}" Visibility="Collapsed"
                            Text="이 서식에 데이터소스가 없습니다. 팔레트에서 '데이터소스'를 먼저 놓고 쿼리를 지정하세요."/>
-                <ListBox x:Name="TableList" SelectionChanged="OnFormChanged" FontSize="12.5"/>
+                <!-- 도움말은 라벨 바로 아래다. Bottom 에 두면 목록이 열을 채워
+                     설명이 목록에서 한참 떨어진 빈 공간에 떠 있었다. -->
+                <TextBlock DockPanel.Dock="Top" FontSize="11" TextWrapping="Wrap" Margin="0,0,0,6"
+                           Foreground="{DynamicResource B.Muted}"
+                           Text="이 서식에 놓아 둔 조회 상자입니다 — 목록에서만 고릅니다."/>
+                <ListBox x:Name="TableList" SelectionChanged="OnTableChanged" FontSize="12.5"/>
             </DockPanel>
 
-            <!-- 나머지 조각 -->
-            <StackPanel Grid.Column="2">
-                <TextBlock Text="형태" Margin="0,0,0,4"/>
-                <ComboBox x:Name="FormBox" SelectionChanged="OnFormChanged"
-                          ToolTip="Select 형은 레거시 편집기가 만드는 형태, Rows 형은 손으로 쓰던 형태입니다. 연 값의 형태를 그대로 유지합니다.">
-                    <ComboBoxItem Content="Select — 필터로 행을 고름"/>
-                    <ComboBoxItem Content="Rows — 행 번호로 직접"/>
-                </ComboBox>
+            <!-- ② 컬럼 + ③ 접힌 행 고르기 -->
+            <DockPanel Grid.Column="2">
+                <TextBlock DockPanel.Dock="Top" Text="② 가져올 컬럼" FontWeight="SemiBold" Margin="0,0,0,4"/>
+                <TextBox x:Name="FieldBox" DockPanel.Dock="Top" TextChanged="OnFormChanged"/>
+                <TextBlock x:Name="FieldHint" DockPanel.Dock="Top" FontSize="11" TextWrapping="Wrap" Margin="0,6,0,0"
+                           Foreground="{DynamicResource B.Muted}"/>
 
-                <TextBlock x:Name="FilterLabel" Text="필터" Margin="0,10,0,4"/>
-                <TextBox x:Name="FilterBox" TextChanged="OnFormChanged"
-                         ToolTip="DataTable.Select 문법 (예: CODCOD='A'). 비워 두면 전체 행입니다. 큰따옴표는 쓸 수 없습니다."/>
+                <!--
+                    ③ 은 접어 둔다. 조건을 쓴 실사용 배선이 0건이고 행 번호는 98%가 0 이라,
+                    첫 방문자가 평생 안 쓸 개념을 먼저 보게 할 이유가 없다.
+                    기본값이 아닐 때만 머리에 칩을 띄워 접혀 있어도 숨지 않게 한다.
+                -->
+                <Expander x:Name="RowExpander" DockPanel.Dock="Top" Margin="0,14,0,0">
+                    <Expander.Header>
+                        <StackPanel Orientation="Horizontal">
+                            <TextBlock Text="③ 여러 행 중에서 고르기"/>
+                            <Border x:Name="RowChip" Margin="8,0,0,0" Padding="6,1" CornerRadius="3"
+                                    Background="{DynamicResource B.Chip}" Visibility="Collapsed">
+                                <TextBlock x:Name="RowChipText" FontSize="10.5"
+                                           Foreground="{DynamicResource B.Muted}"/>
+                            </Border>
+                        </StackPanel>
+                    </Expander.Header>
+                    <StackPanel Margin="0,8,0,0">
+                        <TextBlock Text="몇 번째 행" Margin="0,0,0,4"/>
+                        <TextBox x:Name="RowBox" TextChanged="OnFormChanged"/>
+                        <TextBlock FontSize="11" TextWrapping="Wrap" Margin="0,4,0,0"
+                                   Foreground="{DynamicResource B.Muted}"
+                                   Text="첫 행이 0 입니다. 1 은 두 번째 행입니다. 반각 숫자만 됩니다."/>
 
-                <TextBlock Text="행 번호" Margin="0,10,0,4"/>
-                <TextBox x:Name="RowBox" TextChanged="OnFormChanged" ToolTip="0부터 셉니다"/>
-
-                <TextBlock Text="필드" Margin="0,10,0,4"/>
-                <TextBox x:Name="FieldBox" TextChanged="OnFormChanged"
-                         ToolTip="조회 결과의 컬럼명. SQL 별칭 표현식도 됩니다 (예: A||'-'||B). 큰따옴표는 쓸 수 없습니다."/>
-
-                <TextBlock x:Name="FieldHint" FontSize="11" TextWrapping="Wrap" Margin="0,6,0,0"
-                           Foreground="{DynamicResource B.Muted}"
-                           Text="필드 후보는 쿼리를 실행해야 알 수 있어 목록으로 제시하지 않습니다. 데이터소스의 쿼리를 열어 컬럼명을 확인하세요."/>
-            </StackPanel>
+                        <!--
+                            조건은 저장된 값이 조건 형태일 때만 보인다. 새로 만들 때는 아예 안 보인다 —
+                            실사용에서 조건을 쓴 배선이 0건이고, 이 문법은 SQL WHERE 가 아니라
+                            이미 받아 온 표를 거르는 식이라 NVL·TO_CHAR·|| 가 통하지 않는다.
+                        -->
+                        <StackPanel x:Name="FilterArea" Visibility="Collapsed">
+                            <TextBlock Text="행 조건" Margin="0,12,0,4"/>
+                            <TextBox x:Name="FilterBox" TextChanged="OnFormChanged"/>
+                            <TextBlock FontSize="11" TextWrapping="Wrap" Margin="0,4,0,0"
+                                       Foreground="{DynamicResource B.Muted}"
+                                       Text="이 배선은 조건으로 행을 고르게 저장돼 있습니다. SQL 의 WHERE 가 아니라 받아 온 표를 거르는 식입니다 — 되는 예 CODCOD='A' · 안 되는 예 NVL, TO_CHAR, ||"/>
+                            <Button x:Name="DropFilterButton" Content="조건을 버리고 순서대로 고르기"
+                                    Margin="0,8,0,0" Padding="10,3" Click="OnDropFilter"/>
+                        </StackPanel>
+                    </StackPanel>
+                </Expander>
+            </DockPanel>
         </Grid>
     </DockPanel>
 </Window>

src/SheetMe.Designer/Views/DataTableFieldDialogView.xaml.cs

@@ -6,30 +6,74 @@ using SheetMe.Core.Catalog;
 namespace SheetMe.Designer.Views;
 
 /// <summary>
-/// DataTableField 전용 편집기 — 문법 골격을 코드가 조립하고, 저장 전에 검사한다.
+/// 조회 결과의 한 칸을 컨트롤에 채우는 설정 — 문법 골격을 코드가 조립하고 저장 전에 검사한다.
 ///
 /// 레거시 편집기와 다르게 <b>기존 값을 되읽어 채운다</b>. 레거시는 열 때마다 백지에서 시작해
 /// 한 조각만 고치려 해도 전부 다시 골라야 했다(fmMDataTableField.InitializeSelectedData).
-/// 형태(Select/Rows)도 연 값 그대로 유지한다 — 운영 다수는 Rows 형이고(1,624건, 76%),
-/// 형태를 바꾸면 그 형태만 이해하는 보조 로더에서 동작이 달라질 수 있다.
+///
+/// <b>새 배선은 Rows 형이다.</b> 전에는 레거시 편집기와 같은 Select 형으로 시작했는데,
+/// 그러면 첫 화면이 굳이 <b>조건을 요구하는 어려운 쪽</b>이 된다.
+/// 동작은 같다 — 조건이 비면 <c>Select("")(0)</c> 과 <c>Rows(0)</c> 이 같은 행을 가리키고,
+/// 해석기 자신이 그 등가를 코드로 인정한다(DataTableFieldPicker 는 조건이 비어 있으면
+/// 필터 경로를 아예 타지 않는다). 실사용에서 조건을 쓴 배선은 <b>0건</b>이다.
+///
+/// <b>기존 값의 형태는 그대로 유지한다</b> — 저장된 원문을 우리가 바꾸지 않는 것이
+/// XML 왕복 무손실의 조건이다. Select→Rows 전환은 조건을 버리는 일이라
+/// 명시적 버튼으로만 하고, 버려지는 조건 원문을 확인 문구에 적어 보여 준다.
 /// </summary>
 public partial class DataTableFieldDialogView : Window
 {
     #region Member Fields
     private readonly IReadOnlyList<string> tables;
+
+    /// <summary>
+    /// 데이터소스 이름 → 그 조회 결과의 컬럼 이름. 없으면 null(오프라인·미접속).
+    ///
+    /// <b>여기가 이 창의 유일한 작업 포기 지점이었다.</b> 전에는 "필드 후보는 쿼리를 실행해야
+    /// 알 수 있어 목록으로 제시하지 않습니다" 라고 적어 두고 사용자를 창 밖으로 보냈는데,
+    /// 이 창은 모달이라 밖이 잠겨 있다 — 취소 → 데이터소스 찾기 → 쿼리 편집기 → 검증 실행 →
+    /// 컬럼명 외우기 → 다시 열기. 레거시 편집기는 이 목록을 이미 보여 줬으므로 그 문구는
+    /// 퇴행을 설명하는 문장이었다.
+    ///
+    /// 실행 자체는 이 창이 하지 않는다 — 호출부가 이미 만들어 둔 러너를 함수로 감싸 넘긴다.
+    /// 그래야 접속·캐시·실패 처리가 한 군데(MDataTableRunner)에만 있다.
+    /// </summary>
+    private readonly Func<string, IReadOnlyList<string>?>? columnsOf;
+
+    /// <summary>
+    /// 데이터소스별 컬럼 캐시 — 이 창이 사는 동안 <b>데이터소스마다 한 번만</b> 묻는다.
+    /// Refresh 는 키 입력마다 도는데 그때마다 조회하면 타이핑이 끊긴다.
+    /// </summary>
+    private readonly Dictionary<string, IReadOnlyList<string>?> columnCache = new(StringComparer.Ordinal);
+
     private bool loading = true;
+
+    /// <summary>연 값의 형태 — 저장할 때 그대로 되돌려 쓴다(원문을 우리가 바꾸지 않는다)</summary>
+    private DataTableFieldForm form = DataTableFieldForm.Rows;
     #endregion
 
     #region Properties
-    /// <summary>적용 결과 — 취소면 null, '배선 지우기'면 빈 문자열</summary>
+    /// <summary>적용 결과 — 취소면 null, '가져오지 않음'이면 빈 문자열</summary>
     public string? Result { get; private set; }
     #endregion
 
     #region Constructors
-    public DataTableFieldDialogView(string? current, IReadOnlyList<string> dataTables)
+    /// <param name="current">지금 저장된 값 — 없으면 새 배선</param>
+    /// <param name="dataTables">이 서식의 데이터소스 이름</param>
+    /// <param name="ownerLabel">대상 컨트롤 이름 — 제목에 넣어 "지금 어느 칸 차례인지"를 알린다</param>
+    /// <param name="columnsOf">데이터소스의 컬럼 이름을 주는 함수(없으면 직접 입력만)</param>
+    public DataTableFieldDialogView(string? current, IReadOnlyList<string> dataTables,
+        string? ownerLabel = null, Func<string, IReadOnlyList<string>?>? columnsOf = null)
     {
         InitializeComponent();
         tables = dataTables;
+        this.columnsOf = columnsOf;
+
+        if (ownerLabel is { Length: > 0 })
+        {
+            // 모달이라 인스펙터가 가려진다 — 여러 칸을 연달아 채울 때 어느 칸 차례인지 알 수 없었다
+            Title = $"값 가져오기 — {ownerLabel}";
+        }
 
         foreach (var name in tables)
         {
@@ -40,16 +84,21 @@ public partial class DataTableFieldDialogView : Window
         var spec = DataTableFieldSpec.Parse(current);
         if (spec is not null)
         {
-            FormBox.SelectedIndex = spec.Form == DataTableFieldForm.Rows ? 1 : 0;
+            form = spec.Form;
             TableList.SelectedItem = tables.FirstOrDefault(t => string.Equals(t, spec.TableName, StringComparison.Ordinal));
             FilterBox.Text = spec.Filter;
             RowBox.Text = spec.RowIndex.ToString(CultureInfo.InvariantCulture);
             FieldBox.Text = spec.Field;
+            // 기본값이 아닌 것이 접혀 있으면 숨는다 — 그때만 펼친 채로 연다
+            if (spec.RowIndex != 0 || (form == DataTableFieldForm.Select && spec.Filter.Length > 0))
+            {
+                RowExpander.IsExpanded = true;
+            }
         }
         else
         {
-            // 새 배선 — 레거시 편집기와 같은 Select 형으로 시작한다
-            FormBox.SelectedIndex = 0;
+            // 새 배선 — 조건 없이 첫 행. 첫 화면에 평생 안 쓸 개념을 두지 않는다.
+            form = DataTableFieldForm.Rows;
             RowBox.Text = "0";
             if (tables.Count == 1)
             {
@@ -59,47 +108,134 @@ public partial class DataTableFieldDialogView : Window
 
         loading = false;
         Refresh();
+
+        // 첫 포커스 — 데이터소스가 이미 정해졌으면 다음 할 일(컬럼)로 보낸다.
+        // 이 호출이 없으면 선언 순서상 첫 Tab 정지점이 파괴적 버튼이었다.
+        Loaded += (_, _) =>
+        {
+            if (TableList.SelectedItem is null && TableList.Items.Count > 0)
+            {
+                TableList.Focus();
+            }
+            else
+            {
+                FieldBox.Focus();
+            }
+        };
     }
     #endregion
 
     #region Methods
     /// <summary>
-    /// 현재 입력을 명세로 옮긴다 — 행 번호는 숫자가 아니면 0 으로 본다
-    /// (레거시도 빈 값을 0 으로 강제한다: fmMDataTableField.vb:135).
+    /// 현재 입력을 명세로 옮긴다.
+    ///
+    /// <b>행 번호를 조용히 0 으로 바꾸지 않는다.</b> 전에는 파싱 실패가 그대로 0 이 됐는데,
+    /// 그러면 전각 '１' 을 넣은 배선이 아무 말 없이 첫 행을 가리킨다(실사용에 그런 값이 실재한다).
+    /// 잘못된 입력은 <see cref="Refresh"/> 가 이유를 말하고 확인을 막는다.
     /// </summary>
-    private DataTableFieldSpec CurrentSpec()
+    private DataTableFieldSpec CurrentSpec() => new()
     {
-        var row = int.TryParse(RowBox.Text.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsed)
-            ? parsed
-            : 0;
-        return new DataTableFieldSpec
+        Form = form,
+        TableName = TableList.SelectedItem as string ?? string.Empty,
+        Filter = form == DataTableFieldForm.Select ? FilterBox.Text : string.Empty,
+        RowIndex = ParsedRow() ?? 0,
+        Field = FieldBox.Text.Trim(),
+    };
+
+    /// <summary>행 번호 — 반각 숫자로 읽히지 않으면 null</summary>
+    private int? ParsedRow()
+    {
+        var text = RowBox.Text.Trim();
+        if (text.Length == 0)
         {
-            Form = FormBox.SelectedIndex == 1 ? DataTableFieldForm.Rows : DataTableFieldForm.Select,
-            TableName = TableList.SelectedItem as string ?? string.Empty,
-            Filter = FilterBox.Text,
-            RowIndex = row,
-            Field = FieldBox.Text.Trim(),
-        };
+            return 0; // 빈 값은 첫 행이다(레거시도 빈 값을 0 으로 본다)
+        }
+        return int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var parsed) ? parsed : null;
     }
 
     private void Refresh()
     {
+        // 조건 칸은 저장된 값이 조건 형태일 때만 보인다
+        FilterArea.Visibility = form == DataTableFieldForm.Select ? Visibility.Visible : Visibility.Collapsed;
+
         var spec = CurrentSpec();
-        var rowsForm = spec.Form == DataTableFieldForm.Rows;
+        RawText.Text = spec.Compose();
+        UpdateRowChip(spec);
+        UpdateFieldHint(spec.TableName);
 
-        // Rows 형은 필터를 아예 쓰지 않는다 — 켜 두면 입력해도 무시되는 칸이 된다
-        FilterBox.IsEnabled = !rowsForm;
-        FilterLabel.Opacity = rowsForm ? 0.45 : 1;
-        FilterBox.Opacity = rowsForm ? 0.45 : 1;
+        // 전각 숫자처럼 읽을 수 없는 행 번호는 <b>먼저</b> 말한다 — 조용히 0 으로 바꾸지 않는다
+        var problem = ParsedRow() is null
+            ? "몇 번째 행: 반각 숫자만 됩니다"
+            // 고를 데이터소스가 아예 없으면 '고르세요' 는 따를 수 없는 지시다 — 다음 행동을 말한다
+            : tables.Count == 0
+                ? "이 서식에 데이터소스가 없습니다 — 팔레트에서 먼저 놓고 쿼리를 지정하세요"
+                : spec.Validate(tables);
 
-        PreviewText.Text = spec.Compose();
-        var problem = spec.Validate(tables);
+        PlainText.Text = problem is null ? PlainSentence(spec) : "아직 가져올 값이 정해지지 않았습니다.";
         ProblemText.Text = problem ?? string.Empty;
         ProblemText.Visibility = problem is null ? Visibility.Collapsed : Visibility.Visible;
         // 레거시는 아무것도 안 고르고 확인하면 ")(" 같은 찌꺼기를 저장한다 — 그 경로를 막는다
         OkButton.IsEnabled = problem is null;
     }
 
+    /// <summary>사람 말 한 줄 — 이 창이 무엇을 하기로 했는지</summary>
+    private static string PlainSentence(DataTableFieldSpec spec)
+    {
+        var where = spec.RowIndex == 0 ? "첫 행" : $"{spec.RowIndex + 1}번째 행";
+        var scope = spec.Form == DataTableFieldForm.Select && spec.Filter.Length > 0
+            ? "조건을 통과한 행 중 " + where
+            : where;
+        return $"서식을 열면 — {spec.TableName} 조회 결과의 {scope}에서 "
+            + $"{spec.Field} 값을 가져와 이 칸에 넣습니다.";
+    }
+
+    /// <summary>접힌 ③ 의 머리 칩 — 기본값이 아니면 접혀 있어도 드러낸다</summary>
+    private void UpdateRowChip(DataTableFieldSpec spec)
+    {
+        var parts = new List<string>();
+        if (spec.RowIndex != 0)
+        {
+            parts.Add($"{spec.RowIndex + 1}번째 행");
+        }
+        if (spec.Form == DataTableFieldForm.Select && spec.Filter.Length > 0)
+        {
+            parts.Add("조건 있음");
+        }
+        RowChipText.Text = string.Join(" · ", parts);
+        RowChip.Visibility = parts.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    /// <summary>
+    /// 컬럼 칸 아래 안내 — 실제 컬럼 목록을 얻을 수 있으면 그것을 보여 준다.
+    /// 못 얻으면 <b>왜 못 얻는지</b>를 말한다(전에는 "목록으로 제시하지 않습니다"로 끝났다).
+    /// </summary>
+    private void UpdateFieldHint(string tableName)
+    {
+        if (tableName.Length == 0)
+        {
+            FieldHint.Text = "데이터소스를 먼저 고르면 그 조회 결과의 컬럼 이름을 보여 줍니다.";
+            return;
+        }
+        if (!columnCache.TryGetValue(tableName, out var columns))
+        {
+            columns = columnsOf?.Invoke(tableName);
+            columnCache[tableName] = columns;
+        }
+        if (columns is { Count: > 0 })
+        {
+            FieldHint.Text = $"{tableName} 의 컬럼 {columns.Count}개 — "
+                + string.Join(", ", columns.Take(12))
+                + (columns.Count > 12 ? " …" : string.Empty);
+            return;
+        }
+        // 못 읽었을 때도 <b>왜</b>인지 말한다. 전에는 "목록으로 제시하지 않습니다" 로 끝나
+        // 사용자가 무엇을 하면 되는지 알 수 없었다. 문구는 짧게 — 여기가 도움말 자리다.
+        FieldHint.Text = "컬럼 목록을 읽지 못했습니다(DB 미접속·쿼리 실패) — 직접 입력하세요."
+            + " 조회 결과 표의 머리글 이름이고 대개 전부 대문자입니다(예: ALB, ACPDTE).";
+    }
+
+    private void OnTableChanged(object sender, SelectionChangedEventArgs e) => OnFormChanged(sender, e);
+
     private void OnFormChanged(object sender, RoutedEventArgs e)
     {
         if (!loading)
@@ -108,8 +244,42 @@ public partial class DataTableFieldDialogView : Window
         }
     }
 
+    /// <summary>
+    /// 조건을 버리고 순서대로 고르기 — <b>되돌릴 수 없어</b> 버려지는 조건을 먼저 보여 준다.
+    ///
+    /// 전에는 형태 콤보를 바꾸는 것만으로 조건이 조립에서 조용히 사라졌고(Rows 조립은 Filter 를
+    /// 아예 쓰지 않는다) 다시 열면 Rows 해석에 조건 항목이 없어 영구히 없어졌다.
+    /// 화면은 칸을 흐리게만 해서 값이 살아 있는 것처럼 보였다.
+    /// </summary>
+    private void OnDropFilter(object sender, RoutedEventArgs e)
+    {
+        var filter = FilterBox.Text;
+        if (filter.Length > 0 && !Services.DialogService.Confirm("조건 버리기",
+            "이 배선의 행 조건을 지우고 순서대로 고르게 바꿉니다.",
+            $"지워지는 조건: {filter}\n확인을 누르면 되돌릴 수 없습니다.",
+            destructive: true, owner: this))
+        {
+            return;
+        }
+        form = DataTableFieldForm.Rows;
+        FilterBox.Text = string.Empty;
+        Refresh();
+    }
+
+    private void OnCopyRaw(object sender, RoutedEventArgs e)
+    {
+        if (RawText.Text is { Length: > 0 } raw)
+        {
+            Clipboard.SetText(raw);
+        }
+    }
+
     private void OnApply(object sender, RoutedEventArgs e)
     {
+        if (ParsedRow() is null)
+        {
+            return;
+        }
         var spec = CurrentSpec();
         if (spec.Validate(tables) is not null)
         {

src/SheetMe.Designer/Views/InspectorView.xaml

@@ -175,7 +175,8 @@
             (자르기보다 낫다 — 잘린 라벨은 툴팁을 띄워봐야 아는 정보가 된다).
         -->
         <Style x:Key="RowLabel" TargetType="TextBlock">
-            <Setter Property="Width" Value="72"/>
+            <!-- 위 주석이 92 를 논증해 놓고 값은 72 였다 — 그래서 '액션 대상 컨…' 처럼 잘렸다 -->
+            <Setter Property="Width" Value="92"/>
             <Setter Property="VerticalAlignment" Value="Center"/>
             <Setter Property="Foreground" Value="{DynamicResource B.Muted}"/>
             <Setter Property="FontSize" Value="12"/>
@@ -622,6 +623,16 @@
                     <Button DockPanel.Dock="Right" Width="28" Height="26" Padding="0" Margin="4,0,0,0"
                             Command="{Binding BrowseCommand}" ToolTip="전체 목록에서 선택"
                             Content="{Binding Source=list, Converter={StaticResource IconName}, ConverterParameter=13}"/>
+                    <!--
+                        카탈로그에 없는 이름 — 글꼴 행과 같은 규칙이다. 값은 건드리지 않고 표식만 낸다.
+                        인라인으로 직접 치는 것이 이 행의 주 경로인데 검증이 하나도 없어서,
+                        한 글자 틀려도 조용히 커밋되고 미리보기에서 <b>빈칸</b>으로만 드러났다 —
+                        빈칸의 원인이 오타인지 자료가 없어서인지 가릴 수 없었다.
+                    -->
+                    <TextBlock DockPanel.Dock="Right" Text="⚠" FontSize="13" VerticalAlignment="Center"
+                               Margin="4,0,0,0" Foreground="{DynamicResource B.Warning}"
+                               ToolTip="{Binding UnknownTagHint}"
+                               Visibility="{Binding IsUnknownTag, Converter={StaticResource BoolToVisibility}}"/>
                     <Grid>
                         <TextBox x:Name="TagInput" Style="{StaticResource RowInput}"
                                  bh:InspectorFieldBehavior.CommitOnEnter="True"
@@ -684,8 +695,15 @@
         <DataTemplate DataType="{x:Type ins:ReadOnlyRowViewModel}">
             <DockPanel Margin="0,2">
                 <TextBlock Text="{Binding Label}" Style="{StaticResource RowLabel}"/>
+                <!--
+                    이 자리는 값이 아니라 <b>설명</b>이다 — 자르면 결론이 사라진다.
+                    "타입이 달라 값의 뜻이 다른 속성 2개 — 타입별로 따로 고르세요" 에서
+                    지시에 해당하는 뒷부분이 잘려 나가 무엇을 하라는 건지 알 수 없었다.
+                    접어서 다 보여 주고, 그래도 좁으면 툴팁이 받는다.
+                -->
                 <TextBlock Text="{Binding ValueText}" FontSize="11" Foreground="{DynamicResource B.Muted}"
-                           VerticalAlignment="Center" TextTrimming="CharacterEllipsis"/>
+                           VerticalAlignment="Center" TextWrapping="Wrap"
+                           ToolTip="{Binding ValueText}"/>
             </DockPanel>
         </DataTemplate>
 
@@ -896,11 +914,11 @@
                 <ContentControl DockPanel.Dock="Left" Margin="0,0,7,0" VerticalAlignment="Center"
                                 IsTabStop="False" Focusable="False"
                                 Content="{Binding HeaderIcon, Converter={StaticResource IconName}, ConverterParameter=16|B.Muted}"/>
-                <Button DockPanel.Dock="Right" Width="24" Height="24" Padding="0"
-                        Style="{StaticResource Subtle}" ToolTip="이 컨트롤에 대한 명령"
-                        AutomationProperties.Name="더보기"
-                        Visibility="{Binding IsSingleSelection, Converter={StaticResource BoolToVisibility}}"
-                        Content="{Binding Source=ellipsis-vertical, Converter={StaticResource IconName}, ConverterParameter=14|B.Muted}"/>
+                <!--
+                    ⋮ 버튼을 지웠다. Command·Click·ContextMenu 가 <b>전부 없어</b> 눌러도 아무 일이 없었는데,
+                    툴팁은 '이 컨트롤에 대한 명령' 이라 '단일 선택일 때만 되는 뭔가가 있다'고 오해시켰다.
+                    없는 버튼보다 죽은 버튼이 나쁘다. 컨트롤 단위 명령은 캔버스 우클릭 메뉴에 다 있다.
+                -->
                 <TextBlock Text="{Binding HeaderName}" FontWeight="Bold" FontSize="12.5"
                            Foreground="{DynamicResource B.Ink}" VerticalAlignment="Center"
                            TextTrimming="CharacterEllipsis" ToolTip="{Binding Summary}"/>

src/SheetMe.Designer/Views/LayerPanelView.xaml

@@ -283,13 +283,41 @@
                                     <ToggleButton DockPanel.Dock="Right" Style="{StaticResource LayerRowToggle}"
                                                   IsChecked="{Binding IsHiddenFlag}" ToolTip="숨김"
                                                   Content="{Binding HiddenIconSpec, Converter={StaticResource IconSpec}}"/>
+                                    <!--
+                                        컨테이너의 자식 수 — 접혀 있어도 무엇이 딸려 있는지 보여야 한다.
+                                        페이지 행과 그룹 폴더에는 이미 개수가 붙는데 컨테이너만 없었다.
+                                        중첩까지 세므로 "이걸 지우면 몇 개가 같이 지워지나"가 그대로 읽힌다.
+                                    -->
+                                    <TextBlock DockPanel.Dock="Right" VerticalAlignment="Center" FontSize="11"
+                                               Margin="4,0,2,0" Text="{Binding LayerChildCountText}"
+                                               Visibility="{Binding HasLayerChildren, Converter={StaticResource BoolToVisibility}}">
+                                        <TextBlock.Style>
+                                            <Style TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
+                                                <Setter Property="Foreground" Value="{DynamicResource B.Muted}"/>
+                                                <Style.Triggers>
+                                                    <!-- 선택 밴드 위에서 B.Muted 는 1.03:1 — 개수가 통째로 사라진다 -->
+                                                    <DataTrigger Binding="{Binding Highlight}" Value="Blue">
+                                                        <Setter Property="Foreground" Value="{DynamicResource B.OnSelMuted}"/>
+                                                    </DataTrigger>
+                                                </Style.Triggers>
+                                            </Style>
+                                        </TextBlock.Style>
+                                    </TextBlock>
                                     <!-- 계층 들여쓰기: 페이지 직속 12, 그룹 멤버 32, 컨테이너 자식 +16 -->
                                     <Border DockPanel.Dock="Left" Width="{Binding LayerIndent}"/>
-                                    <!-- 컨테이너(패널/그룹박스)만 자식 접기 셰브론을 갖는다 -->
-                                    <ToggleButton DockPanel.Dock="Left" Style="{StaticResource MiniChevron}" Width="16"
-                                                  IsChecked="{Binding IsLayerExpanded}" ToolTip="자식 접기/펼치기"
-                                                  Visibility="{Binding HasLayerChildren, Converter={StaticResource BoolToVisibility}}"
-                                                  Content="{Binding LayerChevronSpec, Converter={StaticResource IconSpec}}"/>
+                                    <!--
+                                        컨테이너(패널/그룹박스)만 자식 접기 셰브론을 갖는다.
+                                        <b>없을 때도 16px 칸은 남긴다.</b> 전에는 셰브론이 Collapsed 로 사라져
+                                        폭 16 이 통째로 없어졌는데, 컨테이너 자식 들여쓰기도 정확히 16 이라
+                                        <b>부모와 자식의 아이콘이 같은 x 에 놓였다</b> — 목록만 보면 형제로 읽힌다.
+                                        계층을 나타내는 유일한 수단인 들여쓰기가 셰브론 폭에 정확히 상쇄되고 있었다.
+                                    -->
+                                    <Border DockPanel.Dock="Left" Width="16">
+                                        <ToggleButton Style="{StaticResource MiniChevron}" Width="16"
+                                                      IsChecked="{Binding IsLayerExpanded}" ToolTip="자식 접기/펼치기"
+                                                      Visibility="{Binding HasLayerChildren, Converter={StaticResource BoolToVisibility}}"
+                                                      Content="{Binding LayerChevronSpec, Converter={StaticResource IconSpec}}"/>
+                                    </Border>
                                     <ContentControl DockPanel.Dock="Left" Margin="0,0,7,0" VerticalAlignment="Center" IsTabStop="False"
                                                     Content="{Binding LayerIconSpec, Converter={StaticResource IconSpec}}"/>
                                     <!-- 데이터 배선 배지 — 값이 조회/데이터소스에서 오는 컨트롤 -->
@@ -321,10 +349,16 @@
                                                 </Style>
                                             </TextBlock.Style>
                                         </TextBlock>
-                                        <TextBlock Text="{Binding LayerId}" FontSize="10.5" Margin="0,1,0,0"
+                                        <!--
+                                            둘째 줄은 <b>항상</b> 있다 — 없으면 목록에 1줄 행과 2줄 행이 섞여
+                                            훑을 때 눈이 매번 자리를 다시 잡아야 한다.
+                                            타입명을 앞에 두는 이유: 아이콘만으로 안 갈리는 짝이 실제로 있다
+                                            (라벨·마스크입력이 같은 글리프, 리스트박스·체크리스트도 같다).
+                                            이름(Id)은 표시명과 다를 때만 뒤에 붙는다 — 외부 참조 키라 계속 보여야 한다.
+                                        -->
+                                        <TextBlock Text="{Binding LayerSubText}" FontSize="10.5" Margin="0,1,0,0"
                                                    TextTrimming="CharacterEllipsis"
-                                                   ToolTip="컨트롤 이름 — 다른 속성이 이 이름으로 참조합니다"
-                                                   Visibility="{Binding HasLayerId, Converter={StaticResource BoolToVisibility}}">
+                                                   ToolTip="{Binding LayerSubText}">
                                             <TextBlock.Style>
                                                 <Style TargetType="TextBlock" BasedOn="{StaticResource {x:Type TextBlock}}">
                                                     <Setter Property="Foreground" Value="{DynamicResource B.Muted}"/>

src/SheetMe.Designer/Views/PatientPickerDialogView.xaml

@@ -52,10 +52,10 @@
                 <TextBlock Text="기준 시점" VerticalAlignment="Center" Margin="0,0,6,0"
                            Foreground="{DynamicResource B.Muted}"
                            ToolTip="입원 내원은 구간이라 어느 시점의 진료과·병실·보험 자격을 쓸지 정해야 합니다. 외래는 접수일시로 같습니다."/>
-                <ComboBox x:Name="EdgeCombo" Width="92" SelectedIndex="0"
+                <ComboBox x:Name="EdgeCombo" Width="150" SelectedIndex="0"
                           AutomationProperties.Name="기준 시점">
-                    <ComboBoxItem Content="마지막"/>
-                    <ComboBoxItem Content="처음"/>
+                    <ComboBoxItem Content="마지막(퇴원 시점)"/>
+                    <ComboBoxItem Content="처음(입원 시점)"/>
                 </ComboBox>
                 <Button x:Name="SelectButton" Content="선택" Padding="20,4" Margin="10,0,0,0"
                         Click="OnSelect" IsDefault="True" IsEnabled="False"
@@ -132,12 +132,16 @@
                           AutomationProperties.Name="내원 목록">
                     <ListView.View>
                         <GridView>
-                            <GridViewColumn Header="구분" Width="52" DisplayMemberBinding="{Binding Kind}"/>
-                            <GridViewColumn Header="접수일시" Width="118" DisplayMemberBinding="{Binding AcceptedAtText}"/>
-                            <GridViewColumn Header="진료과" Width="100" DisplayMemberBinding="{Binding Department}"/>
-                            <GridViewColumn Header="담당의" Width="80" DisplayMemberBinding="{Binding Doctor}"/>
-                            <GridViewColumn Header="보험" Width="86" DisplayMemberBinding="{Binding Insurance}"/>
-                            <GridViewColumn Header="상태" Width="66" DisplayMemberBinding="{Binding State}"/>
+                            <GridViewColumn Header="구분" Width="46" DisplayMemberBinding="{Binding Kind}"/>
+                            <GridViewColumn Header="접수일시" Width="106" DisplayMemberBinding="{Binding AcceptedAtText}"/>
+                            <!-- 퇴원일시 — 이미 조회돼 있는데 화면에 없었다.
+                                 입원 내원이 '구간'이라는 사실이 이 열 하나로 눈에 보인다.
+                                 그래야 아래 기준 시점 선택이 무슨 뜻인지 알 수 있다. -->
+                            <GridViewColumn Header="퇴원일시" Width="106" DisplayMemberBinding="{Binding LeftAtText}"/>
+                            <GridViewColumn Header="진료과" Width="86" DisplayMemberBinding="{Binding Department}"/>
+                            <GridViewColumn Header="담당의" Width="68" DisplayMemberBinding="{Binding Doctor}"/>
+                            <GridViewColumn Header="보험" Width="74" DisplayMemberBinding="{Binding Insurance}"/>
+                            <GridViewColumn Header="상태" Width="58" DisplayMemberBinding="{Binding State}"/>
                         </GridView>
                     </ListView.View>
                 </ListView>

src/SheetMe.Designer/Views/PatientPickerDialogView.xaml.cs

@@ -86,6 +86,15 @@ public partial class PatientPickerDialogView : Window
         }
     }
 
+    /// <summary>검색 유형의 사람이 읽는 이름 — 0건 안내가 "무엇으로 찾았는지" 말할 때 쓴다</summary>
+    private static string KindLabel(PatientSearchKind kind) => kind switch
+    {
+        PatientSearchKind.Name => "성명 접두일치",
+        PatientSearchKind.ResidentNumber => "주민번호 접두일치",
+        PatientSearchKind.MobilePhone => "휴대전화 부분일치",
+        _ => "차트번호 완전일치",
+    };
+
     private void OnSearch(object sender, RoutedEventArgs e)
     {
         if (store is null)
@@ -111,10 +120,42 @@ public partial class PatientPickerDialogView : Window
             Mouse.OverrideCursor = Cursors.Wait;
             SearchButton.IsEnabled = false;
             var found = store.Search(kind, TermBox.Text);
+            var padded = string.Empty;
+
+            // 차트번호는 <b>완전일치</b>다. 병원마다 자릿수가 정해져 있어 실제 값은 0으로 채워져 있는데
+            // (P_PatInf 가 고정 폭이다) 사람은 "12345" 처럼 앞의 0 을 빼고 친다 — 그러면 0건이다.
+            // 저장소는 주석으로 "병원별 zero-pad 후 전달"을 요구하는데 이 호출부가 그걸 안 지켰다.
+            //
+            // <b>자릿수를 설정으로 정하지 않는다.</b> 병원마다 다르고 틀리면 멀쩡한 검색을 망친다.
+            // 대신 0건일 때만 한 번 더 찾는다 — 8·10자리는 레거시가 쓰던 두 폭이다.
+            // 찾았으면 무엇으로 찾았는지 칸에 되써서 사용자가 그 번호를 기억하게 한다.
+            if (found.Count == 0 && kind == PatientSearchKind.ChartNumber
+                && TermBox.Text.Trim() is { Length: > 0 } typed && typed.All(char.IsDigit))
+            {
+                foreach (var width in new[] { 8, 10 })
+                {
+                    if (typed.Length >= width)
+                    {
+                        continue;
+                    }
+                    var retry = store.Search(kind, typed.PadLeft(width, '0'));
+                    if (retry.Count > 0)
+                    {
+                        found = retry;
+                        padded = typed.PadLeft(width, '0');
+                        TermBox.Text = padded;
+                        break;
+                    }
+                }
+            }
+
             PatientList.ItemsSource = found;
             PatientCountText.Text = found.Count switch
             {
-                0 => "환자 — 없습니다",
+                // 0건일 때 <b>무엇으로 찾았는지</b> 말한다 — 유형이 틀려서 0건인 경우가 가장 흔한데
+                // 전에는 그 힌트가 화면에 하나도 없어 접속이나 권한을 의심하게 됐다
+                0 => $"환자 — 없습니다({KindLabel(kind)}로 찾았습니다)",
+                _ when padded.Length > 0 => $"환자 {found.Count}명 — 자릿수를 채워 '{padded}' 로 찾았습니다",
                 PatientVisitStore.DefaultLimit =>
                     $"환자 {found.Count}명 — 상한에 걸렸습니다. 검색어를 좁히세요",
                 _ => $"환자 {found.Count}명",

src/SheetMe.Designer/Views/PreviewWindow.xaml

@@ -1,55 +1,83 @@
 <Window x:Class="SheetMe.Designer.Views.PreviewWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:ctl="clr-namespace:SheetMe.Designer.Controls"
         Title="미리보기" Width="900" Height="1000"
         WindowStartupLocation="CenterOwner" Background="{DynamicResource B.CanvasBg}"
         Style="{StaticResource ThemedDialogWindow}">
+    <Window.Resources>
+        <ctl:IconNameToVisualConverter x:Key="IconName"/>
+    </Window.Resources>
     <DockPanel>
         <ToolBarTray DockPanel.Dock="Top">
             <ToolBar>
-                <Button Content="인쇄..." Padding="10,3" Click="OnPrint"/>
-                <Button Content="새로 고침" Padding="10,3" Click="OnRefresh"
-                        ToolTip="구조 변경은 자동으로 따라오고, 창을 누르면 다시 그립니다"/>
+                <!--
+                    아이콘 버튼으로 둔다. 전에는 여덟 개가 전부 글자라 툴바가 글자 벽이었고,
+                    무엇이 명령이고 무엇이 상태인지 구분되지 않았다.
+                    글자로 남기는 것은 <b>값과 상태</b>뿐이다 — 고른 환자 이름과 배율.
+                    이름은 툴팁이 받는다(셸 제목줄의 아이콘 줄과 같은 규범).
+                -->
+                <Button Style="{StaticResource Subtle}" Width="34" Height="28" Padding="0"
+                        Click="OnPrint" ToolTip="인쇄..."
+                        Content="{Binding Source=printer, Converter={StaticResource IconName}, ConverterParameter=16}"/>
+                <Button Style="{StaticResource Subtle}" Width="34" Height="28" Padding="0"
+                        Click="OnRefresh"
+                        ToolTip="다시 그리기 — 구조 변경은 자동으로 따라오고, 창을 누르면 다시 그립니다"
+                        Content="{Binding Source=rotate-cw, Converter={StaticResource IconName}, ConverterParameter=16}"/>
                 <Separator/>
                 <!--
                     레거시 미리보기와 레거시 인쇄가 서로 다르다 — 미리보기는 PrintOutPut=False 를
                     그대로 보여 주고 인쇄는 뺀다. 둘 다 확인할 수 있어야 해서 보기를 가른다.
                     기본은 인쇄 기준 — 저장 전에 확인하려는 것이 대개 종이 결과다.
+                    토글은 눌린 상태가 곧 '인쇄 기준'이라는 뜻이다(툴팁이 양쪽을 설명한다).
                 -->
-                <CheckBox x:Name="PrintViewToggle" Content="인쇄될 것만" IsChecked="True"
-                          VerticalAlignment="Center" Margin="4,0"
-                          Checked="OnViewToggled" Unchecked="OnViewToggled"
-                          ToolTip="끄면 화면에 보이는 대로 — 인쇄 출력을 끈 컨트롤도 보입니다(레거시 미리보기와 같음)"/>
+                <ToggleButton x:Name="PrintViewToggle" IsChecked="True"
+                              Style="{StaticResource MiniToggle}" Width="34" Height="28" Padding="0"
+                              Checked="OnViewToggled" Unchecked="OnViewToggled"
+                              ToolTip="인쇄될 것만 보기 — 끄면 화면에 보이는 대로(인쇄 출력을 끈 컨트롤도 보입니다)"
+                              Content="{Binding Source=eye, Converter={StaticResource IconName}, ConverterParameter=16}"/>
                 <Separator/>
                 <!--
                     실제 환자로 미리보기 — 태그가 값을 뽑는지 확인하는 유일한 방법이다.
                     고르지 않은 상태가 기본이다. 여는 순간 환자를 붙이면 미리보기를 열 때마다
                     환자 정보를 조회하게 되고, 그건 이 도구가 할 일이 아니다.
+
+                    선택·해제를 <b>한 버튼</b>으로 합쳤다 — 셸 제목줄의 환자 아이콘과 같은 방식이다.
+                    안 골랐으면 바로 선택 창, 이미 골랐으면 바꾸기·해제 메뉴를 띄운다.
+                    늘 보이는 자리에서 '누르면 해제'로 두면 실수로 지운다.
                 -->
-                <Button x:Name="PatientButton" Content="환자 선택..." Padding="10,3" Click="OnPickPatient"
-                        ToolTip="실제 환자·내원을 골라 태그에 값이 들어간 상태로 확인합니다"/>
-                <Button x:Name="PatientClearButton" Content="환자 해제" Padding="10,3" Click="OnClearPatient"
-                        IsEnabled="False" ToolTip="환자 없이 — 태그는 사유만 보입니다"/>
+                <Button x:Name="PatientButton" Style="{StaticResource Subtle}" Width="34" Height="28" Padding="0"
+                        Click="OnPickPatient"
+                        ToolTip="환자 선택 — 실제 환자·내원을 골라 태그에 값이 들어간 상태로 확인합니다"/>
                 <!--
                     데이터소스 결과 — 종이에 값이 안 찍혔을 때 왜인지는 여기서만 알 수 있다.
                     "[MDataTable1.ALGYON — 조회 결과가 0행입니다]" 한 줄로는 쿼리가 틀렸는지,
                     치환이 빈 값이 됐는지, 이 환자에게 정말 자료가 없는지 가릴 수 없다.
                 -->
-                <Button x:Name="DataSourceButton" Content="데이터소스..." Padding="10,3" Click="OnShowDataSources"
-                        IsEnabled="False" ToolTip="MDataTable 조회 결과와 치환을 마친 SQL 을 봅니다"/>
-                <TextBlock x:Name="PatientText" VerticalAlignment="Center" Margin="8,0"
-                           MaxWidth="360" TextTrimming="CharacterEllipsis"
-                           Foreground="{DynamicResource B.Muted}" Text="환자 없음"/>
+                <Button x:Name="DataSourceButton" Style="{StaticResource Subtle}" Width="34" Height="28" Padding="0"
+                        Click="OnShowDataSources" IsEnabled="False"
+                        ToolTip="데이터소스 결과 — MDataTable 조회 결과와 치환을 마친 SQL 을 봅니다"
+                        Content="{Binding Source=table, Converter={StaticResource IconName}, ConverterParameter=16}"/>
                 <!--
                     미리보기에서 눌러 본 체크·라디오를 원래대로. 문서는 처음부터 안 건드리므로
                     되돌릴 것이 없고, 여기서 지우는 것은 "눌러 본 흔적"뿐이다.
                 -->
-                <Button x:Name="ResetChecksButton" Content="누른 것 초기화" Padding="10,3" Click="OnResetChecks"
-                        IsEnabled="False" ToolTip="미리보기에서 눌러 본 체크·라디오를 서식의 기본 상태로 돌립니다"/>
+                <Button x:Name="ResetChecksButton" Style="{StaticResource Subtle}" Width="34" Height="28" Padding="0"
+                        Click="OnResetChecks" IsEnabled="False"
+                        ToolTip="누른 것 초기화 — 미리보기에서 눌러 본 체크·라디오를 서식의 기본 상태로 돌립니다"
+                        Content="{Binding Source=undo-2, Converter={StaticResource IconName}, ConverterParameter=16}"/>
+                <!-- 고른 환자는 <b>글자로</b> 남긴다 — 이름은 아이콘으로 대신할 수 없는 값이다 -->
+                <TextBlock x:Name="PatientText" VerticalAlignment="Center" Margin="8,0"
+                           MaxWidth="360" TextTrimming="CharacterEllipsis"
+                           Foreground="{DynamicResource B.Muted}" Text="환자 없음"/>
                 <Separator/>
-                <Button Content="－" Padding="8,3" Click="OnZoomOut"/>
+                <Button Style="{StaticResource Subtle}" Width="30" Height="28" Padding="0"
+                        Click="OnZoomOut" ToolTip="축소"
+                        Content="{Binding Source=minus, Converter={StaticResource IconName}, ConverterParameter=14}"/>
                 <TextBlock x:Name="ZoomText" Text="100%" VerticalAlignment="Center" Margin="6,0" MinWidth="42" TextAlignment="Center"/>
-                <Button Content="＋" Padding="8,3" Click="OnZoomIn"/>
+                <Button Style="{StaticResource Subtle}" Width="30" Height="28" Padding="0"
+                        Click="OnZoomIn" ToolTip="확대"
+                        Content="{Binding Source=plus, Converter={StaticResource IconName}, ConverterParameter=14}"/>
             </ToolBar>
         </ToolBarTray>
 

src/SheetMe.Designer/Views/PreviewWindow.xaml.cs

@@ -303,21 +303,42 @@ public partial class PreviewWindow : Window
     /// </summary>
     private void OnPickPatient(object sender, RoutedEventArgs e)
     {
-        var picked = PatientPickerDialogView.Pick(this, out var label);
-        if (picked is null)
+        // 안 골랐으면 바로 선택 창. 이미 골랐으면 <b>메뉴</b>다 —
+        // 늘 보이는 아이콘에서 '누르면 해제'로 두면 실수로 지운다.
+        // 셸 제목줄의 환자 아이콘과 같은 규범이다(버튼 두 개를 하나로 합쳤다).
+        if (!PatientSession.HasPatient)
         {
+            Pick();
             return;
         }
-        // 세션에만 쓴다 — 그러면 Changed 가 이 창을 포함한 <b>모든</b> 화면을 갱신한다.
-        // 여기서 직접 UsePatient 도 부르면 두 번 그리고, 더 나쁘게는
-        // 세션과 창이 어긋나는 경로가 하나 더 생긴다.
-        PatientSession.Set(picked, label);
+        var menu = new System.Windows.Controls.ContextMenu
+        {
+            PlacementTarget = PatientButton,
+            Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom,
+        };
+        var header = new System.Windows.Controls.MenuItem { Header = PatientSession.Label, IsEnabled = false };
+        var change = new System.Windows.Controls.MenuItem { Header = "환자 바꾸기..." };
+        change.Click += (_, _) => Pick();
+        var clear = new System.Windows.Controls.MenuItem { Header = "환자 해제" };
+        clear.Click += (_, _) => PatientSession.Set(null, string.Empty);
+        menu.Items.Add(header);
+        menu.Items.Add(new System.Windows.Controls.Separator());
+        menu.Items.Add(change);
+        menu.Items.Add(clear);
+        menu.IsOpen = true;
+
+        void Pick()
+        {
+            // 권한 문·감사 기록·문맥 읽기는 전부 Pick 안에 있다 — 호출부마다 다시 확인하면 어긋난다.
+            // 세션에만 쓴다 — 그러면 Changed 가 이 창을 포함한 <b>모든</b> 화면을 갱신한다.
+            if (PatientPickerDialogView.Pick(this, out var label) is { } picked)
+            {
+                PatientSession.Set(picked, label);
+            }
+        }
     }
 
     /// <summary>환자를 뗀다 — 종이에서 값이 사라지고 사유로 돌아가는 것까지 확인해야 한다</summary>
-    private void OnClearPatient(object sender, RoutedEventArgs e)
-        => PatientSession.Set(null, string.Empty);
-
     private void OnPatientSessionChanged(object? sender, EventArgs e)
         => UsePatient(PatientSession.Current, PatientSession.Label);
 
@@ -359,7 +380,11 @@ public partial class PreviewWindow : Window
         fields = new MDataTableRunner(designer.Document,
             picked is null ? null : new PatientQueryVariableSource(picked, UserSession.Current.UidCod));
         PatientText.Text = picked is null ? "환자 없음" : label;
-        PatientClearButton.IsEnabled = picked is not null;
+        // 고른 상태는 <b>아이콘 색</b>으로 알린다 — 셸 제목줄과 같다.
+        // 안 고른 상태의 색은 B.Muted 여야 한다(null 을 넘기면 하드코딩 검정으로 칠해져
+        // 어두운 툴바에서 혼자 묻힌다 — 제목줄에서 실제로 겪은 결함이다).
+        PatientButton.Content = Controls.LucideIcons.Icon("user", 16,
+            picked is null ? "B.Muted" : "B.Accent");
         DataSourceButton.IsEnabled = fields.Names.Count > 0;
         BuildPages();
     }

src/SheetMe.Designer/Views/QueryEditorWindow.xaml

@@ -323,9 +323,33 @@
                                 <DockPanel DockPanel.Dock="Top" Margin="0,0,0,8">
                                     <Button DockPanel.Dock="Right" Content="닫기"
                                             Style="{StaticResource LinkBtn}" Click="OnCloseTrial"/>
+                                    <!--
+                                        무엇을 돌렸는지 보여 준다. 0행이 나왔을 때
+                                        '치환이 NULL 이라 조건이 사라진 건지, 이 환자에게 자료가 없는 건지'를
+                                        창을 나가지 않고 가르는 유일한 수단이다 — 치환을 마친 문장이 답을 갖고 있다.
+                                    -->
+                                    <Button x:Name="ShowTrialSqlButton" DockPanel.Dock="Right"
+                                            Content="돌린 SQL 보기" Margin="0,0,10,0"
+                                            Style="{StaticResource LinkBtn}" Click="OnToggleTrialSql"/>
                                     <TextBlock x:Name="TrialSummary" FontSize="12.5" TextWrapping="Wrap"
                                                VerticalAlignment="Center"/>
                                 </DockPanel>
+                                <!-- 돌린 SQL 원문 — 읽기 전용. 08c 데이터소스 결과 창과 같은 구성이다 -->
+                                <Border x:Name="TrialSqlPane" DockPanel.Dock="Top" Visibility="Collapsed"
+                                        Margin="0,0,0,8" BorderThickness="1"
+                                        BorderBrush="{DynamicResource B.Line2}"
+                                        Background="{DynamicResource B.Input}">
+                                    <DockPanel>
+                                        <Button DockPanel.Dock="Right" Content="SQL 복사" VerticalAlignment="Top"
+                                                Margin="6,4,6,4" Style="{StaticResource LinkBtn}"
+                                                Click="OnCopyTrialSql"/>
+                                        <TextBox x:Name="TrialSqlText" IsReadOnly="True" BorderThickness="0"
+                                                 Background="Transparent" FontFamily="Consolas" FontSize="12"
+                                                 TextWrapping="Wrap" MaxHeight="120" Padding="8,6"
+                                                 VerticalScrollBarVisibility="Auto"
+                                                 AutomationProperties.Name="돌린 SQL"/>
+                                    </DockPanel>
+                                </Border>
                                 <!-- 표를 감싸는 테두리 — 표 자체는 테두리를 그리지 않는다(위 스타일) -->
                                 <Border BorderThickness="1" BorderBrush="{DynamicResource B.Line2}">
                                     <DataGrid x:Name="TrialGrid" Style="{StaticResource ResultGrid}" MaxHeight="200"
@@ -422,8 +446,11 @@
 
                     <!-- 검색: 돋보기를 겹쳐 둔다 — 빈 상자만 있으면 무엇을 하는 칸인지 안 읽힌다 -->
                     <Grid DockPanel.Dock="Top" Margin="0,0,0,8">
+                        <!-- KeyDown 필수 — 확인 버튼이 IsDefault 라 이 칸의 Enter 가
+                             '저장하고 닫기'로 새어 나간다(변수를 못 넣은 채 편집이 끝난다) -->
                         <TextBox x:Name="VariableSearch" Padding="28,4,8,4"
                                  VerticalContentAlignment="Center" TextChanged="OnVariableSearchChanged"
+                                 KeyDown="OnVariableSearchKeyDown"
                                  AutomationProperties.Name="치환 변수 검색"
                                  ToolTip="변수명·설명·초성으로 찾습니다 (예: ㅊㅌㅂㅎ → 차트번호)"/>
                         <TextBlock Text="🔍" FontSize="11" Margin="9,0,0,0" IsHitTestVisible="False"

src/SheetMe.Designer/Views/QueryEditorWindow.xaml.cs

@@ -41,6 +41,9 @@ public partial class QueryEditorWindow : Window
     /// <summary>마지막으로 돌린 SQL — 진단이 "무엇을 돌렸는가"를 확인할 때 쓴다</summary>
     private string lastTrialSql = string.Empty;
 
+    /// <summary>검증을 돌린 시점의 SQL 원문 — 그 뒤 고쳤는지 판정한다</summary>
+    private string trialBaseline = string.Empty;
+
     /// <summary>진단 전용 — 검증 실행이 실제로 만든 SQL</summary>
     internal string LastTrialSql => lastTrialSql;
 
@@ -552,6 +555,8 @@ public partial class QueryEditorWindow : Window
             emptyPlaceholder: "NULL");
         var probe = converted.Sql;
         lastTrialSql = probe;
+        // 치환 <b>전</b> 원문을 기준으로 삼는다 — 사용자가 고치는 것은 이쪽이다
+        trialBaseline = SqlBox.Text;
 
         Mouse.OverrideCursor = Cursors.Wait;
         SheetMe.Data.Stores.QueryTrialResult result;
@@ -570,7 +575,11 @@ public partial class QueryEditorWindow : Window
         // 같은 정보를 두 군데 적으면 요약이 두 줄로 늘어 결과 표를 밀어내고,
         // 화면에 환자 이름이 필요 이상으로 여러 번 남는다.
         // 환자가 있을 때 필요한 말은 이미 버튼이 하고 있으므로 여기서는 침묵한다.
-        var basis = variables is not null ? string.Empty : "변수 NULL — 구문만 검사";
+        // 치환 대상이 <b>하나도 없는</b> 쿼리에 '변수 NULL' 을 적으면 거짓이다 —
+        // 치환할 것이 없으니 NULL 로 바뀐 것도 없다. 그런데 그 꼬리표가 늘 붙어 있어서
+        // 정작 진짜 경고가 붙은 날에도 눈에 안 들어왔다. 늘 뜨는 경고는 경고가 아니다.
+        var hasSubstitution = converted.Hits.Count > 0;
+        var basis = variables is null && hasSubstitution ? "변수 NULL — 구문만 검사" : string.Empty;
         var notes = new List<string>();
         // 환자를 안 골랐으면 <b>모든</b> 변수가 Unknown 이다 — 그것을 "아직 옮기지 않았다"고 적으면
         // 거짓이 된다(ChtNum 은 옮겨져 있다). 그 사유는 위 basis 줄이 이미 말한다.
@@ -606,8 +615,11 @@ public partial class QueryEditorWindow : Window
             // 빈 조각은 버린다 — 안 버리면 "성공  ·    ·  경고" 처럼 가운뎃점이 떠 있는다
             TrialSummary.Text = string.Join("  ·  ",
                 new[] { head, basis }.Concat(notes).Where(s => s.Length > 0));
+            // 0행이어도 표를 띄운다 — <b>컬럼 이름</b>은 이미 알고 있고, 그것이 배선 필드 칸에
+            // 옮겨 적을 값이다. 표를 접으면 방금 조회한 컬럼명을 다시 알아내려고
+            // 쿼리를 또 돌려야 한다(0행이 배선 작업에서 드문 상태도 아니다).
             TrialGrid.ItemsSource = ToGridRows(result);
-            TrialGrid.Visibility = result.Rows.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
+            TrialGrid.Visibility = result.Columns.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
         }
         else
         {
@@ -616,6 +628,9 @@ public partial class QueryEditorWindow : Window
                 new[] { "실패 — " + result.Error, basis }.Concat(notes).Where(s => s.Length > 0));
             TrialGrid.ItemsSource = null;
             TrialGrid.Visibility = Visibility.Collapsed;
+            // 실패했으면 표가 어차피 없다 — 그 자리에 돌린 문장을 바로 보여 준다.
+            // 오라클 오류 문구만으로는 어디가 틀렸는지 알 수 없고, 답은 치환된 문장에 있다.
+            SetTrialSqlVisible(true);
         }
     }
 
@@ -736,6 +751,67 @@ public partial class QueryEditorWindow : Window
         LengthText.Text = $"{text.Length:N0}자 · {CountLines(text)}줄";
         UpdateCaretText();
         UpdateProblems(text);
+        RefreshTrialFreshness();
+    }
+
+    /// <summary>
+    /// 검증 결과가 <b>지금 SQL 의 것인지</b> 표시한다.
+    ///
+    /// 전에는 검증을 돌린 뒤 SQL 을 고쳐도 초록 요약과 결과 표가 그대로 남았다.
+    /// "검증했다"고 믿고 저장하는데, 저장되는 것은 <b>검증하지 않은 문장</b>이다.
+    /// 결과를 지우지는 않는다 — 방금 본 컬럼명이 사라지면 그것대로 불편하다.
+    /// 흐리게 낮추고 다시 돌리라고 말하는 것으로 충분하다.
+    /// </summary>
+    private void RefreshTrialFreshness()
+    {
+        if (TrialPane is null || TrialPane.Visibility != Visibility.Visible || trialBaseline.Length == 0)
+        {
+            return;
+        }
+        var stale = !string.Equals(trialBaseline, SqlBox.Text, StringComparison.Ordinal);
+        TrialPane.Opacity = stale ? 0.5 : 1.0;
+        if (stale && !TrialSummary.Text.StartsWith(StaleMark, StringComparison.Ordinal))
+        {
+            TrialSummary.Text = StaleMark + TrialSummary.Text;
+        }
+        else if (!stale && TrialSummary.Text.StartsWith(StaleMark, StringComparison.Ordinal))
+        {
+            TrialSummary.Text = TrialSummary.Text[StaleMark.Length..];
+        }
+    }
+
+    /// <summary>검증 이후 SQL 이 바뀌었을 때 요약 앞에 붙는 표시</summary>
+    private const string StaleMark = "(수정됨 — 다시 실행하세요) ";
+
+    /// <summary>
+    /// '돌린 SQL' 접기/펴기 — 치환을 마친 문장을 창 안에서 확인한다.
+    ///
+    /// 0행이 나왔을 때 <b>치환이 NULL 이라 조건이 사라진 것</b>인지
+    /// <b>이 환자에게 자료가 없는 것</b>인지 가르는 유일한 수단이다. 그 답은 돌린 문장에 있다.
+    /// 전에는 그 문장을 필드에 담아 두기만 하고(진단용) 화면에는 내보내지 않았다.
+    /// </summary>
+    private void OnToggleTrialSql(object sender, RoutedEventArgs e)
+    {
+        var show = TrialSqlPane.Visibility != Visibility.Visible;
+        SetTrialSqlVisible(show);
+    }
+
+    private void SetTrialSqlVisible(bool show)
+    {
+        TrialSqlPane.Visibility = show ? Visibility.Visible : Visibility.Collapsed;
+        ShowTrialSqlButton.Content = show ? "돌린 SQL 숨기기" : "돌린 SQL 보기";
+        if (show)
+        {
+            TrialSqlText.Text = lastTrialSql;
+        }
+    }
+
+    private void OnCopyTrialSql(object sender, RoutedEventArgs e)
+    {
+        if (lastTrialSql.Length > 0)
+        {
+            Clipboard.SetText(lastTrialSql);
+        }
     }
 
     /// <summary>줄·열 표시 — 오류 메시지의 위치를 찾아갈 때 쓴다</summary>
@@ -1047,6 +1123,35 @@ public partial class QueryEditorWindow : Window
     #endregion
 
     #region Methods - Variables
+    /// <summary>
+    /// 변수 검색칸의 Enter·↓ — <b>확인 버튼으로 새어 나가는 것을 막는다</b>.
+    ///
+    /// 확인 버튼이 <c>IsDefault</c> 라, 이 칸에서 Enter 를 누르면 검색이나 삽입이 아니라
+    /// <b>SQL 이 저장되고 창이 닫혔다</b>. '차트' 를 치고 Enter 를 눌렀을 뿐인데
+    /// 변수를 하나도 못 넣은 채 편집이 끝난다 — 무엇이 일어났는지도 알기 어렵다.
+    ///
+    /// Enter 는 지금 걸러진 목록의 선택 항목을 넣는다(필터가 하나로 좁혀졌을 때가 대부분이다).
+    /// ↓ 는 목록으로 이동한다 — 손을 마우스로 옮기지 않고 훑을 수 있어야 한다.
+    /// </summary>
+    private void OnVariableSearchKeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key == Key.Enter)
+        {
+            InsertSelectedVariable();
+            e.Handled = true; // IsDefault 버튼에 도달시키지 않는다
+            return;
+        }
+        if (e.Key == Key.Down && VariableList.Items.Count > 0)
+        {
+            VariableList.Focus();
+            if (VariableList.SelectedIndex < 0)
+            {
+                VariableList.SelectedIndex = 0;
+            }
+            e.Handled = true;
+        }
+    }
+
     private void OnVariableSearchChanged(object sender, TextChangedEventArgs e)
     {
         SearchPlaceholder.Visibility = VariableSearch.Text.Length == 0 ? Visibility.Visible : Visibility.Collapsed;

src/SheetMe.Designer/Views/SelectionOverlayView.xaml

@@ -66,6 +66,22 @@
             </ItemsControl.ItemTemplate>
         </ItemsControl>
 
+        <!--
+            끄는 동안의 치수·좌표 — 편집 크롬이라 종이에는 없다.
+            줌이 걸린 층이라 역배율로 되돌려 글자 크기를 화면 고정으로 만든다
+            (간격 수치 칩이 이미 같은 방식을 쓴다).
+        -->
+        <Border Canvas.Left="{Binding DragBadgeX}" Canvas.Top="{Binding DragBadgeY}"
+                Background="{DynamicResource B.AccentFill}" CornerRadius="3" Padding="5,1"
+                RenderTransformOrigin="0,0"
+                Visibility="{Binding ShowDragBadge, Converter={StaticResource BoolToVisibility}}">
+            <Border.RenderTransform>
+                <ScaleTransform ScaleX="{Binding InverseZoom}" ScaleY="{Binding InverseZoom}"/>
+            </Border.RenderTransform>
+            <TextBlock Text="{Binding DragBadgeText}" FontSize="11"
+                       Foreground="{DynamicResource B.OnAccent}"/>
+        </Border>
+
         <!-- 마퀴(러버밴드) -->
         <Rectangle Canvas.Left="{Binding MarX}" Canvas.Top="{Binding MarY}"
                    Width="{Binding MarW}" Height="{Binding MarH}"

src/SheetMe.Designer/Views/TagPickerDialogView.xaml.cs

@@ -64,6 +64,9 @@ public partial class TagPickerDialogView : Window
     /// </summary>
     private readonly IReadOnlyList<string> preferred;
 
+    /// <summary>액션 태그 목록인가 — 값 칸의 뜻이 데이터 태그와 완전히 다르다</summary>
+    private readonly bool isActionKind;
+
     private const string FilterAll = "*";
     private const string FilterPreferred = "!";
     private const string FilterUsed = "+";
@@ -81,11 +84,16 @@ public partial class TagPickerDialogView : Window
     #endregion
 
     #region Constructors
+    /// <param name="isActionTag">
+    /// 액션 태그 목록인가 — 액션은 <b>값이 아니라 동작</b>이라 값·사유 칸의 뜻이 완전히 다르다.
+    /// 데이터 태그용 문구를 그대로 쓰면 149종 전부에서 오른쪽 설명이 거짓이 된다.
+    /// </param>
     public TagPickerDialogView(string title, IReadOnlyList<string> tags, string? currentValue,
-        IReadOnlyList<string>? preferredTags = null)
+        IReadOnlyList<string>? preferredTags = null, bool isActionTag = false)
     {
         allTags = tags;
         preferred = preferredTags ?? Array.Empty<string>();
+        isActionKind = isActionTag;
         previewStore = new SheetMe.Data.Stores.TagPreviewStore(
             Services.ConfigService.Current.ConnectionString);
         InitializeComponent();
@@ -295,13 +303,21 @@ public partial class TagPickerDialogView : Window
     /// </summary>
     private void ShowTagValue(string tag)
     {
-        if (previewStore is null || !previewStore.CanUseDb)
-        {
-            InfoValueBlock.Visibility = Visibility.Collapsed;
-            return;
-        }
         InfoValueBlock.Visibility = Visibility.Visible;
 
+        // 액션 태그는 <b>값이 아니다</b>. 더블클릭·버튼이 실행하는 동작이라
+        // "환자 정보가 있어야 값이 나옵니다" 같은 데이터 태그용 사유를 붙이면
+        // 149종 전부에서 이 칸이 통째로 거짓말을 한다.
+        if (isActionKind)
+        {
+            InfoValue.Text = "값이 아니라 동작입니다";
+            InfoValueNote.Text = "더블클릭·버튼에서 실행됩니다 — 종이에 찍히는 값이 아닙니다.";
+            return;
+        }
+
+        // 값을 <b>만들 수 없는 이유</b>는 DB 없이도 안다(정적 판정이다).
+        // 전에는 DB 가드가 이 위에 있어서, 접속이 없으면 사유까지 통째로 감춰졌다 —
+        // 정작 그 사유가 가장 필요한 상황(접속 안 된 단말에서 서식을 훑을 때)에 안 보였다.
         if (!TagPreviewCatalog.CanResolve(tag))
         {
             InfoValue.Text = "값을 만들 수 없습니다";
@@ -309,12 +325,29 @@ public partial class TagPickerDialogView : Window
             return;
         }
 
+        // 여기서부터는 실제 값이 필요하다 — 그때만 DB 를 따진다.
+        // (진단 스크린샷은 DB 없이 이 창을 띄우므로 이 가드가 없으면 늘 "값을 읽지 못했습니다"가 찍힌다)
+        if (previewStore is null || !previewStore.CanUseDb)
+        {
+            InfoValue.Text = "값은 접속된 단말에서 확인됩니다";
+            InfoValueNote.Text = TagPreviewCatalog.SourceText(tag);
+            return;
+        }
+
         previewContext ??= previewStore.Read(UserSession.Current.UidCod, UserSession.Current.UidNam);
         var context = previewContext.Value;
         var value = TagPreviewCatalog.KindOf(tag) == TagPreviewKind.Clock
             ? TagPreviewCatalog.FromClock(tag, context.Minute12)
+            // <b>본판(10-인자)으로 부른다.</b> 5-인자 위임판은 면허·전문의·직종·부서·부서전화를
+            // 빈 문자열로 채운다 — 그래서 의사면허번호·전문의번호·직종·부서·부서전화 계열이
+            // 피커에서는 "이 계정에는 값이 비어 있습니다"로 보이는데 종이에는 실제 값이 찍혔다.
+            // 값이 나오는 사용자 태그 중 다섯 갈래가 <b>피커에서만</b> 거짓말을 하고 있었다.
+            // 이 값들은 로그인 세션이 이미 들고 있다(HisUser 15컬럼) — 조회를 더 하지 않는다.
             : TagPreviewCatalog.FromUser(tag, context.UidCod, context.UidNam,
-                context.MobilePhone, context.OfficePhone);
+                context.MobilePhone, context.OfficePhone,
+                UserSession.Current.LicenseNumber, UserSession.Current.SpecialistNumber,
+                UserSession.Current.JobName, UserSession.Current.DepNam,
+                UserSession.Current.DepPhone);
 
         if (value.Length > 0)
         {