@@ -16,7 +16,8 @@ The kit ships no game data. You need your own copy of the disc.
 * **Models open in Blender.** Every character, enemy, weapon, mech, prop
   and map on the disc comes out as a `.glb` with its texture inside.
   File ▸ Import ▸ glTF 2.0 and you have the mesh, its UVs, vertex
-  colours and skin-weight groups. Faces are merged into their bodies.
+  colours, skin weights and an armature built from the game's own
+  skeleton files. Faces are merged into their bodies.
   How-to and what to expect: [docs/BLENDER.md](docs/BLENDER.md).
 * **Character textures look right.** Opening models in Blender showed
   four texture bugs that had been there since the first release, and
@@ -37,9 +38,10 @@ The kit ships no game data. You need your own copy of the disc.
   FLAC, with MIDI and SoundFont files alongside, at the right tempo.
   The story of how: [docs/MUSIC.md](docs/MUSIC.md).
 
-Still on the list: the skeleton pose (models import with weight groups
-but no posed armature), the eyelash textures (stored 4 bits per pixel,
-not decoded yet), and a few map meshes in formats the model parser
+Still on the list: the arm and hair bones sit in the skeleton's T-pose
+rather than where the mesh hangs (legs, torso, head and face line up),
+the eyelash textures (a shared 4-bit sheet the game uploads from a file
+not yet identified), and a few map meshes in formats the model parser
 skips. The full change log is in [docs/UPDATES.md](docs/UPDATES.md).
 
 ## Running it
 
@@ -1566,9 +1566,17 @@ def bump(key: str, n: int = 1) -> None:
                     atlas_cache[atlas] = ((dec[0], dec[1], png_bytes(dec[0], dec[1], dec[2]))
                                           if dec else None)
                 tex = atlas_cache[atlas]
+            skeleton = None
+            jnt = src.with_suffix(".jnt")
+            if jnt.is_file():
+                try:
+                    skeleton = lexmod.parse_jnt(_load(jnt, bump))
+                    bump("models_with_skeleton")
+                except lexmod.LexError:
+                    bump("models_bad_jnt")
             glb = lexmod.to_glb(model, tex[2] if tex else None,
                                 (tex[0], tex[1]) if tex else (1024, 256),
-                                name=src.stem)
+                                name=src.stem, skeleton=skeleton)
             dest = mdir / src.relative_to(dump).with_suffix(".glb")
             dest.parent.mkdir(parents=True, exist_ok=True)
             dest.write_bytes(glb)
@@ -1582,7 +1590,8 @@ def bump(key: str, n: int = 1) -> None:
         log(f"models: {stats.get('models_glb', 0)} .glb written "
             f"({stats.get('models_textured', 0)} textured, "
             f"{tri_total:,} triangles; {stats.get('models_companions_merged', 0)} "
-            f"companions merged; {stats.get('models_unparsed', 0)} unparsed, "
+            f"companions merged; {stats.get('models_with_skeleton', 0)} with a "
+            f"posed skeleton; {stats.get('models_unparsed', 0)} unparsed, "
             f"{stats.get('models_with_warnings', 0)} with warnings)")
 
     if "audio" in kinds:
 
@@ -38,11 +38,17 @@ in `_rgba` and blend; everything else uses a cut-out alpha.
 shading tint. If a model looks too dark, unplug the Color Attribute node
 from Base Color in the material.
 
-**Vertex groups** named `j<number>` on every skinned part, with an
-armature called `skeleton`. The weights are the game's own. The bone
-positions are not decoded yet, so the armature is a flat list of named
-joints at the origin: you can weight-paint or build a rig on top of it,
-but you cannot pose the model as imported.
+**An armature** named after the character, built from the `.jnt`
+skeleton file: the real joint hierarchy with the game's rest pose,
+plus the face file's own small skeleton for eyes and mouth. Skin weights
+are the game's own, as vertex groups named `j<number>` (rotation joints)
+with the offset, translate and bone-end nodes in between. Torso, legs,
+head and face bones sit on the mesh. Arm and hair bones do not: the
+file's rest pose is a T-pose with the hair raised, while the mesh is
+modelled with arms and hair down, and the pose that matches the mesh
+has not been found in the files yet. So the import looks right, the
+legs and head pose correctly, and posing an arm pivots at the T-pose
+shoulder until that is solved.
 
 **Scale.** The game works in metres, Y up, same as glTF. KOS-MOS stands
 1.73 m tall and lands upright on Blender's floor with no scaling.
@@ -67,9 +73,8 @@ the head.
 
 ## Known gaps
 
-* **No skeleton pose yet.** The joints come through as named vertex
-  groups; their positions and hierarchy live in the `.jnt` files, which
-  are the next thing to decode.
+* **Arm and hair bones are in the file's T-pose**, not where the mesh
+  hangs (see above). Everything else on the skeleton lines up.
 * **No eyelashes.** Every character has a lash mesh, but its texture is
   not in the character's own atlas: the rect it points at is only the
   video-memory slot a shared 4-bit lash sheet is uploaded into at
 
@@ -351,9 +351,8 @@ Palette byte -> canvas tile: palx = (pal>>4 % 2)*256 + (pal&0xF / 2)*32 +
   material blocks (a mesh switches palette mid-stream: Cherenkov's
   jacket draws its sleeves from a second CLUT only the in-stream block
   names).
-Not decoded: the `.jnt` skeleton (xenotool reads a parent index per
-  0x40-byte block but neither the pose nor the id mapping is solved);
-  vertex formats 0x30/0xA0 (2 map files); weight formats 515/517.
+Not decoded: vertex formats 0x30/0xA0 (2 map files); weight formats
+  515/517. The `.jnt` skeleton is decoded (next section).
 Export (`lex.py: to_glb`): glTF 2.0 binary, one primitive per
   (mesh, material), PNG atlas embedded, COLOR_0 vertex colours, a flat
   skin of identity-bound joints named `j<id>` so Blender gets the vertex
@@ -367,6 +366,43 @@ old note that `simajiri/hama.lex` "points at (128,0) while the file's
 CLUT tile sits at (64,0)" was the sub-image placement bug above — with
 the correct placement the tile IS at (128,0).)
 
+## JNT skeletons (`lex.py: parse_jnt`) — hierarchy and rest pose
+
+```
+Header 0x20: "JNT\0"; u16 @4 (3); u16 block_count @6; u16 @8 (74 on
+  every file — not a count); u16 @0xA; u16 @0xC; u16 @0xE; u32 table
+  offset @0x10 (0xF0); u16 @0x14; u16 @0x16; name[8] @0x18 ("KOSMOS").
+0x20..table: 52 u32 — [17..42] maps the model's 26 mesh bones (lex
+  bone_idx) to type-1 blocks near the end of the table (0 = none).
+Blocks: 64 bytes each at `table offset`:
+  +0  float, +8 float      per-joint constants (limits?), often 0
+  +16 u16 type             1 offset node, 2 ROTATION JOINT, 3 translate,
+                           4 bone end (pos.x = length), 6 name record
+  +18 u16 flag             0..3 / 6, meaning unknown (not a rotation order)
+  +30 u16 parent           block index; self or out of range = root
+  +32 float3 position      local, metres
+  +48 float3 rotation      local Euler radians, applied as Rz * Ry * Rx
+  type 6: ascii group[8] @+0 ("BODY"/"FACE"), label[16] @+8 ("KUBI")
+Skin joints = the type-2 blocks in order: the k-th weight-group id of the
+model (ids are contiguous per model) is the k-th rotation block —
+checked on 8 models (46/46, 36/36, 26/26, 47/47 …).
+World = parent_world * T(position) * R(rotation). Verified by the
+vertex centroids weighted to each joint: hips/knees/ankles/toes land at
+0.98/0.54/0.16/0.01 m on KOS-MOS, mirrored; face .jnt joints already
+land in body space (eyes within 2 cm of the eye meshes).
+CAVEAT: the file's rest pose is a T-pose with the hair raised; the
+mesh is modelled arms-down, hair-down. Torso, legs, head and face
+joints coincide with the mesh; arm and hair joints sit 0.3–1.2 m from
+their vertices. No Euler order, sign or T/R composition closes that gap
+(brute-forced), so the modelled pose is not stored as joint transforms
+in .jnt or .lex (the lex's 26 matrix pairs are identity). The glTF
+export binds with inverse(rest world), which leaves the mesh exactly as
+stored; posing an arm therefore pivots at the T-pose shoulder.
+Candidates for the bind data: the type-1 "post" blocks the 0x20 table
+points at (big rotations, parented into the arm/hair chains), the
++0/+8 floats, or an animation file not located yet.
+```
+
 ## FL00 event containers / Java (`evt.py`)
 
 `.evt` = FL00 wrapper of real Java class files, format 45.3 (JDK 1.1,
 
@@ -2,6 +2,32 @@
 
 Newest first: what changed, why, and what it means for you.
 
+## 2026-10-14 — skeletons: the `.jnt` files decoded
+
+Models now import into Blender with a real armature instead of a flat
+list of joints. The `.jnt` file is a tree of 64-byte nodes: a type
+(offset, rotation joint, translate, bone end, name), a parent index, a
+local position and a local rotation. The skin's weight groups are the
+rotation joints in order, which checks out on every model tried. The
+face file's own small skeleton comes along for eyes and mouth.
+
+What lines up: torso, legs, head and face. KOS-MOS's hips, knees,
+ankles and toes land at 0.98, 0.54, 0.16 and 0.01 m, mirrored, and her
+eye joints are within two centimetres of the eye meshes. What does not:
+arms and hair. The file's rest pose is a T-pose with the hair raised,
+the mesh is modelled arms-down, and no rotation convention closes that
+gap, so the pose matching the mesh is stored somewhere not found yet.
+The export binds the mesh so it looks exactly as before; posing an arm
+pivots at the T-pose shoulder until that is solved. Byte layout and the
+evidence: [FORMATS.md](FORMATS.md) § JNT skeletons.
+
+**Eyelashes, status.** Still missing. The lash material's rect points
+at a video-memory slot, not at pixels in the character's atlas (the
+slot holds a thin striped column for every character checked), and no
+model file uploads a 4-bit texture there, so a shared lash sheet is
+uploaded by engine code from a file not yet identified. Next lead: a
+RAM dump of the running game around that upload.
+
 ## 2026-10-14 — models in Blender, and the texture fixes that came with them
 
 **Models.** `browse` has a new kind, **Models**: every `.lex` on the disc