@@ -112,7 +112,7 @@ def add(self) -> Selection | None:
         if sc is None or sess is None or g is None:
             return None
         if sess.base_dir is None:
-            self.message = "save the document first: the shape is written into its assets/"
+            self.message = "save the document first (File > Save): the shape goes into its assets/"
             return None
         kind, at = self.kind, tuple(self.placement())
         try:
@@ -151,7 +151,7 @@ def add(self) -> Selection | None:
             self.message = f"refused: {e}"
             (sess.base_dir / name).unlink(missing_ok=True)
             return None
-        self.message = f"added {Path(name).name} ({len(t)} triangles) into {g.label} as {name}"
+        self.message = f"added {Path(name).name} ({len(t)} triangles) into {g.label}"
         warnings = sess.warnings()
         if warnings:
             self.message += "   [!] " + warnings[0]
 
@@ -72,15 +72,14 @@ def register(groups: Groups) -> None:
 
 
 def _game(args: argparse.Namespace) -> Extracted:
-    from mhfu.files import Extracted
+    from mhfu_studio.shell import places
 
-    return Extracted.find(args.data)
+    return places.extracted(given=args.data)
 
 
 def inject(args: argparse.Namespace) -> int:
     from mhfu import addresses as a
     from mhfu.memory import Live
-    from ppsspp_debug import Client
 
     from mhfu_studio.stage import live
     from mhfu_studio.stage import ops as O
@@ -118,7 +117,7 @@ def inject(args: argparse.Namespace) -> int:
         pushes.append((p, catch or 0.0))
     if args.dry:
         return 0
-    with Client.connect(port=args.port) as client:
+    with live.connect(args.port) as client:
         mem = Live(client)
         for p, catch in pushes:
             label = p.stage.label
@@ -127,7 +126,7 @@ def inject(args: argparse.Namespace) -> int:
             elif args.restore:
                 live.restore(mem, p.stage)
             else:
-                undo = base / ".inject" / f"{label}_collision_undo.json"
+                undo = live.undo_path(p.stage.number)
                 live.run(client, mem, p, catch_for=catch, hold_for=args.hold, undo_file=undo)
     return 0
 
 
@@ -2,9 +2,10 @@
 # SPDX-FileCopyrightText: 2026 sp00ktober
 """The map table as rows of sections, entry area first; the village is row 0.
 
-Names come only from the game: three rows and the snowy bank are labelled, everything else
-is `row N` / `stNNN`. Day/night twins share their collision bytes, paired by hash, not by an
-offset that holds for one map only.
+On screen a row is a "map" and a section an "area" (`row_name`, `stage_title`). Names come
+only from the game: three maps and the snowy areas are named, everything else is `Map N` /
+`Area stNNN`. Day/night twins share their collision bytes, paired by hash, not by an offset
+that holds for one map only.
 """
 
 from __future__ import annotations
@@ -30,7 +31,7 @@
 
 STAGE_NAMES: dict[int, str] = {
     139: "Pokke village",
-    66: "Pokke village (twin of st139)",
+    66: "Pokke village twin",
     98: "Snowy base camp",
     99: "Snowy area 1",
     95: "Snowy area 2",
@@ -41,28 +42,40 @@
     96: "Snowy area 7",
     97: "Snowy area 8",
     6: "Snowy secret area",
-    107: "Snowy base camp (night)",
-    108: "Snowy area 1 (night)",
-    104: "Snowy area 2 (night)",
-    103: "Snowy area 3 (night)",
-    101: "Snowy area 4 (night)",
-    102: "Snowy area 5 (night)",
-    109: "Snowy area 6 (night)",
-    105: "Snowy area 7 (night)",
-    106: "Snowy area 8 (night)",
-    15: "Snowy secret area (night)",
+    107: "Snowy base camp at night",
+    108: "Snowy area 1 at night",
+    104: "Snowy area 2 at night",
+    103: "Snowy area 3 at night",
+    101: "Snowy area 4 at night",
+    102: "Snowy area 5 at night",
+    109: "Snowy area 6 at night",
+    105: "Snowy area 7 at night",
+    106: "Snowy area 8 at night",
+    15: "Snowy secret area at night",
 }
 
 ORPHAN_STAGES = (126, 198, 199, 200)
 """Complete maps no row references: a cut section and three unconnected arenas."""
 
 
+def stage_id(stage: int) -> str:
+    return f"st{stage:03d}"
+
+
 def stage_name(stage: int) -> str:
-    return STAGE_NAMES.get(stage, f"st{stage:03d}")
+    """`Pokke village`, or `Area st140` for a stage the game gives no name."""
+    return STAGE_NAMES.get(stage, f"Area {stage_id(stage)}")
+
+
+def stage_title(stage: int) -> str:
+    """`Pokke village (st139)`; `Area st140`, its id once, for a stage with no name."""
+    name = STAGE_NAMES.get(stage)
+    return f"{name} ({stage_id(stage)})" if name else stage_name(stage)
 
 
 def row_name(row: int) -> str:
-    return ROW_NAMES.get(row, f"row {row}")
+    """A row as the map it is: `Snowy Mountains (day)`, or `Map 7`."""
+    return ROW_NAMES.get(row, f"Map {row}")
 
 
 @dataclass
@@ -192,5 +205,5 @@ def describe(self, row: int | None = None) -> str:
             for s in r.sections:
                 entry = "entry " if s.is_entry else "      "
                 stub = "" if s.present else "(placeholder)"
-                lines.append(f"   [{s.slot:2d}] st{s.stage:03d}  {s.name:<26} {entry}{stub}")
+                lines.append(f"   [{s.slot:2d}] {stage_title(s.stage):<33} {entry}{stub}")
         return "\n".join(lines)
@@ -24,7 +24,7 @@
 from mhfu_studio.stage import collision, mesh, textures
 from mhfu_studio.stage import ops as O
 
-from .scene import CLIMB_MAX_UP, Array, Key, MapScene, Point
+from .scene import CLASS_NAMES, CLIMB_MATERIALS, Array, Key, MapScene, Point, group_name
 
 GROUP, OBJECT, FACE, COLLISION = "group", "object", "face", "collision"
 KINDS = (GROUP, OBJECT, FACE, COLLISION)
@@ -34,6 +34,8 @@
 SHORT_WALL = 100.0
 """A climbable triangle shorter than this is worth a warning."""
 KEEPS = ("did-not-fit",)
+#: a collision chunk in words: 1 holds the floor, 0 the walls and ceilings
+CHUNK_WORDS = {0: "wall", 1: "floor"}
 """Error codes a commit keeps (a partial pack still draws), shown as warnings."""
 
 
@@ -241,15 +243,16 @@ def refresh(self, scene: MapScene) -> Selection:
                 out.parts[k] = [int(f) for f in np.nonzero(np.isin(g.triangles, ids).all(1))[0]]
         return out
 
-    def describe(self, scene: MapScene) -> str:
+    def describe(self) -> str:
+        """In words: "2 objects in group 8", "group 8", "3 triangles in 2 groups"."""
         if self.empty:
             return "nothing selected"
-        bits = []
-        for k, ids in self.vertices.items():
-            n = len(self.parts.get(k, []))
-            what = {GROUP: "the whole group", OBJECT: f"{n} object(s)", FACE: f"{n} face(s)"}
-            bits.append(f"{scene.group(*k).label}: {what[self.kind]}, {len(ids)} vertices")
-        return "; ".join(bits)
+        ks = list(self.vertices)
+        where = group_name(ks[0]) if len(ks) == 1 else count(len(ks), "group")
+        if self.kind == GROUP:
+            return where
+        n = sum(len(self.parts.get(k, [])) for k in ks)
+        return f"{count(n, 'object' if self.kind == OBJECT else 'triangle')} in {where}"
 
 
 @dataclass
@@ -293,10 +296,26 @@ def centroid(self, scene: MapScene) -> Array:
         return out
 
     def describe(self, scene: MapScene) -> str:
+        """In words, with the kinds: "3 collision triangles: 2 wall, 1 climbable"."""
         if self.empty:
             return "no collision triangle selected"
-        by = sorted(self.by_chunk().items())
-        return "collision: " + ", ".join(f"chunk {c} x{len(t)}" for c, t in by)
+        kinds: dict[str, int] = {}
+        for c, t in self.tris:
+            k = CLASS_NAMES[str(scene.chunk(c).klass[t])]
+            kinds[k] = kinds.get(k, 0) + 1
+        what = ", ".join(f"{n} {k}" for k, n in kinds.items())
+        if len(kinds) == 1:
+            what = next(iter(kinds))
+        return f"{count(len(self), 'collision triangle')}: {what}"
+
+
+def count(n: int, noun: str) -> str:
+    return f"{n} {noun}{'' if n == 1 else 's'}"
+
+
+def triangle_name(chunk: int, tri: int) -> str:
+    """`wall triangle 12`: a collision triangle as a person points at it."""
+    return f"{CHUNK_WORDS.get(chunk, f'chunk {chunk}')} triangle {tri}"
 
 
 def by_chunk(tris: Iterable[Pair]) -> dict[int, list[int]]:
@@ -340,55 +359,68 @@ def op_key(op: Mapping[str, Any]) -> Key | None:
 
 
 def describe_op(op: Mapping[str, Any]) -> str:
-    """One line per op, in the user's terms."""
+    """One line per op, in plain words: "group 8: moved by 0, 100, 0"."""
     k = str(op.get("op"))
     key = op_key(op)
-    where = f"sub{key[0]}.g{key[1]}" if key else "collision"
-    if k == "transform":
-        by = [round(v) for v in op.get("by", (0, 0, 0))]
-        rot = [round(v) for v in op.get("rotate", (0, 0, 0))]
-        sc = [round(v, 2) for v in op.get("scale", (1, 1, 1))]
-        n = len(op.get("vertices", []))
-        return f"{k:<9} {where:<9} {n:4d} v  by {by} rot {rot} scale {sc}"
-    if k == "move":
-        return f"{k:<9} {where:<9} by {op.get('by')}"
+    where = group_name(key) if key else "collision"
+    if k in ("transform", "move"):
+        by, rot = op.get("by", (0, 0, 0)), op.get("rotate", (0, 0, 0))
+        sc = op.get("scale", (1, 1, 1))
+        bits = [f"moved by {_xyz(by)}"] if any(round(v) for v in by) else []
+        if any(round(v) for v in rot):
+            bits.append(f"turned {_xyz(rot)}\N{DEGREE SIGN}")
+        if any(round(v, 2) != 1 for v in sc):
+            bits.append(f"scaled \N{MULTIPLICATION SIGN}{_xyz(sc, 2)}")
+        return f"{where}: {'; '.join(bits) or 'no change'}"
     if k == "pack":
-        solid = " +collider" if op.get("solid") else ""
-        n = len(op.get("prims") or [])
-        return f"{k:<9} {where:<9} {Path(str(op.get('obj', '?'))).name} into {n} prims{solid}"
+        name = Path(str(op.get("obj", "?"))).name
+        return f"added {name} into {where}" + (", solid" if op.get("solid") else "")
     if k == "clear":
-        what = f"{len(op['prims'])} prims" if op.get("prims") else "whole group"
-        return f"{k:<9} {where:<9} {what}"
+        n = len(op.get("prims") or [])
+        return f"removed from {where} ({count(n, 'drawing slot')})" if n else f"removed {where}"
     if k == "material":
-        bits = [f"texture {op['texture']}"] if "texture" in op else []
+        bits = [f"texture slot {op['texture']}"] if "texture" in op else []
         if "rgba" in op:
-            bits.append(f"rgba {tuple(op['rgba'])}")
-        return f"{k:<9} {where:<9} {', '.join(bits) or '?'}"
+            bits.append(f"colour {_xyz(op['rgba'])}")
+        return f"{where}: {', '.join(bits) or 'material'}"
     if k == "texture":
         if "png" in op:
-            src = str(op["png"])
+            src = Path(str(op["png"])).name
         elif "from" in op:
-            src = f"st{op['from']['stage']:03d} slot {op['from']['slot']}"
+            src = f"slot {op['from']['slot']} of st{op['from']['stage']:03d}"
         else:
-            src = f"rgb {tuple(op.get('rgb', ()))}"
-        return f"{k:<9} slot {op.get('slot')!s:<4} <- {src}"
+            src = f"flat colour {_xyz(op.get('rgb', ()))}"
+        return f"texture slot {op.get('slot')}: {src}"
     if k == "collision":
         if "solid_box" in op:
-            return "collision  box collider"
+            return "added a box collider"
         if op.get("add"):
-            chunk = "auto" if op.get("chunk") is None else op["chunk"]
-            return f"collision  chunk {chunk} +{len(op['add'])} triangle(s){_flags_text(op)}"
+            return f"added {count(len(op['add']), 'collision triangle')}{_flags_text(op)}"
         n = ("tri" in op) + len(op.get("tris", []))
-        what = "delete" if op.get("delete") else ("move" if "verts" in op else "flags")
-        return f"collision  chunk {op.get('chunk', 1)} {what} x{n}{_flags_text(op)}"
-    return f"{k:<9} {where}"
+        tris = count(n, f"{CHUNK_WORDS.get(op.get('chunk', 1), 'collision')} triangle")
+        if op.get("delete"):
+            return f"deleted {tris}"
+        if "verts" in op:
+            return f"moved {tris}"
+        return f"changed {tris}{_flags_text(op)}"
+    return f"{k} {where}"
+
+
+def _xyz(v: Sequence[float], digits: int = 0) -> str:
+    return ", ".join(f"{round(float(x), digits):g}" for x in v)
 
 
 def _flags_text(op: Mapping[str, Any]) -> str:
+    """The flags an op sets, climbing named."""
     fl = op.get("flags") or {}
     if not isinstance(fl, Mapping) or not fl:
         return ""
-    return "  " + " ".join(f"{k}={v}" for k, v in fl.items())
+    if set(fl) == {"material"}:
+        if fl["material"] in CLIMB_MATERIALS:
+            return ": climbable"
+        if fl["material"] == 0:
+            return ": not climbable"
+    return ": " + ", ".join(f"{k} {v}" for k, v in fl.items())
 
 
 class EditSession:
@@ -817,17 +849,13 @@ def climb_warnings(self, tris: Iterable[Pair]) -> list[str]:
         for c, t in tris:
             ch = self.scene.chunk(c)
             if not ch.vertical(t):
-                ny = abs(float(ch.normals[t][1]))
-                out.append(
-                    f"chunk {c} tri {t} is not near-vertical (|n.y| = {ny:.2f} >="
-                    f" {CLIMB_MAX_UP:.2f}): the material will not make it climbable"
-                )
+                out.append(f"{triangle_name(c, t)} is too flat to climb")
             h = float(ch.verts[t][:, 1].max() - ch.verts[t][:, 1].min())
             if h < SHORT_WALL:
-                out.append(f"chunk {c} tri {t} is only {h:.0f} units tall")
+                out.append(f"{triangle_name(c, t)} is only {h:.0f} units tall: too short to climb")
             mats.add(int(ch.material[t]))
         if len(mats) > 1:
-            out.append(f"the patch mixes materials {sorted(mats)}")
+            out.append(f"the selected triangles mix materials {sorted(mats)}")
         return out
 
     # checks
 
@@ -26,7 +26,7 @@
 from mhfu_studio.stage.file import MESHES, TEXTURES, StageFile
 from mhfu_studio.stage.textures import UNTEXTURED
 
-from .atlas import stage_name
+from .atlas import stage_name, stage_title
 
 Array = npt.NDArray[Any]
 Point = Sequence[float] | Array
@@ -49,12 +49,20 @@
 
 FLOOR, WALL, CLIMB, SINK, WADE = "floor", "wall", "climb", "sink", "wade"
 CLASSES = (FLOOR, WALL, CLIMB, SINK, WADE)
+#: a class as the panels name it
+CLASS_NAMES = {FLOOR: "floor", WALL: "wall", CLIMB: "climbable", SINK: "sinking", WADE: "wading"}
 
 
 class SceneError(RuntimeError):
     """The stage cannot be made into a scene at all."""
 
 
+def group_name(key: Key) -> str:
+    """`group 8`; one of the props model (sub 2) is `group 8 (second model)`."""
+    sub, g = key
+    return f"group {g}" + (" (second model)" if sub else "")
+
+
 @dataclass
 class TextureImage:
     """One slot of the bank; `rgba` is (h, w, 4) uint8, row 0 the top."""
@@ -111,7 +119,7 @@ def key(self) -> Key:
 
     @property
     def label(self) -> str:
-        return f"sub{self.sub}.g{self.vg_rec}"
+        return group_name(self.key)
 
     @property
     def budget(self) -> Budget:
@@ -354,7 +362,7 @@ def _resolve_textures(self, groups: Iterable[MeshGroup]) -> None:
 
     def summary(self) -> str:
         lines = [
-            f"st{self.stage:03d}  {self.name}",
+            stage_title(self.stage),
             f"  fog {self.fog_rgba}   subs {self.sub_sizes}",
         ]
         for sub, label in ((0, "terrain"), (2, "props")):
@@ -371,7 +379,7 @@ def summary(self) -> str:
             lines.append(f"  collision chunk {c.index}: {c.n_triangles} triangles  {kinds}")
         lines.append(f"  textures: {len(self.textures)}")
         for e in self.exits:
-            lines.append(f"  exit {e.index} -> st{e.target:03d} {e.target_name}")
+            lines.append(f"  exit {e.index} -> {stage_title(e.target)}")
         lines += [f"  note: {n}" for n in self.notes]
         return "\n".join(lines)