feat(a2b): first-pass texture render — full-screen event-CG layer

Wire asset resolution into a live Godot render. VM executes set-texture ->
ResourceMap resolves (scene,resId) -> files[section_base+resId] across all
archives -> pre-converted BMP -> composite behind the dialogue. The full-screen
event-CG layer (EV052*) renders end-to-end from the executed bytecode.

- Age.Engine/Sys4/ResourceMap.cs: Resolve + BMP TexturePath; Paths: asset JSONs
- GodotAdvHost: create/set/draw-texture -> TextureRect in a _stage layer
- IHost.DrawTexture + VM dispatch extended with dst x/y (draw-texture args 7/8)
- project.godot 800x600; convert_agf.py all-archive + --scene batch
- engine 8/8, C# --selftest still byte-matches vm0 trace (VM behaviour unchanged)

Known limitations (next chunk = graphics geometry/blend subsystem):
- sprites + BG* via the CG-load subroutine get garbage dst/size — native ops
  stubbed (0x208 get-texture-size + sprite position/anim chain)
- AE* fades draw opaque/instant (no alpha); no chromakey
- slot model approximates the game's immediate-mode blit-onto-slot-0 canvas
- AGF pre-converted to BMP offline (runtime decoder deferred)
See docs/phase-a-slice-plan.md (A2b section).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

docs/asset-resolution-re.md

@@ -81,8 +81,15 @@ highest-risk area of the port. This doc is the steering state; it feeds the A2b
    branchy non-opening scenes — use the C# VM to trace those). Runtime note for future work: the game is
    **packed** (main VM logic in a per-run heap `r-x` region) and streams archives through a heap block-cache
    via `ReadFile` (not mmap); the stable AGF decoder is `AGE.EXE+0x74f1f`.
-3. **Wire the backend** (already designed — A2b-background plan Tasks 3–5): `ResourceMap` resolver +
-   Godot `TextureRect` compositing; render only resolved full-screen slots. Mechanical once (1)+(2) land.
+3. **Wire the backend.** **✅ FIRST-PASS RENDER LANDED (2026-07-06).** `Age.Engine/Sys4/ResourceMap.cs`
+   (Resolve + BMP path) + `GodotAdvHost` texture ops → `TextureRect` compositing behind the dialogue;
+   `IHost.DrawTexture` extended with dst x/y; 800×600 window; `convert_agf.py --scene` pre-converts a
+   scene's manifest AGFs → BMP. The full-screen **event-CG layer renders end-to-end** from the executed
+   bytecode. **Limitations (next chunk = graphics geometry/blend):** sprites + `BG*` (routed through the
+   CG-load subroutine) have garbage geometry because native graphics ops are stubbed (`0x208`
+   get-texture-size + the sprite position/animation chain); fades (`AE*`) draw opaque (no alpha); slot
+   model approximates the game's immediate-mode blit-onto-slot-0 canvas. See `docs/phase-a-slice-plan.md`
+   (A2b section) for the full write-up + the graphics-subsystem plan.
 4. **Audio** (parallel, same shape): resolve `play-voice`/`play-bgm` `id → OGG` via SYS4INI + a
    Frida audio capture (hook `DATA3.ALF` reads or the audio-play fn); play via Godot. Reuses the
    `tools/frida/` framework.
@@ -98,9 +105,11 @@ rendering what the executed bytecode + the map produce (never a hardcoded image)
 
 ## Status
 
-A2b-background: **machinery landed**; **steps 1 & 2 SOLVED (static, general).** Step 1 =
-`build/asset-index.json`. Step 2 = **`resId → files[section_base(scene) + resId]`** via SYS4INI
-per-scene sections (`tools/resolve_asset.py` + `build/asset-sections.json`) — no runtime capture, works
-across all archives/types and for audio too. Remaining for the render (step 3): wire a `ResourceMap`
-(scene → section_base; resId → asset via the index) + Godot `TextureRect` compositing (A2b plan Tasks 3–5,
-now purely mechanical). Audio (step 4) uses the *same* resolver (`play-bgm/play-voice id → files[base+id]`).
+A2b-background: **steps 1–3 landed.** Step 1 = `build/asset-index.json`. Step 2 = **`resId →
+files[section_base(scene) + resId]`** via SYS4INI per-scene sections (`tools/resolve_asset.py` +
+`build/asset-sections.json`) — no runtime capture, all archives/types + audio. Step 3 = **first-pass
+render** (ResourceMap + GodotAdvHost texture ops → TextureRect compositing): the full-screen event-CG
+layer renders end-to-end from the bytecode. Remaining (next chunk): the **graphics geometry/blend
+subsystem** — native geometry ops (`0x208` + sprite position/animation) so sprites/`BG*` position, plus
+alpha/blend for fades + chromakey. See `docs/phase-a-slice-plan.md` (A2b). Audio (step 4) uses the *same*
+resolver (`play-bgm/play-voice id → files[base+id]`).

docs/phase-a-slice-plan.md

@@ -181,16 +181,34 @@ Toolchain: `godot --headless --path godot --import` → `dotnet build godot/Hime
 **Next = A2b:** background via `AGF2BMP2AGF.exe`, `play-voice`/`play-bgm`, choices → VM globals,
 just-enough `call-script`/state (unlocks richer scenes).
 
-### A2b-Background — machinery landed; render blocked on asset resolution (2026-07-06)
-Engine-driven texture ops shipped: `create/set/draw-texture` (0x1f8/0x1f9/0x1fb) promoted from VM stubs
-to typed `IHost` methods (CaptureHost no-ops → trace parity kept; engine tests 8/8). Tools: `convert_agf.py`
-(AGF→BMP stills) + `tools/frida/` capture harness (Frida 17.15.3 installed). **Blocked:** rendering the bg
-needs `resId → asset file` resolution, which proved opaque — CGINIT isn't a filename map, SYS4INI (S4IC422)
-needs format RE, Frida file-I/O offsets are noisy (memory-mapping), and the opening mixes movies (MVB/OP =
-MPEG) with stills so eyeball-curation stalled too. **Asset resolution promoted to a dedicated foundational
-RE effort** (graphics + audio; not machine-verifiable — Frida ground truth + human eye/ear are the oracle):
-see `docs/asset-resolution-re.md`. The backend render (ResourceMap + Godot compositing) stays designed in
-`docs/superpowers/plans/2026-07-06-a2b-background.md` Tasks 3–5, mechanical once resolution lands.
+### A2b-Background — FIRST-PASS RENDER LANDED (2026-07-06)
+Resolution solved (`docs/asset-resolution-re.md`: `resId → files[section_base(scene)+resId]`) and wired
+into a live render. **Shipped:** `Age.Engine/Sys4/ResourceMap.cs` (loads `build/asset-index.json` +
+`build/asset-sections.json`; `Resolve(scene,resId) → AssetEntry`; `TexturePath` → pre-converted BMP);
+`GodotAdvHost` implements `create/set/draw-texture` (slot → `TextureRect` composited behind the dialogue
+in a `_stage` layer); `IHost.DrawTexture` + VM dispatch extended to pass the destination x/y (draw-texture
+args 7/8); `project.godot` window = 800×600; `convert_agf.py` searches all archives + `--scene` batch.
+Engine 8/8, C# `--selftest` still byte-matches the vm0 trace (VM behaviour unchanged). **Works end-to-end:**
+the VM executes `set-texture(resId)` → ResourceMap resolves across archives → BMP loads → composite; the
+full-screen **event-CG layer (`EV052*`) renders correctly** as the opening plays.
+
+**Known first-pass limitations (all one subsystem = graphics geometry/blend, the next chunk):**
+1. **Only the full-screen layer is correct.** Sprites/effects and `BG*` backgrounds routed through the
+   CG-load subroutine (`label_12649`) derive width/height/position from native ops we still **stub** —
+   `0x208` (get-texture-size) + the sprite position/registration/animation chain — so their `dst/size`
+   are garbage (backgrounds land off-center, e.g. `BG030A dst=(300,300)`; sizes come out `0x0`). Only the
+   *immediate* full-screen draws (`(0,0) 800×600`) render right.
+2. **No alpha/blend.** `AE*` full-screen fade/flash effects draw **opaque and instant** (a static grey/white
+   sheet over the CG) instead of alpha-animating. No chromakey either (sprites would show green boxes —
+   moot until they position).
+3. **Slot model is an approximation.** We use one `TextureRect` per slot, replace-on-draw; the game
+   actually **blits onto slot 0 as an immediate-mode canvas** (everything composites into slot 0).
+4. AGF is **pre-converted to BMP offline** (`convert_agf.py --scene`); a runtime C# AGF decoder is deferred.
+
+**Next chunk — graphics-geometry/blend subsystem:** implement `0x208` (host returns the slot's real image
+dims) + the sprite position/registration ops so geometry is correct; add alpha/additive blend for fades +
+green chromakey; likely move to a proper canvas/blit compositor. Fixes sprites, background placement, and
+fades together. (Superseded: the id-specific plan in `docs/superpowers/plans/2026-07-06-a2b-background.md`.)
 
 ---
 

docs/tools-reference.md

@@ -66,7 +66,7 @@ All opcode knowledge (ABI, semantics, provenance, `depends_on`) is hand-edited *
 | `parse_sys4ini.py` | Parse `SYS4INI.BIN` (S4IC422, LZSS-compressed) into the authoritative asset index — name ↔ archive ↔ offset ↔ size for all DATA*.ALF (the `resId→file` answer key). | `parse_sys4ini.py [--check]` (`--check` validates vs `extracted/` + `.ALF` sizes) | `姫狩り…/SYS4INI.BIN` → `build/asset-index.json` |
 | `resolve_asset.py` | ★ **The static asset resolver.** SYS4INI is sectioned (one per scene: `SCxxxx.BIN` + its cross-archive manifest; `file_number` = index within section). Resolves `resId → files[section_base(scene) + resId]` for graphics AND audio, no capture. | `resolve_asset.py --build` · `resolve_asset.py <SCENE> [resId]` | `build/asset-index.json` → `build/asset-sections.json`; resolves any (scene, resId) |
 | `resolve_frida_reads.py` | Rescue noisy Frida archive-read offsets → asset names via the index (per-archive range search; drops 0x20000 paging reads); recovers the per-scene asset load order. | `resolve_frida_reads.py [reads.log] [-o out.json]` | `build/frida-reads.log` + `build/asset-index.json` → `build/frida-asset-loads.json` |
-| `convert_agf.py` | Convert named AGF stills to BMP via `AGF2BMP2AGF.exe`. | `convert_agf.py EV001AA.AGF …` | `extracted/DATA2|DATA5/*.AGF` → `build/textures/*.BMP` |
+| `convert_agf.py` | Convert AGF stills to BMP via `AGF2BMP2AGF.exe` (searches all `extracted/DATA*`). `--scene` batch-converts a scene's whole SYS4INI manifest — feeds the Godot render. | `convert_agf.py EV052CA.AGF …` · `convert_agf.py --scene SC0000` | `extracted/DATA*/*.AGF` → `build/textures/*.BMP` |
 
 ## Runtime capture (Frida)