v0.3.0: game-window picker + NCC recognition + artifacts + ?-merged

- window_capture.py: enumerate top-level windows (pygetwindow) and
  capture a specific one via PrintWindow PW_RENDERFULLCONTENT (works
  on non-focused windows). Linux falls back to mss region grab.
- recognizer.py: replace MAE matcher with NCC over numpy vectors.
  Each rotatable slab generates 4 templates (0/90/180/270). Adds 248
  artifact templates and an empty-cell heuristic (low mean/std-dev).
  Cells below confidence floor are tagged "unknown" — likely merged
  "?" boxes.
- gui.py: new ScreenshotFrame with [게임 창 선택] button → window
  picker dialog → bbox crop → recognize → editable preview grid with
  per-cell CellEditor that handles slab / artifact / merged(?) / empty.
  Merged cells let user pick which two slabs got combined + a level.
- artifacts.py + bundled _artifacts.json (248 entries from
  WhiteDog1004/sephiria) for matching and rendering.
- renderer.py: factored CDN fetch into _fetch_image; added
  fetch_artifact_image().
- requirements.txt: + numpy, pygetwindow (Win), pywin32 (Win).
- docker-build-cmd.sh: upgrade PyInstaller to 5.x inside cdrx
  container so numpy DLL manifest reads work.

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

sephiria_inv/gui.py

@@ -1,13 +1,16 @@
 """Tkinter GUI for the Sephiria inventory optimizer.
 
-The main window has a notebook with two input modes:
-  - "수동": pick each slab and its count from the tier-grouped catalog.
-  - "스크린샷": grab the current screen (or load a PNG), click two corners of
-    the inventory area, and let the app recognize the slabs by template
-    matching against the cached CDN images. Mis-recognized cells can be
-    edited inline before solving.
+Two input modes via Notebook:
+  - "게임창 캡처": list visible Windows top-level windows, pick the Sephiria
+    one, capture its full client area (PrintWindow, works even when not
+    focused), click two corners of the bag area, then run the recognizer
+    (NCC + 4 rotations + artifacts + empty/unknown). Mis-recognized cells
+    can be fixed by click. Unknown ("?") cells likely correspond to merged
+    slab boxes — clicking one opens a popup that lets the user describe
+    which two slabs got merged.
+  - "수동 선택": existing tier-grouped +/- input.
 
-Both modes feed into the same basket → solver → renderer pipeline on the right.
+Both modes feed a basket → solver → renderer pipeline shown on the right.
 """
 
 from __future__ import annotations
@@ -16,82 +19,165 @@ import os
 import sys
 import threading
 import tkinter as tk
-from tkinter import filedialog, messagebox, simpledialog, ttk
-from typing import Dict, List, Optional
+from tkinter import filedialog, messagebox, ttk
+from typing import Dict, List, Optional, Tuple
 
 from PIL import Image, ImageTk
 
-from .renderer import fetch_slab_image, render_solution
-from .slabs import SLABS, SLABS_BY_VALUE, TIER_LABEL, TIER_ORDER
+from .artifacts import ARTIFACTS, ARTIFACTS_BY_VALUE
+from .recognizer import CellResult, recognize_image, warm_templates
+from .renderer import fetch_artifact_image, fetch_slab_image, render_solution
+from .slabs import (
+    GRID_COLS,
+    SLABS,
+    SLABS_BY_VALUE,
+    TIER_LABEL,
+    TIER_ORDER,
+    generate_grid_config,
+)
 from .solver import solve
 
 
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
+# ---------- helpers ----------
 
 def _slab_thumb(value: str, size: int = 48) -> Optional[ImageTk.PhotoImage]:
-    """Return a Tk image for the given slab (downloaded + cached)."""
     slab = SLABS_BY_VALUE.get(value)
     if not slab:
         return None
     img = fetch_slab_image(slab.image)
     if img is None:
         return None
-    img = img.resize((size, size))
-    return ImageTk.PhotoImage(img)
+    return ImageTk.PhotoImage(img.resize((size, size)))
 
 
-# ---------------------------------------------------------------------------
-# Crop dialog (two-click bbox)
-# ---------------------------------------------------------------------------
+def _artifact_thumb(value: str, size: int = 48) -> Optional[ImageTk.PhotoImage]:
+    a = ARTIFACTS_BY_VALUE.get(value)
+    if not a:
+        return None
+    img = fetch_artifact_image(a.image)
+    if img is None:
+        return None
+    return ImageTk.PhotoImage(img.resize((size, size)))
 
 
+# ---------- window-picker dialog ----------
+
+class WindowPicker(tk.Toplevel):
+    """List visible windows; the chosen WindowInfo ends up on .selected."""
+
+    def __init__(self, parent: tk.Tk) -> None:
+        super().__init__(parent)
+        self.title("게임 창 선택")
+        self.transient(parent)
+        self.selected = None
+
+        from .window_capture import list_windows, find_sephiria
+        windows = list_windows()
+
+        wrap = ttk.Frame(self, padding=8)
+        wrap.pack(fill="both", expand=True)
+
+        if not windows:
+            ttk.Label(wrap, text=(
+                "현재 OS 에서 창 목록을 가져올 수 없습니다.\n"
+                "(Windows 전용 기능 - 리눅스/맥에서는 전체 화면 캡처를 쓰세요)"
+            ), justify="left").pack(pady=8)
+            ttk.Button(wrap, text="닫기", command=self.destroy).pack()
+            self.grab_set()
+            return
+
+        ttk.Label(wrap, text="아래 목록에서 세피리아 게임 창을 더블클릭하세요:") \
+            .pack(anchor="w")
+
+        tree_frame = ttk.Frame(wrap)
+        tree_frame.pack(fill="both", expand=True, pady=6)
+        cols = ("title", "size")
+        self.tree = ttk.Treeview(tree_frame, columns=cols, show="headings", height=14)
+        self.tree.heading("title", text="창 이름")
+        self.tree.heading("size", text="크기")
+        self.tree.column("title", width=440)
+        self.tree.column("size", width=120, anchor="center")
+        sb = ttk.Scrollbar(tree_frame, orient="vertical", command=self.tree.yview)
+        self.tree.configure(yscrollcommand=sb.set)
+        self.tree.pack(side="left", fill="both", expand=True)
+        sb.pack(side="right", fill="y")
+
+        self._windows = windows
+        # auto-promote Sephiria-matching entries
+        auto = find_sephiria()
+        sel_idx = None
+        for i, w in enumerate(windows):
+            self.tree.insert(
+                "", "end", iid=str(i),
+                values=(w.title, f"{w.width}×{w.height}"),
+            )
+            if auto and w.handle == auto.handle:
+                sel_idx = i
+        if sel_idx is not None:
+            self.tree.selection_set(str(sel_idx))
+            self.tree.see(str(sel_idx))
+
+        self.tree.bind("<Double-Button-1>", lambda _e: self._confirm())
+
+        btns = ttk.Frame(wrap)
+        btns.pack(fill="x", pady=(6, 0))
+        ttk.Button(btns, text="선택", command=self._confirm).pack(side="left")
+        ttk.Button(btns, text="취소", command=self.destroy).pack(side="right")
+
+        self.grab_set()
+        self.focus_set()
+
+    def _confirm(self) -> None:
+        sel = self.tree.selection()
+        if not sel:
+            return
+        self.selected = self._windows[int(sel[0])]
+        self.destroy()
+
+
+# ---------- crop dialog (two-click bbox) ----------
+
 class CropDialog(tk.Toplevel):
-    """Show an image and let the user click two corners of the inventory area."""
-
     MAX_DISPLAY = 1100
 
     def __init__(self, parent: tk.Tk, img: Image.Image) -> None:
         super().__init__(parent)
-        self.title("인벤토리 영역 선택 — 좌상단과 우하단을 차례로 클릭")
+        self.title("가방 영역 선택 — 좌상단과 우하단을 차례로 클릭")
         self.transient(parent)
         self.img_full = img
-        self.bbox: Optional[tuple] = None
-        self._clicks: List[tuple] = []
+        self.bbox: Optional[Tuple[int, int, int, int]] = None
+        self._clicks: List[Tuple[int, int]] = []
 
-        # scale to fit
         w, h = img.size
         self.scale = min(1.0, self.MAX_DISPLAY / max(w, h))
-        disp_w, disp_h = int(w * self.scale), int(h * self.scale)
-        self.disp_img = img.resize((disp_w, disp_h))
-        self.tk_img = ImageTk.PhotoImage(self.disp_img)
+        disp = img.resize((int(w * self.scale), int(h * self.scale)))
+        self.tk_img = ImageTk.PhotoImage(disp)
 
-        info = ttk.Label(
-            self,
-            text="인벤토리 그리드의 좌상단을 먼저 클릭하고, "
-            "우하단을 다시 클릭하세요. (그리드 바깥의 UI 프레임은 빼고)",
-        )
-        info.pack(padx=8, pady=(8, 4))
+        ttk.Label(
+            self, justify="left",
+            text=(
+                "가방(인벤토리) 격자의 좌상단을 먼저 클릭하고, 우하단을 다시 클릭하세요.\n"
+                "그리드 안쪽 첫 칸의 좌상단 모서리와 마지막 칸의 우하단 모서리로 맞추는 게 정확합니다."
+            ),
+        ).pack(padx=8, pady=(8, 4))
 
         self.canvas = tk.Canvas(
-            self, width=disp_w, height=disp_h, highlightthickness=0
+            self, width=disp.size[0], height=disp.size[1], highlightthickness=0
         )
         self.canvas.pack(padx=8, pady=4)
         self.canvas.create_image(0, 0, anchor="nw", image=self.tk_img)
-        self.canvas.bind("<Button-1>", self._on_click)
+        self.canvas.bind("<Button-1>", self._click)
 
-        btns = ttk.Frame(self)
-        btns.pack(fill="x", padx=8, pady=(4, 8))
-        ttk.Button(btns, text="처음부터 다시", command=self._reset).pack(side="left")
-        ttk.Button(btns, text="취소", command=self._cancel).pack(side="right")
+        bar = ttk.Frame(self)
+        bar.pack(fill="x", padx=8, pady=(4, 8))
+        ttk.Button(bar, text="처음부터", command=self._reset).pack(side="left")
+        ttk.Button(bar, text="취소", command=self._cancel).pack(side="right")
 
         self.protocol("WM_DELETE_WINDOW", self._cancel)
         self.grab_set()
         self.focus_set()
 
-    def _on_click(self, e: tk.Event) -> None:
+    def _click(self, e: tk.Event) -> None:
         self._clicks.append((e.x, e.y))
         self.canvas.create_oval(
             e.x - 5, e.y - 5, e.x + 5, e.y + 5, outline="#ff5050", width=2
@@ -100,10 +186,7 @@ class CropDialog(tk.Toplevel):
             (x1, y1), (x2, y2) = self._clicks
             lx, ty = min(x1, x2), min(y1, y2)
             rx, by = max(x1, x2), max(y1, y2)
-            self.canvas.create_rectangle(
-                lx, ty, rx, by, outline="#50ff80", width=2
-            )
-            # convert back to original-image coords
+            self.canvas.create_rectangle(lx, ty, rx, by, outline="#50ff80", width=2)
             inv = 1.0 / self.scale
             self.bbox = (int(lx * inv), int(ty * inv), int(rx * inv), int(by * inv))
             self.after(120, self.destroy)
@@ -118,107 +201,232 @@ class CropDialog(tk.Toplevel):
         self.destroy()
 
 
-# ---------------------------------------------------------------------------
-# Slab picker dialog (used by editable recognition grid)
-# ---------------------------------------------------------------------------
+# ---------- cell editor (slab / artifact / merged / empty) ----------
 
+class CellEditor(tk.Toplevel):
+    """Modal editor. Result on .result: dict {kind, value, rotation, merged}."""
 
-class SlabPicker(tk.Toplevel):
-    """Modal slab picker — returns value via .selected, None if cancelled."""
-
-    def __init__(self, parent: tk.Tk, current: Optional[str] = None) -> None:
+    def __init__(self, parent: tk.Tk, current: Optional[CellResult]) -> None:
         super().__init__(parent)
-        self.title("석판 선택")
+        self.title("셀 수정")
         self.transient(parent)
-        self.selected: Optional[str] = current
+        self.result: Optional[dict] = None
+        cur_kind = current.kind if current else "empty"
+        cur_val = current.value if current else None
 
         wrap = ttk.Frame(self, padding=8)
         wrap.pack(fill="both", expand=True)
-        ttk.Label(wrap, text="석판을 선택하세요. (빈칸으로 두려면 '비우기')").pack(
-            anchor="w"
-        )
 
-        canvas = tk.Canvas(wrap, height=400, highlightthickness=0)
-        scroll = ttk.Scrollbar(wrap, orient="vertical", command=canvas.yview)
-        inner = ttk.Frame(canvas)
-        inner.bind("<Configure>",
-                   lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
-        canvas.create_window((0, 0), window=inner, anchor="nw")
-        canvas.configure(yscrollcommand=scroll.set)
-        canvas.pack(side="left", fill="both", expand=True)
-        scroll.pack(side="right", fill="y")
+        ttk.Label(wrap, text="이 셀의 종류:").pack(anchor="w")
+        self.kind_var = tk.StringVar(value=cur_kind if cur_kind in ("slab", "artifact", "empty", "merged") else "empty")
+        kind_row = ttk.Frame(wrap)
+        kind_row.pack(fill="x", pady=(0, 6))
+        for label, key in [("석판", "slab"), ("아티팩트", "artifact"),
+                           ("합쳐진(?)", "merged"), ("빈칸", "empty")]:
+            ttk.Radiobutton(kind_row, text=label, value=key,
+                            variable=self.kind_var, command=self._render).pack(side="left", padx=2)
 
-        for tier in sorted({s.tier for s in SLABS}, key=lambda t: TIER_ORDER.get(t, 99)):
-            ttk.Label(inner, text=TIER_LABEL.get(tier, tier),
-                      font=("TkDefaultFont", 10, "bold")).pack(anchor="w", pady=(8, 2))
-            row = ttk.Frame(inner)
-            row.pack(fill="x")
-            col = 0
-            for s in SLABS:
-                if s.tier != tier:
-                    continue
-                b = ttk.Button(row, text=s.ko_label, width=8,
-                               command=lambda v=s.value: self._pick(v))
-                b.grid(row=0, column=col % 6, sticky="w", padx=2, pady=2)
-                if col % 6 == 5:
-                    row = ttk.Frame(inner)
-                    row.pack(fill="x")
-                    col = 0
-                else:
-                    col += 1
+        self.body = ttk.Frame(wrap)
+        self.body.pack(fill="both", expand=True)
+        self._slab_buttons: List[ttk.Button] = []
+        self._artifact_buttons: List[ttk.Button] = []
+        self._chosen_value: Optional[str] = cur_val
+        self._chosen_kind: str = self.kind_var.get()
+        # merged sub-state
+        self._merged_a = tk.StringVar(value="")
+        self._merged_b = tk.StringVar(value="")
+        self._merged_lvl = tk.IntVar(value=1)
 
-        btns = ttk.Frame(self)
-        btns.pack(fill="x", padx=8, pady=8)
-        ttk.Button(btns, text="비우기 (빈칸)",
-                   command=lambda: self._pick("")).pack(side="left")
-        ttk.Button(btns, text="취소", command=self.destroy).pack(side="right")
+        self._render()
+
+        bar = ttk.Frame(self)
+        bar.pack(fill="x", padx=8, pady=(0, 8))
+        ttk.Button(bar, text="확인", command=self._ok).pack(side="left")
+        ttk.Button(bar, text="취소", command=self.destroy).pack(side="right")
 
         self.grab_set()
         self.focus_set()
 
-    def _pick(self, value: str) -> None:
-        self.selected = value if value else None
+    def _render(self) -> None:
+        for c in self.body.winfo_children():
+            c.destroy()
+        k = self.kind_var.get()
+        if k == "slab":
+            self._build_slab_picker()
+        elif k == "artifact":
+            self._build_artifact_picker()
+        elif k == "merged":
+            self._build_merged_picker()
+        else:
+            ttk.Label(self.body, text="이 칸은 빈칸으로 처리됩니다.").pack(pady=20)
+
+    def _build_slab_picker(self) -> None:
+        sub = ttk.Frame(self.body)
+        sub.pack(fill="both", expand=True)
+        cnv = tk.Canvas(sub, height=320, highlightthickness=0)
+        sb = ttk.Scrollbar(sub, orient="vertical", command=cnv.yview)
+        inner = ttk.Frame(cnv)
+        inner.bind("<Configure>", lambda e: cnv.configure(scrollregion=cnv.bbox("all")))
+        cnv.create_window((0, 0), window=inner, anchor="nw")
+        cnv.configure(yscrollcommand=sb.set)
+        cnv.pack(side="left", fill="both", expand=True)
+        sb.pack(side="right", fill="y")
+        by_tier: Dict[str, List] = {}
+        for s in SLABS:
+            by_tier.setdefault(s.tier, []).append(s)
+        for tier in sorted(by_tier, key=lambda t: TIER_ORDER.get(t, 99)):
+            ttk.Label(inner, text=TIER_LABEL.get(tier, tier),
+                      font=("TkDefaultFont", 10, "bold")).pack(anchor="w", pady=(8, 2))
+            grid = ttk.Frame(inner)
+            grid.pack(fill="x")
+            for i, s in enumerate(by_tier[tier]):
+                b = ttk.Button(grid, text=s.ko_label, width=8,
+                               command=lambda v=s.value: self._pick_slab(v))
+                b.grid(row=i // 6, column=i % 6, padx=2, pady=2, sticky="w")
+
+    def _build_artifact_picker(self) -> None:
+        sub = ttk.Frame(self.body)
+        sub.pack(fill="both", expand=True)
+        ttk.Label(sub, text=(
+            f"아티팩트 {len(ARTIFACTS)}종. 한글명으로 검색:"
+        )).pack(anchor="w")
+        sv = tk.StringVar()
+        ttk.Entry(sub, textvariable=sv).pack(fill="x", pady=2)
+        list_frame = ttk.Frame(sub)
+        list_frame.pack(fill="both", expand=True)
+        lb = tk.Listbox(list_frame, height=14)
+        lb.pack(side="left", fill="both", expand=True)
+        sb = ttk.Scrollbar(list_frame, orient="vertical", command=lb.yview)
+        sb.pack(side="right", fill="y")
+        lb.configure(yscrollcommand=sb.set)
+
+        items = sorted(ARTIFACTS, key=lambda a: (TIER_ORDER.get(a.tier, 99), a.ko_label))
+
+        def refresh(*_a):
+            lb.delete(0, "end")
+            q = sv.get().strip()
+            for a in items:
+                if not q or q in a.ko_label or q in a.value:
+                    lb.insert("end", f"[{TIER_LABEL.get(a.tier, a.tier)}] {a.ko_label}")
+
+        sv.trace_add("write", refresh)
+        refresh()
+
+        def on_pick(_e=None):
+            sel = lb.curselection()
+            if not sel:
+                return
+            label = lb.get(sel[0])
+            # match by Korean label
+            ko = label.split("] ", 1)[1] if "] " in label else label
+            for a in ARTIFACTS:
+                if a.ko_label == ko:
+                    self._chosen_value = a.value
+                    self._chosen_kind = "artifact"
+                    return
+        lb.bind("<<ListboxSelect>>", on_pick)
+
+    def _build_merged_picker(self) -> None:
+        sub = ttk.Frame(self.body, padding=4)
+        sub.pack(fill="both", expand=True)
+        ttk.Label(sub, text=(
+            "합쳐진 박스(?)에 어떤 두 석판이 들어갔는지 고르고, 누적 레벨을 지정하세요.\n"
+            "선택한 정보로 결과 이미지에 합쳐진 형태가 표시됩니다."
+        ), justify="left").pack(anchor="w", pady=(0, 6))
+
+        slab_values = [s.value for s in SLABS]
+        slab_labels = {s.value: f"{s.ko_label} ({s.value})" for s in SLABS}
+
+        def labelled(v: str) -> str:
+            return slab_labels.get(v, v)
+
+        rowA = ttk.Frame(sub); rowA.pack(fill="x", pady=2)
+        ttk.Label(rowA, text="첫 번째 석판:", width=14).pack(side="left")
+        ttk.OptionMenu(rowA, self._merged_a, "",
+                       *[""] + [labelled(v) for v in slab_values]).pack(side="left", fill="x", expand=True)
+
+        rowB = ttk.Frame(sub); rowB.pack(fill="x", pady=2)
+        ttk.Label(rowB, text="두 번째 석판:", width=14).pack(side="left")
+        ttk.OptionMenu(rowB, self._merged_b, "",
+                       *[""] + [labelled(v) for v in slab_values]).pack(side="left", fill="x", expand=True)
+
+        rowL = ttk.Frame(sub); rowL.pack(fill="x", pady=2)
+        ttk.Label(rowL, text="누적 레벨:", width=14).pack(side="left")
+        ttk.Spinbox(rowL, from_=1, to=10, textvariable=self._merged_lvl,
+                    width=6).pack(side="left")
+
+    def _pick_slab(self, value: str) -> None:
+        self._chosen_value = value
+        self._chosen_kind = "slab"
+
+    def _ok(self) -> None:
+        k = self.kind_var.get()
+        if k == "slab":
+            if not self._chosen_value:
+                messagebox.showinfo("안내", "석판을 선택하세요.")
+                return
+            self.result = {"kind": "slab", "value": self._chosen_value,
+                           "rotation": 0, "merged": None}
+        elif k == "artifact":
+            if not self._chosen_value:
+                messagebox.showinfo("안내", "아티팩트를 선택하세요.")
+                return
+            self.result = {"kind": "artifact", "value": self._chosen_value,
+                           "rotation": 0, "merged": None}
+        elif k == "merged":
+            def _val_from_label(lbl: str) -> Optional[str]:
+                if not lbl:
+                    return None
+                if "(" in lbl and lbl.endswith(")"):
+                    return lbl[lbl.rfind("(") + 1: -1]
+                return None
+            a = _val_from_label(self._merged_a.get())
+            b = _val_from_label(self._merged_b.get())
+            if not a or not b:
+                messagebox.showinfo("안내", "두 석판을 모두 선택하세요.")
+                return
+            self.result = {"kind": "merged", "value": None, "rotation": 0,
+                           "merged": {"a": a, "b": b, "level": int(self._merged_lvl.get())}}
+        else:
+            self.result = {"kind": "empty", "value": None, "rotation": 0, "merged": None}
         self.destroy()
 
 
-# ---------------------------------------------------------------------------
-# Screenshot input frame
-# ---------------------------------------------------------------------------
-
+# ---------- screenshot/game-window frame ----------
 
 class ScreenshotFrame(ttk.Frame):
-    """Capture → crop → recognize → editable preview → confirm."""
-
     def __init__(self, master, on_confirmed) -> None:
         super().__init__(master, padding=6)
         self.on_confirmed = on_confirmed
         self.slot_var = master.master.slot_var  # type: ignore[attr-defined]
         self.image: Optional[Image.Image] = None
-        self.bbox: Optional[tuple] = None
-        self.recognitions: List["Recognition"] = []  # noqa: F821 (forward ref)
-        self._thumbs: List[ImageTk.PhotoImage] = []  # keep refs
+        self.bbox: Optional[Tuple[int, int, int, int]] = None
+        self.cells: List[CellResult] = []
+        # per-slot override: dict slot_id -> {kind, value, rotation, merged}
+        self.overrides: Dict[str, dict] = {}
+        self._thumbs: List[ImageTk.PhotoImage] = []
+        self._templates_warmed = False
 
-        controls = ttk.Frame(self)
-        controls.pack(fill="x")
-        ttk.Button(controls, text="🖥 현재 화면 캡처",
-                   command=self._capture).pack(side="left")
-        ttk.Button(controls, text="📂 스크린샷 파일 열기…",
-                   command=self._open_file).pack(side="left", padx=4)
-        ttk.Button(controls, text="🔁 다시 영역 지정",
-                   command=self._reselect_bbox).pack(side="left", padx=4)
-        ttk.Button(controls, text="✅ 이 목록으로 솔버 실행",
-                   command=self._confirm).pack(side="right")
+        ctl = ttk.Frame(self)
+        ctl.pack(fill="x")
+        ttk.Button(ctl, text="🎮 게임 창 선택…", command=self._pick_window).pack(side="left")
+        ttk.Button(ctl, text="🖥 전체 화면 캡처", command=self._capture_screen).pack(side="left", padx=4)
+        ttk.Button(ctl, text="📂 파일 열기…", command=self._open_file).pack(side="left", padx=4)
+        ttk.Button(ctl, text="🔁 영역 재지정", command=self._reselect_bbox).pack(side="left", padx=4)
+        ttk.Button(ctl, text="✅ 이 구성으로 계산", command=self._confirm).pack(side="right")
 
         self.status = ttk.Label(
             self,
-            text="화면을 캡처하거나 PNG 파일을 열면 인벤토리 영역을 지정한 뒤 "
-            "자동으로 석판을 인식합니다.",
-            wraplength=460, justify="left",
+            text=(
+                "1) [게임 창 선택] 으로 Sephiria 창을 고르거나, [전체 화면 캡처]/[파일 열기] 로 이미지를 가져옵니다.\n"
+                "2) 가방 격자의 좌상단/우하단을 두 번 클릭해 영역을 지정합니다.\n"
+                "3) 자동 인식 후 잘못된 셀은 클릭해서 종류/석판/아티팩트/합쳐진(?) 으로 교정하세요."
+            ),
+            wraplength=520, justify="left",
         )
         self.status.pack(fill="x", pady=(6, 4))
 
-        # editable preview grid (scrollable)
-        self.preview_canvas = tk.Canvas(self, height=420, highlightthickness=0)
+        self.preview_canvas = tk.Canvas(self, height=440, highlightthickness=0)
         self.preview_canvas.pack(fill="both", expand=True)
         self.preview_inner = ttk.Frame(self.preview_canvas)
         self.preview_canvas.create_window((0, 0), window=self.preview_inner, anchor="nw")
@@ -229,25 +437,40 @@ class ScreenshotFrame(ttk.Frame):
             ),
         )
 
-    # ----------------------------------------------- handlers
-    def _capture(self) -> None:
+    # ----- input modes -----
+    def _pick_window(self) -> None:
+        dlg = WindowPicker(self.winfo_toplevel())
+        self.winfo_toplevel().wait_window(dlg)
+        if not dlg.selected:
+            return
+        try:
+            from .window_capture import capture_window
+            self.image = capture_window(dlg.selected)
+        except Exception as e:
+            messagebox.showerror("창 캡처 실패", str(e))
+            return
+        self.status["text"] = f"창 캡처 완료: {dlg.selected.title} ({self.image.size[0]}×{self.image.size[1]})"
+        self._pick_bbox_and_recognize()
+
+    def _capture_screen(self) -> None:
         try:
             from .capture import capture_screen
-            self.update_idletasks()
             top = self.winfo_toplevel()
-            top.withdraw()
-            top.update()
-            self.image = capture_screen(monitor=1)
-            top.deiconify()
-            self._pick_bbox_and_recognize()
+            top.withdraw(); top.update()
+            try:
+                self.image = capture_screen(monitor=1)
+            finally:
+                top.deiconify()
         except Exception as e:
-            messagebox.showerror("캡처 실패", str(e))
             self.winfo_toplevel().deiconify()
+            messagebox.showerror("캡처 실패", str(e))
+            return
+        self._pick_bbox_and_recognize()
 
     def _open_file(self) -> None:
         path = filedialog.askopenfilename(
-            title="스크린샷 PNG 선택",
-            filetypes=[("Images", "*.png *.jpg *.jpeg *.webp"), ("All files", "*.*")],
+            title="스크린샷 선택",
+            filetypes=[("Images", "*.png *.jpg *.jpeg *.webp"), ("All", "*.*")],
         )
         if not path:
             return
@@ -260,10 +483,11 @@ class ScreenshotFrame(ttk.Frame):
 
     def _reselect_bbox(self) -> None:
         if self.image is None:
-            messagebox.showinfo("안내", "먼저 화면 캡처 또는 파일 열기를 해주세요.")
+            messagebox.showinfo("안내", "먼저 캡처 또는 파일 열기를 해주세요.")
             return
         self._pick_bbox_and_recognize()
 
+    # ----- pipeline -----
     def _pick_bbox_and_recognize(self) -> None:
         assert self.image is not None
         dlg = CropDialog(self.winfo_toplevel(), self.image)
@@ -271,122 +495,172 @@ class ScreenshotFrame(ttk.Frame):
         if not dlg.bbox:
             return
         self.bbox = dlg.bbox
-        self.status["text"] = "석판 인식 중…"
+        self.overrides.clear()
+        self.status["text"] = "템플릿 준비 + 셀 인식 중…"
         self.update_idletasks()
         threading.Thread(target=self._recognize_thread, daemon=True).start()
 
     def _recognize_thread(self) -> None:
         try:
-            from .screenshot import recognize
+            if not self._templates_warmed:
+                # First call may download a lot — keep artifacts on (user wants them)
+                warm_templates(include_artifacts=True)
+                self._templates_warmed = True
             slot_num = int(round(self.slot_var.get()))
-            # save image to temp + call recognizer on file path (recognize expects path)
-            import tempfile
-            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
-                self.image.save(f.name)  # type: ignore[union-attr]
-                tmp = f.name
-            try:
-                recs = recognize(tmp, self.bbox, slot_num=slot_num)
-            finally:
-                try:
-                    os.unlink(tmp)
-                except OSError:
-                    pass
-            self.after(0, self._show_recognitions, recs)
+            cells = recognize_image(
+                self.image, self.bbox,
+                slot_num=slot_num, include_artifacts=True,
+            )
+            self.after(0, self._show_cells, cells)
         except Exception as e:
             self.after(0, lambda: messagebox.showerror("인식 실패", str(e)))
 
-    def _show_recognitions(self, recs: list) -> None:
-        self.recognitions = recs
-        for child in self.preview_inner.winfo_children():
-            child.destroy()
+    def _show_cells(self, cells: List[CellResult]) -> None:
+        self.cells = cells
+        for c in self.preview_inner.winfo_children():
+            c.destroy()
         self._thumbs.clear()
 
-        # group into 6-wide grid
-        from .slabs import GRID_COLS
-        slot_to_rec = {r.slot_id: r for r in recs}
         slot_num = int(round(self.slot_var.get()))
-        from .slabs import generate_grid_config
         grid = generate_grid_config(slot_num)
+        slot_to_cell = {c.slot_id: c for c in cells}
+
+        kind_counts = {"slab": 0, "artifact": 0, "empty": 0, "unknown": 0, "merged": 0}
         for row_cfg in grid:
             y = row_cfg["rows"]
             for x in range(GRID_COLS):
                 if x >= row_cfg["cols"]:
-                    # filler
-                    blank = ttk.Frame(self.preview_inner, width=64, height=64)
-                    blank.grid(row=y, column=x, padx=2, pady=2)
+                    tk.Frame(self.preview_inner, width=64, height=80,
+                             bg=self.preview_inner.winfo_toplevel()["bg"]) \
+                        .grid(row=y, column=x, padx=2, pady=2)
                     continue
                 slot_id = f"{y}-{x}"
-                rec = slot_to_rec.get(slot_id)
-                value = rec.value if rec else None
-                self._make_cell(y, x, slot_id, value, rec)
+                cell = slot_to_cell.get(slot_id)
+                ov = self.overrides.get(slot_id)
+                effective = self._effective(cell, ov)
+                kind_counts[effective["kind"]] = kind_counts.get(effective["kind"], 0) + 1
+                self._make_cell(y, x, slot_id, effective)
 
-        recognised = sum(1 for r in recs if r.value)
-        self.status["text"] = (
-            f"인식된 석판 {recognised}개 / 슬롯 {len(recs)}개. "
-            "잘못 인식된 칸은 셀을 클릭해서 수정하세요."
+        msg = (
+            f"석판 {kind_counts.get('slab', 0)} · 아티팩트 {kind_counts.get('artifact', 0)} · "
+            f"빈칸 {kind_counts.get('empty', 0)} · 합쳐진(?) {kind_counts.get('merged', 0)} · "
+            f"미인식 {kind_counts.get('unknown', 0)}\n"
+            "셀을 클릭하면 종류/값을 교정할 수 있습니다. 끝나면 [이 구성으로 계산]."
         )
+        self.status["text"] = msg
 
-    def _make_cell(self, y: int, x: int, slot_id: str, value: Optional[str],
-                   rec) -> None:
-        frame = tk.Frame(
-            self.preview_inner, bd=1, relief="solid", width=72, height=78,
-            bg="#2c1a2a",
-        )
+    def _effective(self, cell: Optional[CellResult], ov: Optional[dict]) -> dict:
+        if ov is not None:
+            return ov
+        if cell is None:
+            return {"kind": "empty", "value": None, "rotation": 0, "merged": None, "score": 0.0}
+        return {
+            "kind": cell.kind, "value": cell.value,
+            "rotation": cell.rotation, "merged": None, "score": cell.score,
+        }
+
+    def _make_cell(self, y: int, x: int, slot_id: str, info: dict) -> None:
+        kind = info.get("kind", "empty")
+        value = info.get("value")
+        rot = info.get("rotation", 0) or 0
+        score = info.get("score", 0.0)
+        border = {"slab": "#7a4a8a", "artifact": "#6a82c8", "merged": "#c870c0",
+                  "unknown": "#c8a050", "empty": "#3a2a3a"}.get(kind, "#3a2a3a")
+        frame = tk.Frame(self.preview_inner, bd=2, relief="solid",
+                         width=72, height=82, bg="#2c1a2a",
+                         highlightbackground=border, highlightthickness=2)
         frame.grid(row=y, column=x, padx=2, pady=2)
         frame.grid_propagate(False)
-        score_txt = f"{rec.score:.0f}" if rec else "-"
-        if value:
-            thumb = _slab_thumb(value, size=48)
+
+        if kind == "slab" and value:
+            thumb = _slab_thumb(value, size=44)
+            if thumb is not None:
+                if rot:
+                    # generate rotated thumb on the fly
+                    base = fetch_slab_image(SLABS_BY_VALUE[value].image)
+                    if base is not None:
+                        base = base.resize((44, 44)).rotate(-90 * rot, expand=False)
+                        thumb = ImageTk.PhotoImage(base)
+                self._thumbs.append(thumb)
+                lbl = tk.Label(frame, image=thumb, bg="#2c1a2a")
+            else:
+                lbl = tk.Label(frame, text=SLABS_BY_VALUE[value].ko_label,
+                               fg="#fff", bg="#2c1a2a")
+        elif kind == "artifact" and value:
+            thumb = _artifact_thumb(value, size=44)
             if thumb is not None:
                 self._thumbs.append(thumb)
                 lbl = tk.Label(frame, image=thumb, bg="#2c1a2a")
             else:
-                slab = SLABS_BY_VALUE.get(value)
-                lbl = tk.Label(frame, text=slab.ko_label if slab else value,
-                               fg="#fff", bg="#2c1a2a")
+                a = ARTIFACTS_BY_VALUE.get(value)
+                lbl = tk.Label(frame, text=a.ko_label if a else value,
+                               fg="#9bf", bg="#2c1a2a")
+        elif kind == "merged":
+            lbl = tk.Label(frame, text="?", font=("TkDefaultFont", 26, "bold"),
+                           fg="#ffaaff", bg="#2c1a2a")
+        elif kind == "unknown":
+            lbl = tk.Label(frame, text="?", font=("TkDefaultFont", 26, "bold"),
+                           fg="#ffd070", bg="#2c1a2a")
         else:
-            lbl = tk.Label(frame, text="(빈칸)", fg="#888", bg="#2c1a2a")
+            lbl = tk.Label(frame, text="·", fg="#666", bg="#2c1a2a")
         lbl.pack(expand=True)
-        slab = SLABS_BY_VALUE.get(value) if value else None
-        cap = tk.Label(
-            frame,
-            text=f"{slab.ko_label if slab else '—'}  · {score_txt}",
-            fg="#cfcfcf", bg="#2c1a2a", font=("TkDefaultFont", 8),
-        )
-        cap.pack(fill="x")
 
-        def click(_e=None, sid=slot_id):
-            self._edit_cell(sid)
-        for w in (frame, lbl, cap):
-            w.bind("<Button-1>", click)
+        caption = ""
+        if kind == "slab" and value:
+            caption = SLABS_BY_VALUE[value].ko_label
+            if rot:
+                caption += f" ↻{rot}"
+        elif kind == "artifact" and value:
+            a = ARTIFACTS_BY_VALUE.get(value)
+            caption = a.ko_label if a else value
+        elif kind == "merged":
+            m = info.get("merged") or {}
+            la = SLABS_BY_VALUE.get(m.get("a", "")) if m else None
+            lb = SLABS_BY_VALUE.get(m.get("b", "")) if m else None
+            caption = f"{la.ko_label if la else '?'}+{lb.ko_label if lb else '?'} L{m.get('level', 1)}" if m else "합쳐진 박스"
+        elif kind == "unknown":
+            caption = f"미인식  {score:.2f}"
+        else:
+            caption = "빈칸"
+        tk.Label(frame, text=caption, fg="#cfcfcf", bg="#2c1a2a",
+                 font=("TkDefaultFont", 7)).pack(fill="x")
 
-    def _edit_cell(self, slot_id: str) -> None:
-        cur: Optional[str] = None
-        for r in self.recognitions:
-            if r.slot_id == slot_id:
-                cur = r.value
-                break
-        dlg = SlabPicker(self.winfo_toplevel(), current=cur)
+        def on_click(_e=None, sid=slot_id):
+            self._edit(sid)
+        for w in (frame, lbl):
+            w.bind("<Button-1>", on_click)
+
+    def _edit(self, slot_id: str) -> None:
+        cell = next((c for c in self.cells if c.slot_id == slot_id), None)
+        dlg = CellEditor(self.winfo_toplevel(), cell)
         self.winfo_toplevel().wait_window(dlg)
-        # apply
-        for r in self.recognitions:
-            if r.slot_id == slot_id:
-                r.value = dlg.selected
-                break
-        self._show_recognitions(self.recognitions)
+        if dlg.result is None:
+            return
+        # store override, then re-render
+        self.overrides[slot_id] = {**dlg.result, "score": 1.0}
+        self._show_cells(self.cells)
 
     def _confirm(self) -> None:
-        if not self.recognitions:
-            messagebox.showinfo("안내", "먼저 화면을 캡처하고 영역을 지정하세요.")
+        if not self.cells and not self.overrides:
+            messagebox.showinfo("안내", "먼저 캡처 + 영역 지정을 해주세요.")
             return
-        basket = [r.value for r in self.recognitions if r.value]
+        basket: List[str] = []
+        for cell in self.cells:
+            ov = self.overrides.get(cell.slot_id)
+            eff = self._effective(cell, ov)
+            if eff["kind"] == "slab" and eff.get("value"):
+                basket.append(eff["value"])
+            elif eff["kind"] == "merged":
+                m = eff.get("merged") or {}
+                # treat a merged box as having both its component slabs in the basket
+                if m.get("a"):
+                    basket.append(m["a"])
+                if m.get("b"):
+                    basket.append(m["b"])
         self.on_confirmed(basket)
 
 
-# ---------------------------------------------------------------------------
-# Manual input frame (tier-grouped +/-)
-# ---------------------------------------------------------------------------
-
+# ---------- manual input frame ----------
 
 class ManualFrame(ttk.Frame):
     def __init__(self, master, on_changed) -> None:
@@ -413,24 +687,19 @@ class ManualFrame(ttk.Frame):
 
         row = 0
         for tier in sorted(by_tier, key=lambda t: TIER_ORDER.get(t, 99)):
-            ttk.Label(
-                inner, text=TIER_LABEL.get(tier, tier),
-                font=("TkDefaultFont", 10, "bold"),
-            ).grid(row=row, column=0, columnspan=4, sticky="w", pady=(8, 2))
+            ttk.Label(inner, text=TIER_LABEL.get(tier, tier),
+                      font=("TkDefaultFont", 10, "bold")) \
+                .grid(row=row, column=0, columnspan=4, sticky="w", pady=(8, 2))
             row += 1
             for slab in by_tier[tier]:
-                ttk.Label(inner, text=slab.ko_label, width=8).grid(
-                    row=row, column=0, sticky="w"
-                )
+                ttk.Label(inner, text=slab.ko_label, width=8).grid(row=row, column=0, sticky="w")
                 ttk.Button(inner, text="−", width=2,
-                           command=lambda v=slab.value: self._change(v, -1)
-                           ).grid(row=row, column=1)
+                           command=lambda v=slab.value: self._change(v, -1)).grid(row=row, column=1)
                 lbl = ttk.Label(inner, text="0", width=3, anchor="center")
                 lbl.grid(row=row, column=2)
                 self.count_labels[slab.value] = lbl
                 ttk.Button(inner, text="+", width=2,
-                           command=lambda v=slab.value: self._change(v, 1)
-                           ).grid(row=row, column=3)
+                           command=lambda v=slab.value: self._change(v, 1)).grid(row=row, column=3)
                 row += 1
 
     def _change(self, v: str, d: int) -> None:
@@ -451,10 +720,7 @@ class ManualFrame(ttk.Frame):
         return out
 
 
-# ---------------------------------------------------------------------------
-# Main app
-# ---------------------------------------------------------------------------
-
+# ---------- main app ----------
 
 class App(tk.Tk):
     def __init__(self) -> None:
@@ -470,7 +736,6 @@ class App(tk.Tk):
         self.solving = False
         self.preview_image: Optional[ImageTk.PhotoImage] = None
         self.last_solution = None
-
         self._build()
 
     def _build(self) -> None:
@@ -480,16 +745,14 @@ class App(tk.Tk):
         root.columnconfigure(1, weight=3)
         root.rowconfigure(0, weight=1)
 
-        # LEFT: notebook with manual + screenshot input
         nb = ttk.Notebook(root)
         nb.grid(row=0, column=0, sticky="nsew", padx=(0, 6))
+        self.screenshot = ScreenshotFrame(nb, on_confirmed=self._on_screenshot_confirmed)
+        nb.add(self.screenshot, text="게임창/스크린샷")
         self.manual = ManualFrame(nb, on_changed=self._on_manual_changed)
         nb.add(self.manual, text="수동 선택")
-        self.screenshot = ScreenshotFrame(nb, on_confirmed=self._on_screenshot_confirmed)
-        nb.add(self.screenshot, text="스크린샷")
         self.nb = nb
 
-        # RIGHT
         right = ttk.Frame(root)
         right.grid(row=0, column=1, sticky="nsew")
         right.columnconfigure(0, weight=1)
@@ -506,13 +769,11 @@ class App(tk.Tk):
         self.slot_label.grid(row=0, column=2, sticky="w")
 
         ttk.Button(ctl, text="비우기", command=self._clear_basket).grid(
-            row=1, column=0, pady=(8, 0), sticky="w"
-        )
+            row=1, column=0, pady=(8, 0), sticky="w")
         self.solve_btn = ttk.Button(ctl, text="최적 배치 계산", command=self._solve)
         self.solve_btn.grid(row=1, column=1, pady=(8, 0), sticky="ew", padx=6)
         ttk.Button(ctl, text="이미지 저장…", command=self._save).grid(
-            row=1, column=2, pady=(8, 0), sticky="e"
-        )
+            row=1, column=2, pady=(8, 0), sticky="e")
 
         summary = ttk.Frame(right)
         summary.grid(row=1, column=0, sticky="ew", pady=(6, 0))
@@ -523,12 +784,11 @@ class App(tk.Tk):
         preview_frame.grid(row=2, column=0, sticky="nsew", pady=(6, 0))
         self.preview = ttk.Label(
             preview_frame, anchor="center",
-            text="좌측에서 석판을 추가하거나 스크린샷을 분석한 뒤 "
-            "'최적 배치 계산'을 눌러주세요.",
+            text="좌측에서 인벤토리를 가져오거나 석판을 추가한 뒤 "
+                 "'최적 배치 계산'을 눌러주세요.",
         )
         self.preview.pack(fill="both", expand=True)
 
-    # -------------------------------------------------------- callbacks
     def _on_manual_changed(self) -> None:
         self.basket = self.manual.basket()
         self.summary_var.set(f"선택된 석판: {len(self.basket)}개  (수동)")
@@ -536,10 +796,8 @@ class App(tk.Tk):
     def _on_screenshot_confirmed(self, basket: List[str]) -> None:
         self.basket = list(basket)
         self.summary_var.set(f"선택된 석판: {len(self.basket)}개  (스크린샷)")
-        self.nb.select(0)  # back to first tab? Keep on screenshot tab actually
-        messagebox.showinfo(
-            "확정", f"{len(self.basket)}개를 가져왔습니다. '최적 배치 계산'을 누르세요."
-        )
+        messagebox.showinfo("확정",
+                            f"{len(self.basket)}개를 가져왔습니다. '최적 배치 계산'을 누르세요.")
 
     def _on_slot(self, _evt) -> None:
         v = int(round(self.slot_var.get()))
@@ -555,27 +813,19 @@ class App(tk.Tk):
         if self.solving:
             return
         if not self.basket:
-            messagebox.showinfo(
-                "안내",
-                "먼저 '수동 선택'에서 석판을 추가하거나, "
-                "'스크린샷' 탭에서 화면을 분석하고 확정해주세요.",
-            )
+            messagebox.showinfo("안내",
+                                "먼저 인벤토리를 가져오거나 수동 선택으로 석판을 추가해주세요.")
             return
         slot_num = int(round(self.slot_var.get()))
         basket = list(self.basket)
         if len(basket) > slot_num:
-            if not messagebox.askyesno(
-                "확인",
-                f"슬롯({slot_num})보다 석판({len(basket)})이 많습니다.\n"
-                "초과분은 무시하고 계산할까요?",
-            ):
+            if not messagebox.askyesno("확인",
+                                       f"슬롯({slot_num})보다 석판({len(basket)})이 많습니다. 초과분 무시?"):
                 return
         self.solving = True
         self.solve_btn["state"] = "disabled"
         self.score_var.set("score: 계산 중…")
-        threading.Thread(
-            target=self._solve_worker, args=(basket, slot_num), daemon=True
-        ).start()
+        threading.Thread(target=self._solve_worker, args=(basket, slot_num), daemon=True).start()
 
     def _solve_worker(self, basket: List[str], slot_num: int) -> None:
         try:
@@ -620,8 +870,7 @@ def main() -> int:
     try:
         app = App()
     except tk.TclError as e:
-        print(f"GUI를 띄울 수 없습니다 ({e}). CLI 모드를 시도하세요:",
-              file=sys.stderr)
+        print(f"GUI를 띄울 수 없습니다 ({e}). CLI 모드를 시도하세요:", file=sys.stderr)
         print("  python -m sephiria_inv --help", file=sys.stderr)
         return 1
     app.mainloop()