BUILD_PLAN_END_TO_END.md

programs/BUILD_PLAN_END_TO_END.md

The end-to-end build plan — canon to a running game

Status: ACTIVE, 2026-07-22. Produced by a 8-agent Opus trace (7 lane traces + a synthesis) over BOTH

repos, verified against CURRENT repo state rather than the 2026-07-19 wall list (which is partly

stale — see each lane's already-done list). 137 build items enumerated. Companion to

docs/PIPELINE_READINESS_ROADMAP.md (the gate matrix) and docs/ROADMAP_TO_5090.md (the window plan).

The framing, from Josh: these are not capability blockers. They are engineering. Where a lane

reported "blocked", the trace was required to report WHAT TO BUILD instead.

The headline

• 137 build items across 7 lanes.
• 118 are buildable RIGHT NOW — no hardware, no external service, no ruling.
• Only 8 are genuinely 5090-gated, and 5 need a Josh ruling.
• That ratio is the finding. The pipeline is not waiting on hardware or on canon decisions;

it is waiting on plumbing that can be written today.

The critical path — the canon→engine trunk

THE CANON→ENGINE TRUNK, three links, none hardware-gated and none needing a Josh ruling: (1) FREEZE THE COLUMNS — build the missing single-writer for the region page's ## Zone Catalog block (verified today: harness/apply_region_page_sections.py only replaces ### Section N spans and STOPS at the next ## header, so the Zone Catalog at flores_island.md:38 has no deterministic writer at all), then land ONE coordinated column pack across the Zone Catalog and the six pending registry extensions in a single docs/registry_extensions.json + --emit-baseline commit; (2) CODEGEN THE TYPES — docs/REGISTRY_ROW_STRUCT_SPEC.md + Tools/gen_row_struct.py, turning a CSV header into a native USTRUCT : FTableRowBase (only 2 of ~36 exist today: BossEncounterRow.h and ChapterIndexRow.h, both hand-authored and both illegally FString on player-facing columns); (3) BULK-IMPORT — Tools/import_all_registries.py over the already-proven DataTable seam (verified at 79 and 281 real rows).

Why this and not any lane's own pick: five of the seven lanes independently nominated a variant of link (2) or (3) as their critical path (ue5 explicitly, audio "THE ONLY BRIDGE", quest Q-10, assetgen, cinematic), and five nominated a Zone Catalog / registry column add as theirs (terrain zone_bounds_wgs84, ue5 worldcover_biome + zone_anchor_wgs84, audio footfall_surface, combat care_tier + EG_ ids, assetgen mesh_tags/asset_routing). Those are the same two pieces of work seen from six angles. Everything else in all seven lanes is either upstream extraction (extract_spine_rows.py, wanted by three lanes) or downstream runtime — and every downstream item terminates in a row type that does not exist.

Critically, the ENGINE half of this project is far more finished than the wall lists say: the Landscape import shim called "the single highest-priority engineering dependency in the whole chain" is OBVIATED, weightmap painting is exposed, World Partition is exposed, PCG graph authoring is smoke-tested, the Sequencer Lua domain is 6,603 lines of full camera/keyframe/track authoring, the UE-Python bridge is a verified universal vector, and 360 real canon rows are already inside the editor. There is almost no missing CAPABILITY left. What is missing is TYPING: canon that exists as prose and markdown, with no machine column, no row struct, and no emitter to carry it across.

Build order

Ranked by (lanes served x unblocking power) / effort. Where several lanes independently named the

same missing thing, that convergence is the strongest signal in the dataset.

1. harness/spinelib.py + harness/extract_spine_rows.py — factor the existing spine parsers into an emitter — Three lanes independently named this exact missing tool and it is the cheapest thing on the board because the parsers ALREADY EXIST — verified: check_spine_graph.py carries _sections(), parse_beats(), parse_forks(), parse_file(), _kv_fields(), _bracket_list(), _brace_map() and validates 439 scene rows across 80 spine files, but emits nothing. This is a factoring job plus a CSV writer, not a parsing job. It produces sites/beats/forks/fork_options/scenes/sq/boss-index rows that ue5's hop 2, cinematic's entire lane (3.6% row coverage today: 16 of 439), and quest's realized_beat_refs/objectives_array/fork_option_refs FKs all dead-end without. Factor into spinelib.py so the gate and the extractor can never drift.

2. harness/extract_zone_catalog.py + harness/apply_zone_catalog_columns.py — the missing single-writer for the '## Zone Catalog' block — VERIFIED GAP, and the highest lanes-served-per-hour item in the dataset. The Zone Catalog is a top-level '## ' block (flores_island.md:38, 10 columns) sitting OUTSIDE apply_region_page_sections.py's '### Section N' span logic — that script's own SECTION_RE/TOP_RE explicitly stop at '## '. So six lanes each need to add a machine column to the same table and there is no deterministic writer for it; the alternative is hand-editing flag-prone canon 69 times. Build the reader (emits zones.csv, the FZoneRow source) and the all-or-nothing writer mirroring apply_region_page_sections.py's wrong-place and untouched-drift guards.

3. The ONE coordinated Zone Catalog column pack (zone_bounds_wgs84, meters_per_vertex, worldcover_biome, footfall_surface, care_tier, asset_routing/asset_category, environment_grammar EG_ refs) + a grammar spec for the value encodings — This single table add flips FIVE lanes from BLOCKED to READY on the SAME machine-generated scorecard (harness/build_readiness_scorecard.md), because each lane's readiness predicate is literally asking for one or two of these columns. Doing it as one pass on one rail beats five separate passes: five re-baselines, five template-version bumps, five chances to invent a different serialization for a list-in-a-cell. Pin the encoding once (recommend the in-repo precedent: semicolon-delimited key=value, as T0_Boss_Encounter_Registry.composure_nodes already does) so no consumer invents its own. Keep the existing area_bounds untouched — it is the playable design sizing, a deliberately different number from the real-world extent, and that ratio IS the scale-compression policy.

4. docs/REGISTRY_ROW_STRUCT_SPEC.md — the column→UE-type contract — Named as the #1 wall by ue5 and implied by every other engine lane; genuinely absent (no such file in docs/). Pins: id columns→FName; PLAYER-FACING text→FText (a BINDING localization law that the two existing hand-authored structs already violate on title and boss_name); designer prose→FString; closed enums→UENUM with an FString mirror for lossless round-trip; list columns→FString + a named parse helper; nested objects→FString-holding-JSON + typed accessor; FKs→FDataTableRowHandle. Must also record the two hard-won seam facts (RowName = the first CSV column; UE strips the F prefix, so /Script/Humanity.SceneSpecRow resolves and the F-prefixed path returns None).

5. Tools/gen_row_struct.py — CSV header + sidecar overrides → USTRUCT : FTableRowBase — The single highest-leverage script in the whole plan: it converts an O(34-sessions) hand task that START_HERE has named as 'the standing next build item' on three separate days into one script run plus one compile, and it serves six lanes' row-struct items at once (FCreatureRow, FSceneSpecRow, FQuestDefinitionRow, FThemeRegistryRow, FSFXRegistryRow, FVoiceRegistryRow, FWeaponRow, FVrilSiteRow, FZoneRow, the spine typed layer...). Generate the two WIDEST and most-nested structs first (FCreatureRow at 132 rows, FSceneSpecRow at 31 columns) as the pay-off test.

6. The batched registry-extension pass + ONE fidelity re-baseline (quest-schema-v2 §6.5 ~16 cols · assetgen-pipeline ~8 cols · audio ue_sound_asset_path ×3 · cinematic participant mesh_pipeline_type/ue_asset_path/binding_kind · combat phase_trigger/escalation_vector/signature_counters · SFX schema reconcile · §10.6 sfx_id_ref arrays) — Five lanes each named a registry column add as their own critical path or near it; the rail is BUILT AND PROVEN (verified: docs/registry_extensions.json carries 11 registry keys and 20 owner systems today, with check_registry_extensions.py enforcing single-system ownership). Batching them is not a convenience — every add must refresh docs/fidelity_baseline.json in the SAME commit or the gates go red, so five separate passes means five re-baseline windows and five chances for a stale baseline. Verified state confirming the need: quest registry is still 27 cols / 16 rows with no quest owner key; T0_Familiar_Registry is a ONE-LINE file with no header at all.

7. Generate + compile + import ~20 row structs; Tools/import_all_registries.py (manifest-driven bulk driver with per-table read-back and non-zero exit on row-count mismatch) — The terminal hop every lane's data must cross, over a seam already verified at production scale (DT_ChapterIndex 79×51, DT_BossEncounter 281×26, Unicode preserved). Today every import is a hand-typed command line, against the standing lesson that work-lists must be script-emitted. Expect and fix the real-data issues the smoke never hit at 281+ rows: embedded commas/quotes in prose columns, empty cells, payload size, and the FText import round-trip.

8. Tools/gen_gameplay_tags.py + Config/Tags/HumanityCanonTags.ini — canon ids → GameplayTags — Small, ungated, and structurally must precede anything that keys on a tag, because tags load at engine init only. One derivation covers ws.* (from the 42 live T0_Worldstate_Variables rows — verified populated), thread.T01..T22 (canonicalizing the two live encodings), region.*, and the ruled Boss.Phase.* / Boss.Composure.Node.* / Boss.Win.* / Boss.Shape.* sets. Copy the enum members verbatim from check_boss_axes.py so gate and engine cannot drift. UCombatTelemetrySubsystem::RecordNodeBreak(FGameplayTag) already compiles against a tag table that does not exist.

9. UWorldStateSubsystem + FWorldStateValue + UWorldStateSaveGame — run the 3-4-key validation spike FIRST — FOUR lanes independently name this as a blocker and it exists in none of them (verified: Source/Humanity/Public holds only Combat/ and Data/). It is fully specced by T99_Translation_Combat Step 7 and echoed by UE5 Step 10, and the canon side is ready (42 typed ws rows with defaults, enums and named consumers — WS_017's consumer list literally reads 'Ch76_77_cinematic_dispatcher'). It is ORIGINAL engineering with no Epic reference pattern, which is exactly why the ruled 3-4-key end-to-end spike must precede the ~42-key architecture: four lanes rework if the tagged-union or save shape is wrong. RECOMMENDED: keep mark_write's {community_id, valence, persistence, forward_track[]} in a separate DataTable-backed ledger rather than forcing a record into the scalar map.

10. harness/condition_expr.py + docs/CONDITION_EXPRESSION_GRAMMAR.md — ONE grammar, one parser, one evaluator — The §9.5 mini-grammar is RULED and reconciled across every conditional surface (quest gates, objectives_array.completion_condition, sq_gate_condition, dialogue line-variant selection, scene dispatch, boss phase triggers) but has no EBNF, no precedence, no type rules and no parser — check_spine_graph.py:511 only regex-scans has()/flag() for produce-before-consume. Build the Python reference implementation plus a golden accept/reject corpus harvested from the spine's Block-11 gates and the 88 spike dialogue lines; the C++ evaluator is then a port, not a reinvention.

11. ONE batched Josh ruling brief (mint the 3 new quest_type game-surface categories · GRAND_SAGE_REVEAL_VOICE retire-vs-rescope · the Ch74→Ch76 endgame residue in T0_Worldstate_Variables + Contract §5.5 and the WS_004 'ALL' selector · Sonniss free-now / BOOM spend decision) — Every genuine cardinal-canon item across all seven lanes is small, and there are only four of them. Batched into one brief early they cost a day; drip-fed late they serially block the quest seed-typing for all 69 regions, the first unattended voice batch, and the dispatch resolver binding the wrong chapter's forks. Each goes out per the standing protocol with alternatives, deep-dive, adversarial review, a RECOMMENDATION and the strongest objection — never as a bare question.

12. harness/derive_region_bbox.py + the Section-1 PARAMETERS BLOCK instantiated on all 4 pages (via the existing apply_region_page_sections.py writer) — Once zone_bounds_wgs84 exists this is small and it is the terrain lane's formal exit condition: union the zone polygons with a pad, compute the local UTM EPSG from the centroid, emit region_bbox/utm_epsg/meters_per_vertex/target_footprint/dem_source/water_plane/gaea_pass as machine fields. Supersedes the hand-typed Liang Bua smoke bbox and the now-stale 'the ruled per-region mpv remains a Josh number' prose (D-MPV closed 2026-07-21). Also realign check_build_readiness.py:263, which reads a single Section-1 meters_per_vertex while D-MPV rules mpv PER AOI — a live spec/gate mismatch.

13. terrain_fetch_preprocess.py hardening: absolute-elevation encoding, rasterio.fill void-fill + automated NASADEM fallback, content-addressed DEM cache + 50-call/24h rate limiter — Three small fixes that convert a working one-region hand-driven tool into an unattended 69-region batch. Two are real DEFECTS, not gaps: the per-AOI normalization means adjacent World Partition tiles will not stitch and water_plane in absolute metres is unrepresentable; and np.where(np.isnan(dst), lo, dst) slams every NoData void to the region MINIMUM, manufacturing false craters that only a human eyeballing the Landscape would catch. The cache also makes re-resampling at a different mpv ladder tier free instead of costing one of 50 daily API calls.

14. Tools/landcover_fetch.py (ESA WorldCover 10 m + Sentinel-2 L2A via Planetary Computer STAC) + the WorldCover→material-layer reclass table — The single difference between grey geometry and a painted, vegetated, PCG-populated Landscape — and it is a NEW source integration, not a parameter change: WorldCover is NOT served by OpenTopography's /API/globaldem endpoint, contrary to T99_Translation_Terrain §2 Step 2 (correct that doc in the same pass). Resample onto EXACTLY the Step-3 elevation grid so weightmaps are pixel-aligned with the heightmap by construction. Feeds worldcover_biome (named BLOCKED-ON by the UE5 lane on all four pages), the auto-material, and PCG Biome Core keying simultaneously.

15. Terrain→level chain: target_footprint/tile splitter → Tools/import_landscape.py → Tools/build_region_level.py (World Partition + Data Layers + per-zone PCG volumes) — The script that gets run 69 times, riding seams that are ALREADY VERIFIED — lvl:import_heightmap built a real 379×379 / 36-component Landscape from a 16-bit PNG, and lvl:partition exposes enable/configure_grid/set_streaming/create_layer. This is the driver, not the capability. Carry the recorded quirks: save via UnrealEditorSubsystem.GetEditorWorld → EditorLoadingAndSavingUtils.SaveMap (an untitled map otherwise cannot be saved); call PCGComponent.generate() AFTER actor spawn; screenshot focus_actor='Landscape' fails.

16. Combat data trunk: HumanityGameplayTags + BossRowParse (port the grammar verbatim from check_boss_axes.py) + AHumanityBossCharacter/ASC bootstrap + the real DT_Boss_Encounter import at 281 rows — The first live entity in the game driven by a canon row, and everything upstream of it is done: 281 rows × 26 columns with the five combat columns back-filled, gate-enforced by check_boss_axes.py, FBossEncounterRow compiling, UHumanityAttributeSet carrying all eight Composure sub-nodes. Nothing owns the AttributeSet today — there is no pawn, no ASC, no IAbilitySystemInterface. Prove-out assertion to bake in from the first commit: no code path writes any attribute from the density value.

17. boss-statetree-framework (schema, Tasks, Conditions, ~30 clocks, evolve-not-swap) + the boss cinematic trigger channel with a console debug emitter — The largest zero-built block in a lane where everything around it exists, and the named cross-lane dependency the cinematic lane is blocked on. Ship the tag channel + listener + Humanity.Boss.EmitPhase N debug emitter IN THE SAME WORK so the cinematic trigger path is testable with no boss AI at all — otherwise cinematic parks behind a hard engine constraint it does not need to: UStateTree.EditorData is a protected UPROPERTY unreachable by the py-bridge, so the state GRAPH is an in-editor manual pass. Consider the editor-module StateTree authoring helper before boss #3; hand-authoring 281 phase graphs is the alternative.

18. d_local resolver + the four dial GameplayEffects + harness/score_greybox.py — This is where the project's headline combat thesis becomes observable — one authored boss at two world-tensions with ZERO enemy-stat delta. Route every effect through a UGameplayModMagnitudeCalculation so nothing ever reads raw WS_024 [0,2] against a d_local [0,1] expectation. score_greybox.py closes a live orphan (UCombatTelemetrySubsystem already writes Saved/Telemetry/<session>.json to a consumer that does not exist) and gates SHAPES/RELATIONS/FLOORS only — every-mode-broken, tell-window monotone in d_local, zero enemy-attribute delta across a dial change — logging absolute milliseconds as Phase-5M evidence rather than gating them.

19. Audio identity + import: Section-10 machine cue table (template + Flores backfill) → T0_Theme_Registry regional cue rows + adaptive-field population → the SFX path convention → Tools/import_audio_assets.py → Tools/compose_audio_prompts.py — The cue_id namespace is head-of-chain for the whole audio lane and every hop keys to it, yet half the hardest column already exists as authored canon (Flores pass-2 tagged every track brief {adaptive|loop|oneshot} explicitly 'for Music Step 4 stem-splitting'), so this is largely formalization. Verified state: T0_Theme_Registry has the three ruled adaptive columns but ZERO regional rows and all 12 canonical rows empty on those fields. Publish the per-line voice naming convention (V_<voice_id>__<dialogue_line_id>) in the same pass and hand it to the quest lane as a constraint — the cheapest possible de-risking of the one genuine cross-lane audio dependency.

**20. Cinematic assembly: T99_Cinematic_Shot_Grammar (11 scene_types) → 11 LS_TPL_* templates via Tools/build_shot_templates.py → Tools/assemble_scene_sequence.py → Tools/render_mrq_dailies.py — Materially cheaper than the wall list assumes: NeoStack's Sequencer Lua domain is installed and rich (6,603 lines — bindings with spawnable/possessable, camera_cut/subsequence/audio/animation/property tracks, keyframes with interp, marked frames, plus list() read-back), so the 11 templates are a SCRIPTED authoring task with read-back verification, not hand labour. Shot grammar is creative-within-vision — author the recommendation and apply it. A 720p MRQ daily is the lane's fastest visible artifact and needs nothing external; route MRQ through the UE-Python bridge — MRQ is the one genuinely absent module. CORRECTED 2026-08-13:** MetaHuman and IKRig extension modules ARE present and compiled; see build/ops/NEOSTACK_METAHUMAN_BINDING_2026-08-13.json.

21. Quest lane land-and-author: docs/quest_dialogue/ + the first DD CSVs → harness/apply_quest_spike.py (25 quests + 17 SQ stages + 88 lines) → the quest_type enum proposal → T99_Translation_Quest.md — Content that is ALREADY AUTHORED and critic-gated (four fresh-context critics, unanimous GO-WITH-FIXES, zero reveal leaks) currently has nowhere to land — verified: the registry is still 27 columns / 16 rows and docs/quest_dialogue/ does not exist. Landing it produces the evidence base for the quest_type enum proposal, which schema v0.2.2 §11.1 explicitly OWES from the first quest-writing pass and which unblocks the seed harvest identically for all 69 regions. It also hands the audio lane its named blocker's first real canonical line.

22. AssetGen chain: field-grammar spec → capture_rights register + the §17.1 gate teeth → harness/compose_asset_prompt.py → Tools/mesh_finish.py (Blender 5.1 headless) → Tools/import_mesh_asset.py → harness/apply_mesh_writeback.py → the previz round-trip smoke on one fantastical vril-site asset — Everything external is already in place — Blender 5.1 is installed, the FBX→UE import seam is verified, and NeoStack ships a compiled generative provider layer (Tripo exposing text_to_model, texture_model and highpoly_to_lowpoly retopology). Run the whole chain on ONE asset with zero §17.1 exposure first: its real product is the CORRECTED field set, surfaced before 69 regions inherit a wrong schema. The capture-rights register is non-negotiable and has no substitute — the agent currently cannot distinguish a rights-cleared reference photo from a prohibited one on real heritage architecture.

**23. PCG binding: docs/translation/PCG_BINDING_AND_POPULATION.md → PCG_Biome_* template graphs → the zone-polygon → UE-local-ENU → PCG bounds-actor → graph-selection binding → Tools/bake_region_pcg.py** — The last hop from 'a real landscape' to 'a populated playable zone', and the one place both T99 docs correctly say there is 'no existing product feature to point at'. It is composition over verified primitives (Epic's MCP PCG toolset is smoke-tested end to end; lvl:scatter exists), so the work is the inference layer: terrain_type→template routing with an explicit fallback so an unseen enum never silently no-ops, plus ambient_threat→density, vril_density→creature-tier filter, climactic_affordances→marker class. Author those numbers as illustrative defaults under the tuning firewall and flag for veto — Contracts §0 assigns runtime-parameter inference to the Translation layer, not canon. Treat PCG Biome Core as Experimental v0.2.

24. Gate pack: harness/check_quest_rows.py · harness/check_asset_pipeline.py · harness/check_scene_spec.py · a Quest lane predicate added to check_build_readiness.py LANES — Three lanes ship new content classes with no gate, and the Quest lane is INVISIBLE to the readiness matrix entirely (verified: LANES at check_build_readiness.py:112 is the six other lanes). The house pattern is mature — self-testing both directions, refusing to run if its own teeth are broken, enrolled in gates_config.json — so this is template reuse, not gate design. This is what makes autonomous production authoring at 69-region volume trustworthy rather than spot-checked.

25. Write the 5090 benchmark harnesses NOW, run them on arrival (Gaea-vs-Landmass kill test · 69-region throughput extrapolation · World Partition + PCG runtime cost at the 1 m hero tier · MOSS/ACE-Step scoring rigs · the runtime-inference perf budget) — Benchmark day becomes turnkey instead of a week of rig-building, and several of these are KILL TESTS that could delete work: if Gaea's erosion is not perceptibly better than UE Landmass + auto_paint at the chosen scale, the whole Gaea leg and its license question evaporate. Same shape for the TRELLIS.2 GPU-free licence re-check, which could delete the entire PyTorch3D renderer-swap spike before the hardware arrives.

26. The 5090-gated runs themselves (see five090_only) — Kept last and kept short deliberately. Across seven lanes only ~6 work classes are honestly hardware-gated, and every lane's own trace says so explicitly. Anything else parked here is a real cost.

Shared infrastructure — build once, serves many

The highest-value section: a solo builder wins by building the shared thing once.

• harness/spinelib.py — one home for the spine parsers currently living inside check_spine_graph.py (_sections, parse_beats, parse_forks, _kv_fields, _bracket_list, _brace_map), imported by both the gate and the new extractor so validation and extraction can never disagree about what a beat row is.
• harness/extract_spine_rows.py — ONE emitter producing sites/beats/forks/fork_options/scenes/SQ/boss-index CSVs, replacing three lanes' separately-specified extractors (ue5 hop 2, cinematic's extract_spine_scene_rows, quest Q-3). Add a --emit-page-index mode so it also regenerates each region page's Derived-Indexes Scene index rather than anyone hand-editing pages.
• harness/extract_zone_catalog.py + harness/apply_zone_catalog_columns.py — the reader/writer pair for the '## Zone Catalog' top-level block, the exact twin of apply_region_page_sections.py's safety contract (all-or-nothing, wrong-place guard, untouched-drift check). This one small tool is what makes six lanes' column adds mechanical across 69 pages instead of hand-edited canon.
• docs/REGISTRY_ROW_STRUCT_SPEC.md + Tools/gen_row_struct.py — the CSV-header→USTRUCT codegen. One spec plus one script replaces ~34 hand-authored row structs across six lanes, enforces the FText localization law by construction rather than by discipline, and emits the import manifest entry in the same pass.
• Tools/import_all_registries.py — one manifest-driven bulk driver over the already-proven DataTable seam: N tables, one editor session, per-table read-back, non-zero exit on any row-count mismatch. Makes a full-canon re-ingest after any registry edit a single command instead of N hand-typed ones.
• UWorldStateSubsystem + FWorldStateValue + UWorldStateSaveGame — the one runtime state trunk. Four lanes (combat ws_writes, cinematic path-conditional dispatch, quest state_writes, ue5 save) each specced it separately; build it once, seeded from the 42 live worldstate rows, with the small key-count validation spike first.
• Tools/gen_gameplay_tags.py — canon ids → GameplayTags in one derivation (ws.* from the worldstate registry, thread.T01..22 canonicalizing the two live encodings, region.*, Boss.Phase/Composure/Win/Shape from check_boss_axes.py's ruled enums). Makes the tag space a mechanical function of canon so it can never drift, and serves five lanes.
• harness/condition_expr.py + docs/CONDITION_EXPRESSION_GRAMMAR.md — ONE implementation of the §9.5 mini-grammar (EBNF, precedence, type rules against WS_NNN domains, tokenizer, AST, evaluator, golden corpus), consumed by the spine gate, the quest gate, dialogue variant selection, scene dispatch and boss phase triggers — and ported once to C++ rather than reinvented per subsystem.
• The registry-extension rail (ALREADY BUILT — use it, do not rebuild it): docs/registry_extensions.json single-system column ownership + docs/fidelity_baseline.json added_columns/extension_hashes + harness/check_registry_extensions.py + registry_fidelity.py --emit-baseline. Verified live across 11 registry keys and 20 owner systems. Every pending column add in every lane should ride this rail, and they should be BATCHED into as few re-baseline commits as possible.
• A generic canon-row → prompt composer. The audio, assetgen and quest lanes each spec their own orchestration agent with the same shape: read entity row + region page + region-filtered RAG (harness/recall.py + harness/rag/), compose a prompt from a deterministic rule table, emit a generation_prompt_hash, and detect regeneration by hash diff. Build one composer with per-lane rule tables and per-lane output schemas rather than three near-identical scripts.
• The self-testing gate template. check_build_readiness.py's shape — must-fire and must-not-fire fixtures on every real run, refuse to run if its own teeth are broken, enrolled in gates_config.json, emits a scorecard with a worklist_next block — should be the literal template for check_quest_rows, check_asset_pipeline, check_scene_spec and score_greybox rather than four independently-invented gate shapes.
• A content-addressed external-fetch cache + budget limiter. Written for OpenTopography's 50-call/24h cap, it should be generic over (provider, request-key) so WorldCover/Sentinel-2, Meshy/Tripo, ElevenLabs and any future API inherit caching, retry, resume-hint-on-exhaustion and a provenance record for free. Raw payloads land outside git.
• The cross-repo writeback manifest. Four lanes need to write results from the game repo back into canon registries (mesh_id_ref, ue_asset_path, terrain params, import status) while the one-writer-per-repo rule forbids direct writes. Design ONE manifest schema and ONE canon-side applier (harness/apply_*_writeback.py) that refreshes the fidelity baseline in the same commit — not a per-lane improvisation.
• The UE-Python bridge as the declared universal vector. invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand') reaches the full unreal API and is already proven for DataTable import and asset import. CORRECTED 2026-08-13 — the "absent" reading was wrong for two of the three. NSAI_MetaHuman_Integration (938,496 B) and NSAI_IKRig_Integration (927,232 B) are both PRESENT and compiled in Plugins/NeoStackAI/Binaries/Win64/; only an MRQ/MoviePipeline module is genuinely absent from the 64 shipped NSAI integrations. Standardize on the bridge for MRQ alone; MetaHuman and IKRig have working Lua domains today (66 MetaHuman functions enumerated in build/ops/NEOSTACK_METAHUMAN_BINDING_2026-08-13.json). The generalisation was drawn from one stub file in the CORE module and applied to three domains without checking the extension modules — the same class of error as calling a tool limited before diffing its real surface.

The shape of the gap

• THIS IS A TYPING PROBLEM, NOT A CAPABILITY PROBLEM. Across all seven lanes, nearly every engine seam is already proven: the Landscape import (which two docs call 'the single highest-priority engineering dependency in the whole chain') is OBVIATED by lvl:import_heightmap, weightmap painting is exposed, World Partition is exposed, PCG graph authoring is smoke-tested, the Sequencer Lua domain is 6,603 lines of full camera/track/keyframe authoring, the UE-Python bridge is a verified universal vector, and 360 real canon rows are already inside the editor. What is missing is TYPE: canon that exists as excellent prose with no machine column, no row struct, and no emitter. The owner should staff this as schema-and-codegen engineering, not as engine or graphics engineering.
• ONE SHARED SURFACE IS THE BOTTLENECK, AND IT HAS NO WRITER. Six of seven lanes are blocked on a machine column in the SAME table — the region page's '## Zone Catalog' (terrain wants zone_bounds_wgs84 + per-AOI mpv, ue5 wants worldcover_biome + zone_anchor, audio wants footfall_surface, combat wants care_tier + EG_ refs, assetgen wants asset_routing/mesh_tags, cinematic wants the scene index). Verified today: apply_region_page_sections.py replaces '### Section N' spans and stops dead at the next '## ' header, so the single most-demanded schema surface in the project is the one surface with no deterministic writer.
• VALIDATION WAS BUILT BEFORE EXTRACTION. check_spine_graph.py parses beats, forks, sites, SQ rows and all 439 scene rows across 80 files — and emits nothing. The same inversion recurs everywhere: 20+ gates, a fidelity harness, a registry-extension enforcer, a readiness scorecard, all mature; and almost no tool that turns validated canon into a consumable table. Three lanes independently asked for the identical missing emitter. The cheapest wins in this plan are all 'factor an existing parser into an emitter'.
• PRODUCERS WITHOUT CONSUMERS (AND VICE VERSA) — the standing anti-orphan lesson, recurring at least six times: UCombatTelemetrySubsystem writes a telemetry JSON to a scorer that does not exist; mesh_id_ref exists as a column with 0/72 populated and no populator; T0_Scene_Spec_Registry carries a complete audio FK surface pointing at registries with no asset-path column; recall.py works with no packs exporter; T0_Hard_Lines has no 'Runtime' pipeline value so the runtime guardrail would pass everything; T0_Familiar_Registry is a one-line file that two specs list as a required generation source. Every build item should be checked for both ends before it lands.
• THE WALL LISTS ARE SYSTEMATICALLY STALE IN THE PESSIMISTIC DIRECTION. Independently, five lanes found their own named top blocker already closed: the ALandscape C++ shim (obviated), the weightmap-painting caveat (obsolete), the adaptive-audio tempo/bar/stem columns (ruled and present), D-MPV (ruled 2026-07-21), the Boss_Encounter combat columns (applied to all 281 rows), Tripo's commercial terms (settled), Blender installation (done), Epic MCP PCG verify (resolved). Planning off a three-day-old wall list demonstrably wastes work; verify-then-plan is not optional here, it is the highest-yield step in the process.
• MISSING UE-SIDE TYPE DEFINITIONS AT SCALE, AND THE TWO THAT EXIST ARE ALREADY WRONG. 2 of ~36 row structs, both hand-authored, both all-FString on player-facing columns in violation of a binding localization-from-the-first-string law that cannot be cheaply retrofitted once content references the strings. The scale factor (34 remaining × 6 lanes asking) plus a known-correct-but-unapplied rule is exactly the signature of a codegen problem.
• NO SHARED RUNTIME STATE TRUNK. Four lanes name UWorldStateSubsystem as a blocker and it exists in none of them, while the canon side is fully ready (42 typed worldstate rows with enums, defaults and named consumers). It is original engineering with no Epic reference pattern — which makes it both the highest-leverage single C++ item and the highest-risk one, and argues for the small validation spike before the full architecture.
• THE CANON LAYER IS FAR AHEAD OF THE BUILD LAYER. 79 spine nodes, 439 scene rows, 281 gate-enforced boss rows, 42 worldstate rows, an audited book-substrate RAG at ~661k chunks, region pages critic-corrected to pass-2 depth. The scarce resource is not canon and it is not engine capability — it is the narrow band of transform tooling between them. That is a small, well-specified, deterministic-Python-shaped body of work, which is good news for a solo builder.
• GENUINE CARDINAL-CANON GATES ARE RARE AND SMALL. Across seven lanes there are roughly four real Josh rulings (mint 3 quest_type categories · the Grand-Sage voice row vs HL_0046 · the Ch74→Ch76 endgame residue and the WS_004 'ALL' selector · one library purchase). Everything else is engineering shape, format convention, or runtime-parameter inference that the Contracts explicitly assign to the translation layer. The failure mode to avoid is treating format calls as canon calls and stalling.

Genuinely 5090-only

Anything parked here that could ship now is a real cost, so this list is deliberately short.

• Local shipped-path 3D geometry generation — TRELLIS.2 (24 GB VRAM floor) and Hunyuan3D-2.1 (29 GB), plus the PyTorch3D renderer-swap spike that needs a 24 GB+ card to test the swapped render path at all. NOTE: the GPU-free licence re-check may DELETE this item before the hardware arrives, so run that first.
• Local music-generation benchmark (ACE-Step / YuE / HeartMuLa on a fixed test set) and the MOSS-SoundEffect v2.0 SFX benchmark. Explicitly NOT included: Kokoro-82M voice TTS (documented CPU-runnable at ~2-3 GB) and the Demucs orchestral stem-separation spike (runs on modest hardware) — parking either here would be a real cost.
• The 14B on-device reference model and the runtime-inference perf budget at ship scale — batching, speculative/draft decode, KV/prefix cache, the ~8-15 gen/s busy-scene target, P99 latency, VRAM/quant budgets, and the nightly first-try-pass-rate eval at corpus scale. Explicitly NOT included: the 3-4B ship-target bark smoke, which the design pins to the CURRENT GPU, and the entire deterministic V1-V5 validator + fallback-bank spine, which needs no model at all.
• Render and streaming perf validation across the four spec classes: World Partition + PCG runtime cost at the 1 m/vertex hero-terrain tier (the densest terrain case in the game), many-simultaneous-MetaHuman groom cost, Chaos destruction at scale (fracture budgets, cache determinism, many-destructible frame cost), and the 69-region headless PCG/HLOD/Nanite batch bake. The single-region versions of all of these run today.
• Measurement-bound NUMBERS that no amount of engineering can produce early: the per-category poly/LOD/collision budgets (T1_BPC §1.7 steam_deck_minimum, which Tools/mesh_finish.py's Decimate target reads), the Phase-5M combat tuning values, and the Gaea-vs-Landmass perceptible-difference kill test. Every consuming SCRIPT is buildable now on illustrative constants under the tuning firewall — only the constants wait.
• MetaHuman generation at full roster scale, and the persona-voice LoRA/QLoRA training run. Both have a today-half that must NOT be parked: ONE MetaHuman built in-engine (which discharges the cinematic lane's participant-asset blocker for an afternoon of editor time, and matters because Epic sunsets the browser Creator on 2026-11-05), and the LoRA DATASET ACCUMULATION, which should start collecting ratified personas and gate-passed lines from the first authored quest so the workstation arrives to a ready corpus.

Where this plan could be wrong

• FREEZING COLUMNS BEFORE CONTENT PROVES THEM. This plan front-loads a large coordinated schema pass, but the quest lane's own evidence says schema gaps only surface when content is authored — the Ch 2-5 spike produced 32 contract gaps that no amount of spec review had found. Freezing 60+ columns across six registries and a template before any end-to-end asset, quest or scene exists risks a second migration across 69 pages. FALSIFIER / MITIGATION: run three thin end-to-end smokes first (one fantastical vril-site mesh, one quest with dialogue, one scene to a 720p daily); if any smoke forces a column change, the freeze was premature and the column pack should follow the smokes rather than precede them.
• CODEGEN MAY NOT PAY. gen_row_struct.py assumes CSV headers map 1:1 to UE members — true for the two existing structs, which are all-FString. The moment FText, UENUM+mirror, list columns, nested JSON payloads and FDataTableRowHandle FKs enter, the per-registry sidecar override file could approach the size of the struct it generates, making codegen pure overhead. FALSIFIER: generate FCreatureRow (132 rows, widest) and FSceneSpecRow (31 columns, most nested) FIRST; if their sidecars exceed roughly 30% of the emitted struct, abandon codegen and hand-author with the spec as a checklist.
• THE FText RETROFIT IS SCORED AS SMALL AND MAY NOT BE. FText is legally load-bearing (ship-everywhere localization) and cannot be cheaply retrofitted once content references the strings — but the DataTable import path runs through fill_data_table_from_csv_string, and FText's CSV import format is not the same as FString's. If the round-trip breaks, the verified import seam needs rework at exactly the moment every lane is depending on it. FALSIFIER: round-trip ONE FText column through the existing DT_ChapterIndex import and read it back before generating 20 structs.
• GEOREFERENCING MAY BE A CANON CALL IN DISGUISE. The terrain lane asserts that adding zone_bounds_wgs84 'mints no chapter, numerical, or naming canon' because Liang Bua, Kelimutu and Wae Rebo are real published places. That holds where a zone maps to exactly one named real site — but across 69 regions some canonical zones will have no single obvious real-world referent, and CHOOSING one is a canon assignment. FALSIFIER: attempt bali, sumatra_java and angkor_khmer before flores is generalized; if more than one zone per page needs a site-identity decision, this work needs the ruling rail, not autonomous apply.
• UWorldStateSubsystem IS ORIGINAL ENGINEERING WITH FOUR DEPENDENTS. No Epic reference pattern exists (Lyra ships no save reference). If the tagged-union or the async-save shape is wrong — or if mark_write's record shape is forced into the scalar map and the forward_track array is lost — four lanes rework simultaneously. FALSIFIER: the ruled 3-4-key end-to-end spike (set, read, save, reload, dispatch on it) before committing to the ~42-key architecture.
• SEVERAL 'VERIFIED SEAMS' WERE VERIFIED ONCE, BY HAND. The Landscape import, the PCG graph smoke, the SoundWave import and the Sequencer domain are all reported proven, and three lanes now plan on the assumption that no engineering is needed there. But a hand-driven one-off is not a reproducible unattended script — the untitled-map save quirk and the PCG generate()-after-spawn quirk are already evidence of that. FALSIFIER: re-run each claimed-proven seam once from a script, unattended, before any lane's plan depends on it being free.
• THIS PLAN BACK-LOADS EVERYTHING PLAYABLE. Ranks 1-11 produce no frame of gameplay. If nothing is playable for months, the feedback that would most change the schema — does the vril-density dial FEEL like a smarter opponent, does a PCG-populated zone read as a place — arrives after the schema has hardened around it. MITIGATION: keep the combat greybox (ranks 16-18) and the single-region terrain chain running as a PARALLEL lane rather than strictly behind the trunk; they share only the GameplayTag generator and the DataTable import.
• EFFORT ESTIMATES ASSUME PROVEN-AT-SMOKE MEANS PROVEN-AT-SCALE. The DataTable seam survived 281 rows, but PCGWorldPartitionBuilder has a community-reported iterative-cell-loading failure against Grid Size nodes, MetaHuman cloud throughput at roster scale is undocumented by Epic, Chaos destruction cost at scale is unmeasured, and PCG Biome Core is Experimental v0.2. Any of ranks 15, 22, 23 could be materially larger than 'large'.
• THE CROSS-REPO WRITEBACK SEAM IS DESIGNED BUT UNPROVEN, AND ITS FAILURE MODE IS SILENT. Four lanes need results flowing from the game repo into canon registries under a one-writer rule. If a manifest is dropped or misapplied, canon carries stale or wrong asset paths that no current gate can see — and the project's own recorded history contains exactly this class (a chunk_id collapse that reported success while 16 gates stayed green). MITIGATION: the writeback applier must verify the target asset actually exists in-engine, and check_asset_pipeline must assert that every 'complete' status has a resolvable path.
• SERIALLY-BLOCKING SMALL RULINGS. The four cardinal-canon items are individually trivial and collectively cheap, but drip-fed they gate the quest seed-typing for all 69 regions, the first unattended voice batch, and the dispatch resolver's chapter binding. The plan assumes they go out as ONE early brief; if they instead surface one at a time as each lane reaches them, the schedule takes four separate stalls.

Per-lane end-to-end traces

audio

Critical path: The Section-10 machine cue table (cue_id + track_type + adaptive_class) added to T1_Region_Page_Template §10 and backfilled into flores_island.md. It is head-of-chain, ungated, and small: it is the ONLY thing that mints a stable cue-id namespace, and every hop downstream keys to those ids — the readiness gate (harness/check_build_readiness.py:317 literally tests for cue_id + track_type), the T0_Theme_Registry regional cue rows, the generation prompt compose, the import path convention, the MetaSound graph, and the Scene_Spec music_cue_id_ref FK. Today the richest region page in the repo (Flores, pass-2 audited) carries a genuinely excellent Section 10 that is 100% prose, so the audio lane reports BLOCKED-ON for the one region that is otherwise fully built. Nothing about this is 5090-gated, canon-gated, or vendor-gated — it is a template edit plus one backfill, and it converts the audio lane from "no addressable unit of work" to "69 regions of enumerable, scriptable work." Second-place item is the trio of C++ FTableRowBase row structs, which is the only bridge from canon CSV into the running game.

CHAIN: canon row -> generation -> UE import -> MetaSounds/Quartz adaptive graph -> audible in PIE.

HOP 1 — Canon substrate (region page Section 10 + Section 17). PARTIAL. C:/dev/humanity-forgotten/_source/02_Tier_2_Region_Pages/flores_island.md:845-868 has a rich, pass-2-audited Section 10 (gong-waning ensemble, Thread-21 vril-active instrument, four named track-type briefs, sound-design enums, voice tiering, a substrate-confidence flag) and it even carries inline adaptive-class tags {adaptive|loop|oneshot} added at pass 2. But it is PROSE. No cue_id, no track_type, no machine table. Only 4 region pages exist at all (angkor_khmer, sumatra_java, bali, flores_island) of 69.

HOP 2 — Canon registries. PARTIAL, three ways.

• T0_Theme_Registry [DRAFT v0.1] EXISTS, 12 rows x 25 cols. The three adaptive columns tempo_bpm, bar_length, per_stem_role ARE PRESENT (verified in the CSV header) — the named wall is CLOSED, ruled 2026-07-20 and declared in docs/registry_extensions.json:155-161 under the adaptive-audio owning system. However all 12 rows have those three fields EMPTY, and all 12 rows are canonical themes (protagonist, Velheim, Architect, 3x Cassius, Grand Sage, 3x endings, Vimana, Familiar). ZERO Regional Ambient / Combat Cue / Vril Site Cue rows exist — the entire region-driven music track has no rows.
• T0_Voice_Registry [DRAFT v0.1] EXISTS, 10 rows, all canonical, all generation_status=pending, all elevenlabs_voice_id_ref empty. One row (GRAND_SAGE_REVEAL_VOICE) is self-quarantined against HL_0046 ("the Grand Sage never speaks") and needs a retire-vs-rescope ruling.
• T0_SFX_Registry [ACTIVE v1.0] EXISTS and is the healthiest of the three: 12 real populated rows with layering_role, spatial_attenuation, vril_density_modifier, cultural_authenticity_source, hard_line_anchors. But every row is a Component-11 vril-site anchor (Serapeum, Great Pyramid, Baalbek, Antikythera, Newgrange...) — ZERO Flores rows, zero footstep/weapon/foley/creature rows. And docs/PIPELINE_ADAPTER.md:212-214 records that this live 19-column schema shares only sfx_id/notes/extensions with the Contract §10.5 20-column schema, with an ID-format mismatch (live SFX_00001 5-digit vs contract SFX_NNNN 4-digit) plus mojibake.

HOP 3 — Readiness gate. EXISTS and is the honest reporter. harness/check_build_readiness.py:313-322 lane_audio demands (a) a Section-10 machine cue table with cue_id + track_type, (b) a per-zone footfall_surface field. Flores has NEITHER, so the pilot region reports BLOCKED-ON. This gate is correct, not stale.

HOP 4 — Cue/roster/bank derivation (the orchestration agent that reads schema-bound fields and composes prompts). MISSING. No script exists in either repo. Tools/ contains only terrain_fetch_preprocess.py, generate_sfx.py, import_registry_datatable.py.

HOP 5 — Generation.

• SFX: EXISTS. C:/dev/Humanity/Humanity/Tools/generate_sfx.py is real, 55 lines, hits POST api.elevenlabs.io/v1/sound-generation, key read from ELEVENLABS_API_KEY env with a winreg HKCU fallback, writes mp3. Key IN and probe-verified.
• Music hero lane: RULED COMPOSER-IN-LOOP (Josh, 2026-07-27 — AIVA closed as skip, the enterprise-contact path is dead). Not a build item: the hero lane is a human composer, and the orchestration side is the substrate/prompt-pack handoff plus cue lock, not a vendor integration.
• Music bulk lane (ACE-Step/YuE/HeartMuLa): MISSING and 5090-gated. grep for Kokoro|ACE-Step|MOSS|Demucs across the entire game repo returns ZERO files.
• Voice: MISSING. No Kokoro tooling anywhere; ElevenLabs TTS leg unscripted (only the sound-generation endpoint is wired, not text-to-speech).

HOP 6 — UE import. EXISTS AND PROVEN, but not yet repeatable. The mp3->SoundWave round trip is real: C:/dev/Humanity/Humanity/Content/Audio/SFX/smoke_stone_door.uasset is on disk, produced via AssetImportTask through the UE-PYTHON BRIDGE (NeoStack execute_script -> PythonScriptLibrary.ExecutePythonCommand), documented at game CLAUDE.md:100-104. But it was a one-off ad-hoc invocation — there is no Tools/import_audio_assets.py, so there is no batch/manifest-driven import for region scale.

HOP 7 — Canon data reaching the running game via DataTable. MISSING — and this is the hard structural gap. Tools/import_registry_datatable.py EXISTS and is verified (game CLAUDE.md:113-119, evidence /Game/Data/Smoke/DT_ImportSmoke), BUT it requires a NATIVE C++ USTRUCT(FTableRowBase) row type per registry — UserDefinedStructs are explicitly a DEAD END on this seam. Source/Humanity/Public/Data/ contains exactly ChapterIndexRow.h and BossEncounterRow.h. There is no ThemeRegistryRow.h, no SFXRegistryRow.h, no VoiceRegistryRow.h. So today ZERO audio canon can reach the engine as data.

HOP 8 — MetaSounds/Quartz adaptive graph. MISSING entirely. No MetaSound Source assets, no tempo/bar Data Asset, no builder script. Spike #5 (MetaSoundBuilderSubsystem "does not support variables") has never been run. Content/Audio/ contains exactly one asset: the SFX smoke test.

HOP 9 — Runtime playback driven by game state. MISSING. No audio subsystem in Source/. Note the natural driver already exists: Source/Humanity/Public/Combat/HumanityDensitySubsystem.h is the ruled vril-density difficulty dial — the obvious input to an adaptive-intensity MetaSound parameter, and an integration seam nobody has claimed.

HOP 10 — Cinematic handoff. PARTIAL (correctly). T0_Scene_Spec_Registry [ACTIVE v0.1] carries every audio FK the contract names: music_cue_id_ref, sfx_category_array, sfx_id_ref_array, voice_refs, dialogue_dataset_ref, audio_priority_layer, scene_audio_intent. thematic_anchor and scene_audio_intent are POPULATED with real content (e.g. SCENE_CH77_FINAL_REVEAL carries ["GRAND_SAGE_REVEAL","PROTAGONIST_THEME"] and "silence holds at recognition moment then GRAND_SAGE_REVEAL theme emerges from PROTAGONIST_THEME echo"). The FK columns themselves are empty/[] — which is the CORRECT state, since no cue exists yet to point at. Schema ready, awaiting hops 1-8.

NET: the two ends of the lane are solid (canon substrate is rich; the UE import seam is proven with an artifact on disk). The entire MIDDLE is missing — there is no machine-readable cue identity, no generation orchestration, no C++ row struct bridge, and no adaptive graph. Nothing in that middle is 5090-gated except the local music/SFX model benchmarks.

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• THE NAMED TEMPO/BAR/STEM-ROLE WALL IS CLOSED. The roadmap wall 'No T0_Theme_Registry field carries tempo, bar-length, or stem-role metadata' (PIPELINE_READINESS_ROADMAP.md:68) is RESOLVED. Josh ruled it 2026-07-20 in the seven-ruling batch (docs/spine/DECISIONS_PENDING_JOSH.md:244-246, item B4 ADAPTIVE-AUDIO = declare now); it is declared in docs/registry_extensions.json:155-161 under the adaptive-audio owning system; and tempo_bpm, bar_length, per_stem_role are physically present as columns 23/24/25 in the T0_Theme_Registry CSV header. The T99_Translation_Audio PROPOSED-NOT-RATIFIED hedges at Music Step 4/6 were flipped in place (see the doc's own line 143 note). Residual work is POPULATION (all 12 rows carry empty values), not schema.
• DECISIONS_PENDING_JOSH shows ZERO open decision items as of the 2026-07-20c banner — adaptive-audio was one of seven closed that day. There is no open Josh gate sitting on this lane other than the GRAND_SAGE_REVEAL_VOICE / HL_0046 quarantine noted below.
• T99_Translation_Audio.md EXISTS at ACTIVE v1.0 — 816 lines, flipped 2026-07-15 with a critic PASS. It closes the last THREE of the six §0 Translation Doc roster slots at once (AIVA §3 / ElevenLabs §4 / SFX §10) as one audio-family doc. It contains the full 7-step Music chain, 7-step Voice chain, 6-step SFX chain, a 15-row spike table, and a 10-step per-region build checklist. The audio lane is NOT undocumented.
• ElevenLabs key IN and probe-verified (Starter plan, 90k credits). Tools/generate_sfx.py is written, real, and has been run — first artifact smoke_stone_door.mp3.
• The mp3 -> SoundWave UE import is PROVEN with an artifact committed to the repo: C:/dev/Humanity/Humanity/Content/Audio/SFX/smoke_stone_door.uasset, imported via AssetImportTask through the UE-PYTHON bridge (NeoStack execute_script -> PythonScriptLibrary.ExecutePythonCommand). Roadmap queue item #8 (the ElevenLabs SFX-to-UE round-trip) is COMPLETE, not pending — the roadmap listed the '->UE import leg rides the next editor session' and that session happened.
• The DataTable bulk seam is VERIFIED (Tools/import_registry_datatable.py, evidence /Game/Data/Smoke/DT_ImportSmoke, 3 rows). The audio lane can reuse it as-is once row structs exist — the transport is not a build item, only the per-registry structs are.
• Kokoro language coverage — flagged 'unconfirmed' as spike #7 in T99_Translation_Audio §2.6 — is now CONFIRMED at 54 voices across 8 languages, 24kHz (PIPELINE_READINESS_ROADMAP.md:149). The spike is answered; only the throughput half remains open.
• T0_SFX_Registry is ACTIVE v1.0 with 12 genuinely populated rows carrying real audio-engineering fields (layering_role, spatial_attenuation, vril_density_modifier, integrity_band_modifier, cultural_authenticity_source, hard_line_anchors, pipeline_consumer). This is further along than 'DRAFT stub' framing suggests.
• The Flores region-page pass-2 added inline adaptive-class tags {adaptive | loop | oneshot} to every Section-10 track brief, explicitly 'derived from the cue's own behavior, for Music Step 4 stem-splitting'. Half the machine cue table's hardest column already exists as authored canon — the build item below is largely a formalization, not a fresh authoring pass.
• T0_Scene_Spec_Registry already carries the complete downstream audio FK surface (music_cue_id_ref, sfx_category_array, sfx_id_ref_array, voice_refs, audio_priority_layer, scene_audio_intent) with thematic_anchor and scene_audio_intent POPULATED. The Cinematic handoff schema needs no work.

Genuinely external (not ours to build):

• AIVA IS CLOSED AS SKIP (Josh, 2026-07-27: “not emailing; the enterprise-contact path is dead”) — the API finding below is now historical, and was never a build item. AIVA's own ToS (fetched live 2026-07-15) states API access 'is ruled by a separate Licensing Agreement, to be negotiated and signed between the parties', with no published pricing or endpoint docs anywhere, and 'Enterprise' contractually defined as 3+ employees AND $300k+ prior-year revenue — a solo dev may not qualify at all. No amount of engineering produces this endpoint. MITIGATION ALREADY RULED: the canonical-theme track is composer-in-loop regardless, so a human generating in AIVA's web app and handing the draft into the DAW review step loses NOTHING except the automation layer; and the roadmap already recommends SKIP AIVA for now in favour of the open-source bench class. Practical effect on the lane: near zero. Do not treat this as blocking.
• AIVA TIER (HISTORICAL — the vendor is closed as skip, Josh 2026-07-27; retained because the ship-legality principle generalizes): only the Pro tier (approx EUR 33/mo billed annually, 'Copyright owned by YOU') can ship. Free and Standard explicitly retain AIVA's own copyright and grant at most a YouTube/Twitch/TikTok/Instagram monetization licence that does not cover music inside a purchased game. If AIVA is ever used, Pro is not optional.
• SONNISS AND EASTWEST CONTRACTUALLY PROHIBIT AI/ML TRAINING on their licensed audio (verified directly). Irrelevant to the actual near-term need (direct shipped use is fully permitted), but a hard wall against the memory-tracked generative-entity-system runtime layer ever fine-tuning on an owned-audio corpus that includes library-sourced material. Consequence to design in NOW rather than discover later: keep library-sourced audio in a segregated tree so a future training corpus can be assembled from generated/owned-only material without an archaeology pass.
• STABLE AUDIO OPEN 1.0 / 3.0 SMALL IS REVENUE-CAPPED (free under $1M annual revenue) and therefore permanently previz/reference-only under the ruled UNRESTRICTED-or-ROYALTY-FREE-OWNED licensing posture. Not a constraint to solve — a tool to keep off the shipped path. Note this also means spike #12's licensing half needs no further research effort: the outcome is the same regardless of the exact clause text.
• NO LOCAL GENERATIVE MODEL EXISTS ON THIS MACHINE TODAY (no ollama, no llama.cpp; fastembed is embeddings-only, and grep for Kokoro|ACE-Step|MOSS|Demucs across the game repo returns zero files). This genuinely gates ONLY the three local-model benchmarks (ACE-Step/YuE/HeartMuLa music, MOSS-SoundEffect SFX) — and even there, Kokoro-82M is documented CPU-runnable at ~2-3GB and Demucs runs on modest hardware, so the voice tooling and the stem-separation spike are NOT 5090-gated. 16 of the 20 build items above carry no hardware gate at all.
• DIALOGUE LINE TEXT DOES NOT EXIST ANYWHERE — cross-lane on the unauthored Quest Writing pipeline §6, which owns dialogue_dataset_ref. This is real but narrower than the wall list implies: Voice Step 1 (derive WHO speaks) runs today off spine beat actors and scene participant_refs, the voice generation TOOLING is buildable and testable now on placeholder text, and the per-line naming convention can be published now as a constraint the quest lane mints against. Only production VO runs actually wait on quest content.

terrain

Critical path: Georeferenced per-zone bounds (zone_bounds_wgs84 on the Zone Catalog). Every downstream terrain hop consumes a world position: region_bbox is spec'd as "derived — union of zone area_bounds" (T99_Translation_Terrain §3) but today's area_bounds is local-ENU size-only prose ("220×180×60 karst interior"), which the readiness gate's _GEOREF regex explicitly rejects ("Size-only bounds never match", check_build_readiness.py:120-123), so the union cannot be computed at all. Without it: the DEM fetch AOI must be hand-typed per region (the Liang Bua smoke bbox was), the alteration_list carve footprints have no polygon to rasterize, the WorldCover weightmaps have no grid to align to, the PCG zone-bounds actors have no polygon to place, and the UE5 lane's own BLOCKED-ON row ("georeferenced zone bounds (area_bounds is size-only, no world position)") does not clear either. It is one column on a template plus ~11 real-site coordinate lookups per page — it is NOT canon invention (Liang Bua, Kelimutu, Wae Rebo, Todo are real published places; the chapter/site assignment is already canonical and untouched), so it needs no Josh ruling, and it is the single item that converts the terrain lane from a hand-driven one-region smoke into an unattended 69-region batch.

CANON ROW -> RUNNING GAME, hop by hop. Verified against the repos on 2026-07-22, not against the 2026-07-19 wall list.

H1. Canon row exists. EXISTS — registries/T0_Region_Index [ACTIVE v1.2]/T0_Region_Index DRAFT v1.1.csv (flores_island row) + the Zone Catalog on _source/02_Tier_2_Region_Pages/flores_island.md (11 typed zone rows, joined VERBATIM from spine §3b). Four pages exist: flores_island, bali, sumatra_java, angkor_khmer.

H2. Zone row -> WGS84 georeferenced polygon. MISSING — the Zone Catalog area_bounds column carries local-ENU DESIGN SIZINGS only ("220×180×60 karst interior + 400 m forest approach", "compang center-stone + lodok fan ~500×500"). The page itself says these are "first-pass design sizings (meters, local ENU origin at the region center)". T0_Region_Index.coordinates holds a free-text DMS POINT ("8.5333°S 120.4400°E (Liang Bua); 8.6110°S 120.4689°E (Ruteng)"), not a bbox and not decimal-parseable. Gate confirms: harness/build_readiness_scorecard.md UE5 row, all 4 pages — "georeferenced zone bounds (area_bounds is size-only, no world position)".

H3. Zone polygons -> region_bbox. MISSING — T99_Translation_Terrain §3 declares region_bbox "derived — union of zone area_bounds + region-ambient rows; not separately authored", but H2 supplies no georeference to union. The only real Flores bbox in the repo is PROSE inside a "Recorded build output (terrain smoke)" bullet (flores_island.md:110), hand-typed into the smoke run, not a machine field. Live gate, all 4 pages: "BLOCKED-ON(Section-1 region_bbox machine field (WGS84))".

H4. meters_per_vertex assignment. PARTIAL — the POLICY is RULED and the wall is stale: D-MPV = Option C, tiered ladder (1 m hero set-piece / 2 m standard playable / 5-10 m ambient-vista), Josh 2026-07-21, recorded in docs/spine/DECISIONS_PENDING_JOSH.md:90-92 and applied into T99_Translation_Terrain §1/§5 item 1. What is MISSING is (a) the per-AOI value assignment on any page and (b) the machine field. Also a live SPEC/GATE MISMATCH: check_build_readiness.py:263 reads a single Section-1 meters_per_vertex, but D-MPV rules mpv PER AOI — so the ruling now wants a per-zone column the gate cannot see.

H5. DEM fetch (OpenTopography COP30). EXISTS — C:/dev/Humanity/Humanity/Tools/terrain_fetch_preprocess.py lines 59-68; key IN and probe-verified, read from env with an HKCU registry fallback (lines 28-37); Liang Bua proven (371×372).

H6. Reproject / resample to local UTM. EXISTS — same tool, lines 70-80, calculate_default_transform + reproject at resolution=(mpv,mpv), bilinear.

H7. Mosaic across DEM tiles / clip to zone polygon. MISSING — the tool fetches ONE GeoTIFF for ONE hand-typed bbox. No gdal_merge mosaic leg, no clip-to-polygon (H2 blocks it anyway).

H8. Void / NoData handling + DEM fallback trigger. MISSING (and actively defective) — line 85 np.where(np.isnan(dst), lo, dst) slams every void to the REGION MINIMUM, manufacturing false pits rather than filling. No rasterio.fill.fillnodata, no void-fraction metric, and therefore no automated NASADEM fallback trigger (T99 §5 item 5's named unknown).

H9. Alteration / carve-composite recipe layer. MISSING on both halves — no alteration_list instantiated on ANY of the 4 pages (grep for alteration_list across _source/02_Tier_2_Region_Pages/ returns zero), and no carve script exists in Tools/ (only 3 files: terrain_fetch_preprocess, generate_sfx, import_registry_datatable). T0_Vril_Site_Registry carries no footprint column by design — the page must supply WHERE.

H10. Era-modification pass (sea level, coastline, deforestation reversal, volcanic state). MISSING — present as Section 1 PROSE on flores (lines 114-121: deep-time sea-level shift, pre-colonial forest reversal, live geothermal) but never structured into the §3 era_modifications field and no raster pass consumes it.

H11. Gaea detail synthesis. MISSING — not installed, no .tor graph, CLI-tier ($99 Indie vs $199 Pro) unconfirmed with QuadSpinner. Note this step is OPTIONAL by spec (gaea_pass is a bool, "false only where relief is negligible") — it does not gate the chain.

H12. 16-bit heightmap emit + Z-scale. PARTIAL — emit EXISTS (tool lines 86-94, uint16 PNG + ue_landscape_z_scale = rng/512*100). DEFECT for the multi-tile path: the encoding is NORMALIZED PER-AOI ((dst_filled-lo)/rng), so every tile of a region gets its own independent lo/rng. Adjacent World Partition tiles will therefore NOT stitch (visible seams), and water_plane in absolute meters is unrepresentable. Fine for the single-actor Liang Bua smoke; wrong the moment a region tiles.

H13. target_footprint / World Partition tiling math. MISSING — nothing computes vertex count from bbox×mpv, nothing decides single_tile vs N-tile against the 8,129-vertex actor cap, nothing splits the PNG into tiles.

H14. Landscape creation from heightmap file. EXISTS — and this retires the wall list's top terrain engineering dependency. T99_Translation_Terrain §5 item 8 calls a C++ ALandscape::Import() shim "the single highest-priority engineering dependency in the whole chain"; it is OBVIATED. NeoStack exposes lvl:import_heightmap({file, scale, location}) as a level-handle method that builds a real Landscape directly from a 16-bit PNG (game CLAUDE.md:105-112, VERIFIED 2026-07-20; Liang Bua 371×372 -> 379×379, 36 components). Binding source: Plugins/NeoStackAI/Source/NeoStackAI/Private/Lua/Bindings/LuaBinding_LevelDesign.cpp:3463, backed by LandscapeImportHelper.h.

H15. Repeatable scripted import. PARTIAL — the seam is verified and was driven BY HAND once. No Tools/import_landscape.py exists (the pattern to copy is Tools/import_registry_datatable.py, which does exactly this shape over the same NeoStack channel).

H16. WorldCover / Sentinel-2 fetch. MISSING — T99 §2 Step 2 says "same-session calls also fetch ESA WorldCover 10 m and Sentinel-2 L2A", but the tool fetches DEM ONLY. Note a spec error worth catching: WorldCover is NOT served by OpenTopography's /API/globaldem endpoint, so this is a NEW source integration (Terrascope / AWS Open Data / Planetary Computer STAC), not a parameter change.

H17. WorldCover -> material-layer reclass + worldcover_biome. MISSING — no reclass table for the 11 WorldCover classes, and no worldcover_biome column on any Zone Catalog (live gate names it on all 4 pages).

H18. Weightmap import onto the Landscape. EXISTS (seam) — second stale-wall correction. T99 §2 Step 8 carries a caveat about "no first-class public painting API"; that is obsolete for THIS project. NeoStack exposes import_weightmap({file, landscape, layer, region}) for 8-bit grayscale PNGs (LuaBinding_LevelDesign.cpp:345, :3613), plus create_landscape_layer, paint, auto_paint (slope/height rules), get_weightmap, and edit_layer. What is MISSING is only the upstream rasterizer that PRODUCES the per-layer PNGs (blocked by H16/H17).

H19. World Partition enable / grid config / data layers. EXISTS (seam) — lvl:partition("enable" | "configure_grid" {cell_size, loading_range} | "set_streaming" | "create_layer" | "add_to_layer" | "set_layer_state") (LuaBinding_LevelDesign.cpp:453-463). Unexercised for terrain, but present.

H20. PCG biome population keyed to zone polygons. PARTIAL/MISSING — Epic's ModelContextProtocol PCG toolset is SMOKE-TESTED end to end (CreateGraph -> AddNode -> ConnectNodePins -> GetGraphStructure, saved at /Game/Data/Smoke/PCG_HelloGraph, game CLAUDE.md:91-99), and lvl:scatter exists. MISSING is the binding layer T99 §5 item 9 flags as having "no existing product feature": no terrain_type -> PCG-template table, and no zone-polygon -> PCG bounds-actor -> graph-selection mechanism (also blocked by H2's missing polygons).

NET SHAPE: the ENGINE half of this lane is substantially more complete than the roadmap says (H14, H18, H19 all verified seams; the "highest-priority C++ shim" is unnecessary). The lane's real remaining work is CANON-SIDE structuring (H2, H3, H4, H9, H10, H17) and PYTHON PREPROCESSING (H7, H8, H12-defect, H13, H16), plus one binding layer (H20). Nothing on the critical path is 5090-gated.

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• OpenTopography API key IN and probe-verified; read from OPENTOPOGRAPHY_API_KEY with an HKCU registry fallback so it works from any shell (Tools/terrain_fetch_preprocess.py:28-37). The roadmap §1 line 'needs a free OpenTopography key (Josh registers) + one rasterio install' is STALE.
• Tools/terrain_fetch_preprocess.py exists and RUNS the whole fetch->reproject->resample->16-bit PNG + meta JSON leg, with the Copernicus modified-data attribution emitted into the JSON. Liang Bua proven: 371x372 vertices, elevation 141.75-1187.07 m, UE Z-scale 204.164. Roadmap §2 queue item 9 is DONE.
• THE LANDSCAPE-CREATION C++ SHIM IS OBVIATED. T99_Translation_Terrain §5 item 8 / §2 Step 7 call an ALandscape::Import() C++ shim 'the single highest-priority engineering dependency in the whole chain'. NeoStack's lvl:import_heightmap({file,scale,location}) already builds a real Landscape from a 16-bit PNG file (game CLAUDE.md:105-112 VERIFIED 2026-07-20; LuaBinding_LevelDesign.cpp:3463 over LandscapeImportHelper.h). Liang Bua was imported: 371x372 png -> 379x379, 36 components. Do not build the shim.
• THE WEIGHTMAP-PAINTING CAVEAT IS OBSOLETE FOR THIS PROJECT. T99 §2 Step 8 warns there is 'no first-class public painting API'. NeoStack exposes import_weightmap({file,landscape,layer,region}) for 8-bit grayscale PNGs plus create_landscape_layer / paint / auto_paint (slope+height rules) / get_weightmap / edit_layer (LuaBinding_LevelDesign.cpp:345, 416-423, 3613). Only the upstream rasterizer that produces the PNGs is missing.
• World Partition authoring is exposed and needs no build: lvl:partition('enable' | 'configure_grid' {cell_size, loading_range} | 'set_streaming' | 'create_layer' | 'add_to_layer' | 'set_layer_state' | 'info') (LuaBinding_LevelDesign.cpp:453-463).
• D-MPV IS RULED — the wall-list item 'No single resolved meters_per_vertex value ... Josh ruling' is CLOSED. Josh ruled Option C on 2026-07-21: a per-AOI tiered ladder (1 m/vertex hero set-pieces, 2 m standard playable, 5-10 m ambient/vista), with the Liang Bua 30 m value kept as a SMOKE artifact. Recorded at docs/spine/DECISIONS_PENDING_JOSH.md:90-92 and applied into T99_Translation_Terrain §1 and §5 item 1. Only the field and the per-AOI assignment remain.
• T99_Translation_Terrain [ACTIVE v1.0] exists and is flipped ACTIVE (2026-07-15, critic PASS-WITH-FIXES all six fixed) — the full 8-step chain, the §3 PARAMETERS BLOCK schema, the previz gating, and the §5 unknowns table are all specified. The terrain lane HAS its Translation Doc.
• harness/check_build_readiness.py exists with real, non-vacuous terrain teeth (lane_terrain at :257-270; a _GEOREF regex that rejects size-only bounds; a _NOT_RULED regex that rejects smoke/placeholder mpv values but deliberately does NOT reject an affirmatively-ruled value mentioning Josh), is enrolled as the 'build_readiness' gate in harness/gates_config.json:457, and emits a live per-page x per-lane matrix with named missing inputs.
• harness/apply_region_page_sections.py exists as the SAFE single-writer for whole '### Section N' spans in a region page, with hard-fail guards against wrong-place writes and untouched-section drift. The mechanism to land a Section-1 parameters block is already built — only the block's content and its derivation tool are missing.
• Epic's ModelContextProtocol PCG toolset is smoke-tested end to end (CreateGraph -> AddNode -> ConnectNodePins with auto-inserted type-filter conversion -> GetGraphStructure, saved at /Game/Data/Smoke/PCG_HelloGraph), and lvl:scatter exists — so the PCG half of Step 8 is a binding problem, not a capability problem.
• Four region pages exist and are gate-passing structurally (flores_island as the v2.0 pilot, plus bali, sumatra_java, angkor_khmer), each with a typed Zone Catalog joined VERBATIM from the spine §3b rows — the terrain lane's input surface is populated, just not georeferenced.
• The terrain lane is confirmed NOT book-gated: geometry is DEM-derived (roadmap §5 states this explicitly).

Genuinely external (not ours to build):

• OpenTopography rate limit: 50 API calls per 24 hours for non-academic keys. 69 regions x (COP30 + a NASADEM cross-check + retries) exceeds a single day's quota, so the 69-region batch is inherently multi-day unless cached. Mitigable by us (a local DEM cache + limiter, build item terrain-08), but the cap itself is theirs and cannot be engineered away.
• OpenTopography commercial-integration terms: an Enterprise key is required for integrating their API INTO commercial software. Our use is offline authoring-time asset generation, not runtime integration, which very likely falls outside that clause — but the determination is OpenTopography's to give, not ours to assume. This was flagged as an under-specified doc correction in the roadmap §6 terrain section and is still unrecorded. Low risk, needs one email.
• Gaea CLI licensing tier: whether headless/CLI automation requires Professional ($199) rather than Indie ($99) is UNCONFIRMED — QuadSpinner's edition page names no CLI restriction but one source claimed Pro is required. Only QuadSpinner can answer. Note this constrains an OPTIONAL step (gaea_pass is a bool), so it gates polish, not the chain.
• Gaea 3.0 shipped-status is unconfirmed; the plan targets Gaea 2.3 (confirmed shipped June 2026) until 3.0 is verified live. Vendor release timing, not ours.
• ESA WorldCover and Sentinel-2 L2A are NOT served by OpenTopography's /API/globaldem endpoint, contrary to T99 §2 Step 2's implication. They require a separate provider (Terrascope, AWS Open Data, or Microsoft Planetary Computer STAC), each with its own auth and quota terms. This is a doc error to correct plus a new integration to build, not an unavailable capability — all three sources are free and open.
• Copernicus GLO-30 licensing is clean and NOT a constraint: global, free, explicitly commercial and non-commercial with no time limit. The only obligation is the modified-data attribution notice, which the tool already emits into the meta JSON.
• PCG Biome Core ships Experimental at v0.2 across UE 5.5-5.8. Its API surface and runtime performance are Epic's to stabilize; we can build against it but should not treat its interface as pinned.
• UE 5.8 Mesh Terrain (true XYZ mesh, overhangs, non-destructive modifiers) is Experimental with an undocumented scripting surface this release. A future re-target for cave/overhang geometry, entirely on Epic's timeline — WATCH only, and explicitly not on the critical path.

quest — Quest writing / dialogue

Critical path: Q-1 — the T0_Quest_Definition_Registry schema extension: append the ~16 already-ruled §6.5 columns to the live CSV, declare them under a 'quest-schema-v2' owner in docs/registry_extensions.json, and refresh docs/fidelity_baseline.json in the same commit. It unblocks the most by a wide margin, and it is the single item where the gap between the spec and the data is pure mechanical work. The §6.5 spec is COMPLETE and RULED — the contract closed 30 of the spike's 32 gaps across the 2026-07-20 mechanical pass and the 2026-07-21 director pass — but the live registry is still the original 27-column, 16-row table with no extension declared anywhere (verified: no quest key in registry_extensions.json, no quest entry in fidelity_baseline added_columns). Until that column set exists: the 25 critic-gated quests and 88 dialogue lines already authored in the spike have nowhere to land; FQuestDefinitionRow cannot be authored because the column set is not final; the verified DataTable import seam has no table to import; check_quest_rows.py has nothing to validate; and Q-7 — the quest_type enum proposal that schema v0.2.2 §11.1 explicitly assigns to the first quest-writing pass, and which unblocks the seed harvest for all 69 regions — has no authored rows to argue from. It needs no hardware, no external service, and no Josh ruling: every column is already ruled contract text. It is a day of careful mechanical work standing in front of the entire lane.

CHAIN: spine beat row -> quest-authoring pack -> authored quest row -> T0_Quest_Definition_Registry -> DD dialogue CSV -> C++ USTRUCT -> UE DataTable -> runtime quest/dialogue subsystem evaluating condition_expression against worldstate.

HOP 1 — Spine beat graph as the authoring skeleton. EXISTS. docs/spine/CH_NN.md x79, v3.1 twenty-block form: beat rows (Block 10, beat_id CH0N_BNN, permanence absolute), fork graph (Block 10b, three closed table grammars CHOICE-8 / DISPATCH-7 / SIX-OPTION-7), site rows (Block 8/§3b site_id), SQ rows (Block 11 sq_stage + gate), scene rows (Block 13 seven-column). Validated by harness/check_spine_graph.py.

HOP 2 — Extract spine rows into machine form. MISSING as a tool. check_spine_graph.py parses every one of those tables but only to validate; it emits no CSV/JSON. harness/enrich.py is chapter-scoped for SPINE authoring (enrich.py chapter CH_NN --json) and has no quest mode. harness/extract_claims.py extracts claims, not spine rows. The roadmap §3 "spine-row extractor does not exist" wall is STILL TRUE and it bites this lane as hard as the ue5 lane — realized_beat_refs, objectives_array.beat_ref, spatial_requirements_array.site_ref and fork_option_refs are all FKs into rows no tool emits.

HOP 3 — Region substrate for regional quests. PARTIAL. Region pages exist (flores_island, bali, sumatra_java, angkor_khmer). The book->seed feed is LIVE: docs/proposals/quest_seed_queue/<region>.md (12 regions; 71 audited flores seeds) regenerated by harness/rag/deep_read.py from docs/book_extractions/EXR_*.json. MISSING: the typed Section-13 seed stub (CG-22, ruled) is instantiated on no page, so seeds have no typed landing and the §7.5 typing step has no target schema.

HOP 4 — Author the quest. PARTIAL/PROVEN. The Ch 2-5 SPIKE RAN (roadmap queue #1): docs/proposals/quest_spike/CH_02..CH_05_quests.md + SPIKE_REPORT.md — 46 beats decomposed, 25 main quests, 17 SQ stages, 88 dialogue lines, four fresh-context critics, all GO-WITH-FIXES, zero reveal leaks, zero §17.1 community-targets. It is proposal-tier markdown, not rows.

HOP 5 — Land the quest row. PARTIAL — THE BREAK. Schema T1_Build_Pipeline_Contracts §6.5 is now FULLY SPECIFIED (mechanical completion pass 2026-07-20 + director pass on the 2026-07-21 ruling batch closed 30 of the spike's 32 gaps). But the LIVE CSV registries/T0_Quest_Definition_Registry [ACTIVE v1.0]/T0_Quest_Definition_Registry.csv still carries the OLD 27 columns and 16 rows. The ~16 new typed fields (encounter_facet, sq_stage, sq_gate_condition, quest_giver, trigger_type, realized_beat_refs, objectives_array, completion_condition, fail_state, progression_guarantee, state_writes, fork_option_refs, reward_class, ability_unlock_refs, reward_drop_refs, reward_seed_refs) have NO column, NO owner entry in docs/registry_extensions.json (verified: no quest key), and NO added_columns entry in docs/fidelity_baseline.json (verified: empty match). Authored content has literally nowhere to land.

HOP 6 — dialogue_dataset. FORMAT RESOLVED / FILES MISSING. §6.5 pins it: one CSV per quest at docs/quest_dialogue/DD_<quest_id>.csv, columns line_id, speaker_ref, trigger_beat, line_text, condition_expression, loc_namespace_key; extension pinned to csv; per-quest not per-character. The dead Drive path and the canon/dialogue_datasets/ proposal (PIPELINE_ADAPTER L120) are both SUPERSEDED. Verified: docs/quest_dialogue/ does not exist, zero DD_* files anywhere in the repo, and no writer or validator exists.

HOP 7 — condition_expression. GRAMMAR RESOLVED / NO PARSER. §6.5 reconciled every conditional surface (quest gates, objective completion_condition, sq_gate_condition, line-variant selection) onto the SINGLE §9.5 mini-grammar: has(local.k), at(site_id), flag(local.k), ws.key with == >= <= in, read(surface), boolean & and |, produce-before-consume. Documented in Contracts §9.5 + SPINE_SCHEMA_v3. MISSING: no EBNF, no operator precedence, no type rules for comparing against a WS_NNN domain, and no parser — check_spine_graph.py:511 only regex-scans (has|flag)\(local\.x\) for produce-before-consume. Nothing can evaluate an expression.

HOP 8 — Registry -> UE DataTable. SEAM EXISTS, ROW TYPES MISSING. C:/dev/Humanity/Humanity/Tools/import_registry_datatable.py is VERIFIED end-to-end over the NeoStack MCP channel (:9315, create_asset 'datatable' with option key Struct = a NATIVE /Script/... USTRUCT, FillDataTableFromCSVString, read-back, save). Two registries already landed: Content/Data/Registries/DT_BossEncounter.uasset, DT_ChapterIndex.uasset. MISSING: FQuestDefinitionRow and FDialogueLineRow — Source/Humanity/Public/Data/ holds only BossEncounterRow.h and ChapterIndexRow.h. The tool's own header states the hard constraint: UserDefinedStructs are a dead end on this seam, so each registry needs a C++ USTRUCT first.

HOP 9 — Runtime. MISSING ENTIRELY. Source/Humanity/ has Combat/ (CombatTelemetrySubsystem, HumanityAttributeSet, HumanityDensitySubsystem) and Data/ (two row structs). There is no UQuestSubsystem, no objective tracker, no dialogue player, no six-option wheel, no condition evaluator, and no UWorldStateSubsystem — the last is referenced in two existing headers as a planned sibling ("the shared UWorldStateSubsystem, Combat TD Step 7") but does not exist. Without it, state_writes commit nowhere and ws.key in any condition resolves to nothing.

HOP 10 — Translation Doc layer. MISSING. docs/translation/ holds AssetGen, Audio, Cinematic, Combat, Terrain, UE5_Build. There is NO T99_Translation_Quest.md — the quest lane is the only major lane with no platform-specific inference doc, so the row-to-UE-mechanism mapping (which subsystem, StateTree vs FSM for objectives, DataTable-driven dialogue, FText String Table from loc_namespace_key, save through the worldstate subsystem) is unauthored.

HOP 11 — Readiness reporting. MISSING. harness/check_build_readiness.py:112 defines LANES = [Terrain, UE5, Combat, Cinematic, Audio, AssetGen]. There is no Quest lane predicate, so the quest lane is invisible to the per-page readiness matrix.

SUPPORTING REGISTRIES: T0_Questline_Index is POPULATED (23 rows: SQ1-SQ12 + TRADE_01-10 + legendary) so questline_id resolves. T0_Worldstate_Variables 42 rows so ws.* resolves. T0_Quest_Seed_Registry 0 rows and T0_RNG_Drop_Table 0 rows — the reward FK slots are pinned but their targets are empty.

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• WALL 1 RESOLVED (roadmap §3 row 70, 'dialogue_dataset file format and extension are unpinned'): §6.5 PINS both — one CSV per quest at docs/quest_dialogue/DD_<quest_id>.csv, file_extension pinned to csv, with a pinned column set (line_id, speaker_ref, trigger_beat, line_text, condition_expression, loc_namespace_key). Closed in the 2026-07-20 mechanical completion pass. The per-character-per-quest file split is superseded by the per-line speaker_ref column.
• WALL 2 RESOLVED IN DOC (roadmap §3 row 71, 'landing path is a dead Google-Drive path; canon/dialogue_datasets/ is un-ratified'): CG-09 is closed. The landing path is docs/quest_dialogue/ — repo-native and registries-adjacent. The canon/dialogue_datasets/ proposal at PIPELINE_ADAPTER.md line 120 is SUPERSEDED, not pending. RESIDUAL AND REAL: the directory does not exist and zero DD_* files exist anywhere in the repo (verified by find).
• WALL 3 LARGELY RESOLVED (roadmap §3 row 72, 'condition_expression grammar is undocumented — operands are named but no expression syntax exists'): CG-11 is closed by RECONCILIATION rather than by minting a second language — every conditional surface (quest gates, objectives_array.completion_condition, sq_gate_condition, line_variant selection) now uses the single §9.5 mini-grammar, which IS documented with operands and operators: has(local.k), at(site_id), flag(local.k), ws.key with == >= <= in, read(surface), boolean & and |, produce-before-consume. RESIDUAL: no EBNF/precedence/type-rules and no parser — check_spine_graph.py:511 only regex-matches has()/flag() for produce-before-consume.
• THE ROADMAP QUEUE-#1 SPIKE RAN AND DELIVERED (2026-07-20). docs/proposals/quest_spike/ holds CH_02..CH_05 quest drafts + SPIKE_REPORT.md: 46 spine beats decomposed, 25 main-story quests, 17 side-questline stages, 88 dialogue lines, four independent fresh-context critics, unanimous GO-WITH-FIXES. Every beat citation, ws.* write, zone anchor, reveal-ceiling check and §17.1 care check passed; no draft invented a gap.
• THE SPIKE'S 32 CONTRACT GAPS ARE 30-OF-32 CLOSED. The 2026-07-20 mechanical pass closed CG-01..CG-05, CG-07..CG-12 and CG-19; the director pass following the 2026-07-21 ruling batch closed CG-13, CG-14, CG-15, CG-16a/b, CG-17, CG-18, CG-20, CG-21, CG-22, CG-23, CG-24, CG-25, CG-26, CG-27, CG-28. §6.5 now carries typed objectives_array, completion_condition, state_writes, realized_beat_refs, site/zone FKs, sq_stage + sq_gate_condition, quest_giver + trigger_type, fail_state + progression_guarantee, fork_option_refs, the reward triple, encounter_facet, and two new dialogue_types (non_lexical_vocalization, interiority_narration). Only CG-29 (Champa, book-gated) and CG-30 (persona depth) remain open.
• quest_type RULED 2026-07-21 as EXR_RECORD_SCHEMA_v0.2 §11.1 (v0.2.2): proposed_quest_type is REMOVED from the seed-queue ratification gate; typing moves downstream to the §7.5 Section-13 step; five attested values are blessed (canonical_hard_line, epilogue_resolution, prologue_baseline, main_story_per_chapter, side_questline_stage). This unblocked all 71 flores seeds and would have blocked every one of the 69 regions identically. It also lands a STANDING OBLIGATION on this lane: the first quest-writing pass proposes the enum from what it actually needed (build item Q-7).
• CG-16a RULED BY JOSH 2026-07-21: biography slots (Sympathetic, Detached, Curious, Defiant) carry ZERO integrity delta; only Truly Good and Truly Bad carry the fork's class delta; per-slot tone-to-outcome routing rides to the dialogue build; WS_018 is a system-level accumulator exempt from micro-fork-promotion. The six-option wheel is no longer an open design question for the dialogue runtime.
• CG-26 RULED/CALIBRATED BY JOSH 2026-07-21 (§6.8): elevated-care audit routing is content-driven, not fixed-chapter-list-driven — but calibrated to the LIGHTER batch-audit tier outside the fixed eight, explicitly to prevent care-tier inflation ('this is a rated M action adventure fantasy RPG... do not go overboard'). The CH_04 author_in_loop contradiction is resolved in place.
• T0_Questline_Index IS POPULATED — 23 rows (SQ1 fairy_tale_folklore .. SQ12 secret_societies, TRADE_01..TRADE_10, plus legendary-weapon rows), each with a source_anchor citing the spine block-11 SEED line. CG-06 is closed; questline_id now resolves. The 2026-07-21 brief's 'bare-title stub with zero rows' description is STALE.
• quest_id FORMAT PINNED (CG-10): quest_id = QUEST_<quest_anchor_id>_<path_bucket>, and quest_anchor_id is also the canonical beat-to-quest decomposition unit. The spike's placeholder QS_CH_0N_NN form is retired. Also pinned: dialogue_dataset_id = DD_<quest_id>.
• A LIVE BOOK-TO-SEED FEED EXISTS. docs/proposals/quest_seed_queue/ holds 12 region files (flores-indonesia 71 audited proposal-tier seeds, plus bali, sumatra_java, angkor-khmer, rome-italy, vietnam, malay-world, sumatra-batak, fairy-literary, esoteric, cross-cutting), regenerated by harness/rag/deep_read.py over docs/book_extractions/EXR_*.json. Each seed carries seed_kind, proposed_layer, care_flag, chapter_ref, region_ref, game_surface_routing, and page-anchored citations. The quest lane now has real substrate inflow, not a hypothetical one.
• THE UE DATATABLE SEAM IS VERIFIED, NOT THEORETICAL (2026-07-20). Tools/import_registry_datatable.py imports a registry CSV to a DataTable over the NeoStack MCP channel end-to-end; Content/Data/Registries/ already holds DT_BossEncounter.uasset and DT_ChapterIndex.uasset from real runs. The quest lane inherits a working import vector — it only needs its row structs.

Genuinely external (not ours to build):

• Anthropic API credentials + a per-quest-category model pin for the build-time Quest Writer orchestration agent (Contracts §6.4). Today authoring runs inside Claude Code sessions, which is fine for the Ch 2-5 batch; the contract's envisioned unattended production loop over millions of words needs a pinned key, a pinned model per quest category, and an iteration budget in the (not-yet-created) config/build_pipeline.toml. This is a procurement + config decision, not an engineering blocker — the lane can author at slice scale without it.
• ElevenLabs licensing at production VO volume. The key is IN and probe-verified (Starter, 90k credits; Tools/generate_sfx.py ran). The genuine external items are the 'Large Studio Games' written confirmation from ElevenLabs and a paid tier sized to full per-line VO. Neither blocks writing dialogue text — only speaking it at scale. The audio lane's named blocker ('dialogue line text does not exist anywhere') is CROSS-LANE, resolved by this lane's Q-5/Q-6, not by anything external.
• Josh's physical book scanning for CG-29 — the Champa/Cham ELEVATED cultural-grounding obligation on Ch 5, recorded as owed and unmet at spike tier and gated behind the BOOK_ACQUISITION MUST-ACQUIRE Cham sources (~3 weeks of scanning remaining across the high-care set: Ch 29 Sámi, Ch 42 Vodou, Ch 57 Australia, Ch 11-13, 47-48, 50). This gates PASS-2 per-region production quest CONTENT at high-care regions ONLY. It gates nothing in the machine layer, nothing in the Ch 2-5 slice (Indonesia corpus is drained), and nothing on the main-story or hard-line quest set, which is spine-gated.
• No 5090-gated item sits on this lane's critical path. The only genuinely 5090-bound work is the persona-voice LoRA/QLoRA training run (Q-21) and, at real volume, draft-tier pre-drafting / bulk FK resolution / embedding-based dedupe as accelerants. The dataset ACCUMULATION for the LoRA is buildable today and should start now. Nothing else in the lane should be parked behind the workstation.
• No local generative model exists on this machine today (no ollama, no llama.cpp; fastembed is embeddings-only). This is real but does not touch the quest lane — quest authoring is Opus-tier work by design (canon/quality-bearing authoring is explicitly excluded from local-model use), and every gate, extractor, parser and transform in the build list is deterministic Python.

assetgen

Critical path: The assetgen-pipeline registry extension — declaring and scattering the T1_BPC §2.6 column set (mesh_tags, asset_category, asset_routing, generation_status, generation_prompt_hash, last_generated_timestamp, regeneration_trigger, plus mesh_id_ref on the five registries lacking it) across the six live asset-bearing registries via docs/registry_extensions.json + a fidelity re-baseline. It is zero-gated (the mechanism is built and proven across 10 registries already), and every hop downstream of prompt composition dead-ends without it: the composer has nothing to read, the state machine has no state to hold, the writeback has nowhere to land, and the region-page asset block and the Blender/import legs both terminate in these columns. It is also the field set the gate that measures this lane (harness/check_build_readiness.py lane_assetgen) is literally asking for.

CANON ROW -> A MESH IN THE RUNNING GAME. Ten hops.

HOP 1 — the canon entity row exists. PARTIAL. Live and populated: T0_Weapon_Registry/Sheet1 (72 rows), T0_Creature_Roster/Sheet1 (132), T0_Vril_Site_Registry/Sheet1 (42), T0_Boss_Encounter_Registry/Sheet1 (281 — the roadmap already refuted the "0 rows" claim), T0_Character_Index (163), T0_Antagonist_Network_Registry/Sheet1 (64). MISSING: registries/T0_Familiar_Registry [DRAFT v0.1]/Sheet1.csv contains exactly ONE line — the doc title — no header, no rows, though §2.2 makes it a required generation source (33 species / 22 slots / 12 Father-bonded). Architectural Features have no registry BY CONTRACT (§2.6 puts them inline on region-page Section 7) and Section 7 is 100% prose on all four built pages (flores_island.md L776-793).

HOP 2 — per-asset routing tag (which backend; real-cultural vs fantastical vs MetaHuman). MISSING everywhere. No asset_category / mesh_category / asset_routing column on any registry; no such machine field on any region page. The rule lives as a prose sentence (flores_island.md L778: "REAL cultural architecture is reference-built, never raw-generated"). The Zone Catalog protected boolean is NOT a usable proxy — real heritage sits in protected:false zones (flores wae_water_spring, angkor west_baray).

HOP 3 — mesh_tags {morphology, region, style, material, era}, the §2.5 prompt-composition input. MISSING on every registry and every page. Confirmed mechanically, not by inspection alone: harness/check_build_readiness.py lane_assetgen reports all four pages BLOCKED-ON("per-asset morphology/asset_concept field"; "asset_category / mesh_tags field") in harness/build_readiness_scorecard.md.

HOP 4 — prompt composition + generation_prompt_hash (the §2.4 orchestration agent). MISSING. No such script in harness/ or C:\dev\Humanity\Humanity\Tools\ (grep for blender|trellis|assetgen|mesh_tags across both returns only check_build_readiness.py's own docstring and NeoStack plugin source). The SUBSTRATE side it would read is EXISTS and strong: the region-filtered RAG (~661k chunks, harness/rag/), harness/recall.py, and the flores pass-2 page (555 -> 1721 lines, 8 critic-corrected sections).

HOP 5 — generation. PARTIAL, and much more live than the wall list implies. EXISTS at the interim/cloud tier on the CURRENT machine: NeoStack ships a full generative provider layer in source — Plugins/NeoStackAI/.../Lua/Bindings/LuaBinding_Generate.cpp registers a global generate(opts) (L38-49, L1239-1249) routing to registered providers with actions text_to_3d / rig / retexture / check / import / get_result / cancel / balance / discover; Providers/MeshyProvider.cpp and Providers/TripoProvider.cpp are both compiled in. Tripo alone exposes text_to_model, image_to_model, multiview_to_model, refine_model, texture_model, mesh_segmentation, mesh_completion, highpoly_to_lowpoly (retopology), animate_prerigcheck, animate_rig, animate_retarget. Reachable today through the verified NeoStack MCP channel (127.0.0.1:9315, execute_script). Gated only on a MeshyApiKey (MeshyProvider.cpp L193) / Tripo key + cloud credits. MISSING/5090: the ruled SHIPPED-path local stack (TRELLIS.2 / Hi3DGen / Hunyuan3D-2.1) — a real 24-29GB VRAM floor.

HOP 6 — Blender finishing (retopo, UV, LOD chain, collision, FBX export). PARTIAL. Blender 5.1 IS INSTALLED at C:\Program Files\Blender Foundation\Blender 5.1\blender.exe (not on PATH) — the roadmap queue-#10 prerequisite is satisfied. MISSING: no finishing script exists in either repo. T99_Translation_AssetGen §4.3 specifies the mechanism exactly (blender.exe --background --python, Decimate LOD chain under UE's _LOD0/_LOD1 auto-detect, convex-hull collision) and pins the Decimate target to T1_BPC §1.7's steam_deck_minimum column — whose NUMBERS are 5090-benchmark-deferred, but the script is not.

HOP 7 — FBX -> UE import. EXISTS, two independent proven vectors. (a) the UE-PYTHON BRIDGE through NeoStack — invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand'), VERIFIED 2026-07-20 with unreal.AssetImportTask (mp3 -> SoundWave at /Game/Audio/SFX/smoke_stone_door), which is precisely the API §4.3 claims as this doc's owned seam; (b) NeoStack's own generate{action='import'}, which downloads and imports a provider result directly.

HOP 8 — registry writeback (mesh_id_ref + the five supporting columns). PARTIAL -> MISSING. mesh_id_ref exists as column 8 of T0_Weapon_Registry/Sheet1 and is 0/72 populated; it exists on NO other registry despite §2.6 requiring it on all seven. The other five required columns exist on ZERO registries. The gate-safe mechanism to add them EXISTS AND IS PROVEN: docs/registry_extensions.json (per-system column ownership; 10 registries already carry extension columns) + docs/fidelity_baseline.json added_columns/extension_hashes + harness/check_registry_extensions.py. There is no assetgen owner block in that manifest today. Note the seam constraint: the game repo is READ-ONLY against canon (game CLAUDE.md, one-writer-per-repo hard rule), so writeback must cross as a manifest file, not a direct write.

HOP 9 — UE consumption (row -> DataTable -> spawned/placed actor). PARTIAL, cross-lane to ue5. The DataTable bulk seam is VERIFIED (Tools/import_registry_datatable.py; /Game/Data/Smoke/DT_ImportSmoke), but each registry needs a C++ USTRUCT(FTableRowBase) row type authored in Source/ first — UserDefinedStructs are a proven DEAD END on this seam. No row struct exists for any asset-bearing registry.

HOP 10 — the §17.1 capture-rights gate on the reference-built path. MISSING. No reference_image_ref / capture_rights / reference_source / use_class field anywhere in the asset lane. The PATTERN exists and is live one lane over — use_class governs the book-substrate citations (flores_island.md L1683), which is the exact parallel T99_Translation_AssetGen §6 names ("parallel to the use_class discipline already governing the book-processing substrate lane").

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• BLENDER IS INSTALLED — Blender 5.1 at C:\Program Files\Blender Foundation\Blender 5.1\blender.exe (not on PATH). The roadmap queue-#10 prerequisite 'Blender installed' is satisfied; only the finishing SCRIPT is missing.
• THE FBX->UE IMPORT SEAM IS VERIFIED LIVE, not theoretical — the UE-PYTHON BRIDGE through NeoStack (invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand')) was proven 2026-07-20 with a real unreal.AssetImportTask import. That is the exact API T99_Translation_AssetGen §4.3 claims as this doc's owned seam. Hop 7 is not a build item.
• NEOSTACK SHIPS A FULL GENERATIVE PROVIDER LAYER IN SOURCE, compiled into this project: LuaBinding_Generate.cpp registers a global generate(opts) with actions text_to_3d / rig / retexture / check / import / get_result / cancel / balance / discover; MeshyProvider.cpp and TripoProvider.cpp are both present. Tripo exposes text_to_model, image_to_model, multiview_to_model, refine_model, texture_model, mesh_segmentation, mesh_completion, HIGHPOLY_TO_LOWPOLY (retopology), animate_prerigcheck, animate_rig, animate_retarget. The doc's plan to 'route rigging through Tripo's universal rig via the NeoStack Cloud allowance' is a WIRED BINDING, not a proposal — and Tripo's retopology/texture actions materially narrow the §4.3 'nothing automates retopology+UV+rigging' hole at the interim tier.
• TRIPO'S COMMERCIAL-TERMS 'SETTLE-ITEM' IS CLOSED — the roadmap §6 asset lane already records that Tripo Pro grants full commercial IP ownership of generated and auto-rigged assets, usable in Unreal (Free tier is non-commercial). T99_Translation_AssetGen §2's 'license tail ... never independently verified' text is STALE.
• THE §3 'PBR HOLE IS AN EMPTY SET' FRAMING IS FLAGGED STALE by the roadmap's own §6 — current TRELLIS.2 advertises CuMesh UV unwrapping plus full PBR materials under MIT. The nvdiffrast/nvdiffrec caveat still stands so the hole is not PROVEN closed, but repeating 'no path exists' is not current.
• THE GATE THAT MEASURES THIS LANE ALREADY EXISTS AND RUNS — harness/check_build_readiness.py (gate 20, build_readiness, REPORT tier, 30/30 self-test both directions) with a real lane_assetgen predicate, emitting harness/build_readiness_scorecard.md. The AssetGen wall is machine-computed per page with named missing fields, not asserted.
• THE REGISTRY-EXTENSION MECHANISM IS BUILT AND PROVEN — docs/registry_extensions.json (single-system column ownership) + docs/fidelity_baseline.json added_columns/extension_hashes + harness/check_registry_extensions.py. Ten registries already carry system-owned extension columns (combat-encounter on Boss_Encounter, adaptive-audio on Theme_Registry, environment-grammar on Region_Index, etc.). Adding the assetgen columns is a well-trodden path, not new machinery.
• mesh_id_ref ALREADY EXISTS AS A COLUMN on T0_Weapon_Registry/Sheet1 (column 8), 0/72 populated. The wall's 'exists in no consumable form' is fully true of mesh_tags but only half-true of mesh_id_ref.
• D-MATARG-LOOK IS RULED (Josh, 2026-07-21) and recorded in T99_Translation_AssetGen §2 — the materialized-argument boss class has a settled shared visual grammar (inscription-made-flesh: script/ledger/mark made physical, per-boss regional condemned-register skin, shared hollow-core tell). The review's item-J note that 'the visual concept itself is Josh/quest-layer' is SUPERSEDED for the grammar; per-boss asset_concept slots are creative-within-vision, not a Josh gate.
• THE PROMPT-COMPOSITION SUBSTRATE IS LIVE — the region-filtered semantic RAG (~661k chunks, harness/rag/) plus harness/recall.py plus the flores pass-2 page (555 -> 1721 lines, 8 sections authored and adversarially critic-corrected from an audited book-extraction harvest) give real style/material/morphology substrate for the Ch 2-3 asset set today.
• T0_Boss_Encounter_Registry IS POPULATED (281 rows) with care_tier, boss_kind, target_type, ontology_class, win_condition and the combat-encounter extension columns — the earlier '0 rows' claim was refuted at director adjudication. What is missing for assetgen is morphology/asset_concept, not the rows.
• THE §1.7 PER-CATEGORY-BY-SPEC-CLASS BUDGET TABLE STRUCTURE HAS LANDED (D-POLY-BUDGETS, 2026-07-20 ruling batch) with steam_deck_minimum as the named Decimate target that §4.3 reads. Only the NUMBERS are 5090-benchmark-deferred; the mechanism and the column are pinned.
• THE ENGINE-VERSION SPLIT NOTED AGAINST T99_Translation_AssetGen IS RESOLVED — UE 5.8.0 (BuildId 55116800) is the installed and pinned engine, NeoStack is installed as source and rebuilt against that BuildId, and both MCP channels are verified live. The doc's 5.8 targeting is now correct, not aspirational.

Genuinely external (not ours to build):

• Meshy and Tripo are closed third-party SaaS. Using the NeoStack passthrough needs a MeshyApiKey (MeshyProvider.cpp GetApiKeySettingName) / Tripo key plus cloud credits, and their output terms are theirs to set — Tripo requires the PRO tier for commercial IP ownership (Free tier is non-commercial). This is a purchase/terms decision, not something we can engineer around.
• The nvdiffrast/nvdiffrec dependency inside TRELLIS.2's own texture bake is NVIDIA-licensed non-commercial-only for third parties. GitHub issue #22 against the maintainers is open with no response. The only routes around it are the PyTorch3D renderer swap (we build) or Microsoft/NVIDIA relicensing (they do). Pixal3D's own MIT license does not help while its install chain hard-requires TRELLIS.2.
• Hunyuan3D-2.1 caps commercial use at 1M MAU and excludes the EU, UK and South Korea; CHORD (Ubisoft La Forge) carries a Research-Only Copyleft. Both are disqualified from the SHIPPED path by Josh's ruled unrestricted-components-by-default constraint regardless of quality. No engineering closes a license.
• Epic sunsets the browser MetaHuman Creator on a staged 2026 timeline (full shutdown November 5, 90-day retrieval window after). The in-engine creator, native since UE 5.6, is the surviving route — an external deadline that argues for building the NPC leg sooner rather than later.
• Fab/Megascans is no longer free (Epic began charging in 2025; roughly 1,500 assets remain free). Still commercially usable under the Fab Standard License, so this is a cost axis on the licensed-kit reference path, not a licensing wall.
• Per-site heritage capture rights are genuinely external legal facts. Some heritage sites and museums prohibit commercial 3D capture outright, and crowd-sourced tourist photos are third-party copyrighted material. We can build the register and the gate; we cannot build the permission, and some hero sites (the UNESCO living-heritage set on the four built pages) may simply come back prohibited — in which case that structure is licensed-kit or hand-modeled, full stop.
• The 24GB (TRELLIS.2) to 29GB (Hunyuan3D-2.1) VRAM floor is hardware. The current GPU cannot meet it; the 5090's 32GB clears both with thin headroom under concurrent load. This gates local shipped-path geometry generation and the §5 benchmark day — and nothing else in the lane.
• There is no local generative model on this machine today (no ollama, no llama.cpp; fastembed is embeddings-only). Any model-assisted mesh_tags inference or asset-concept drafting is therefore 5090-gated — but deterministic rule-table prompt composition, every schema/column/template/gate item above, and the whole Blender-and-import chain are not.

combat — Combat / physics / runtime (boss & encounter canon → GAS + StateTree → the vril-density dial → runtime generative barks)

Critical path: BUILD THE BOSS STATETREE FRAMEWORK (boss-statetree-framework) — the C++ StateTree schema, Tasks and Conditions in Source/Humanity/Public/Combat/StateTree/. It is the single largest zero-built block in a lane where everything around it already exists: the canon rows are populated and gate-enforced (281 rows, 26 columns, boss_axes green), the row struct exists, the DataTable seam is verified, the AttributeSet with all eight Composure nodes compiles, the density subsystem holds WS_024, and the telemetry producer already fires. StateTree is what consumes all of it — it carries the phase transitions (making composure_nodes and character_engagement_node load-bearing rather than merely validated), the ~30 clocks, the Withdrawal enrage-replacement, every [DIAL] react-slack lever that makes the vril-density thesis observable, the habit-vector consumer, and the environmental-boss protocol state machine. It is also the named CROSS-LANE dependency the cinematic lane is blocked on (spike C-14 / roadmap §3: 'boss cinematics fire off a boss combat-state event that no boss-AI framework yet emits'). Its own prerequisites are three small items in the same commit series — the GameplayTag source, the row parser, and the boss actor/ASC bootstrap — none of which is gated on anything. Nothing in this critical path touches the 5090.

CHAIN: canon boss row → machine combat columns → gate → UE row struct → DataTable → boss actor/ASC → abilities+phases → clocks+dial → environment → worldstate/save → cinematic event → telemetry/scorer → runtime barks.

H1 CANON ROW — EXISTS. C:/dev/humanity-forgotten/registries/T0_Boss_Encounter_Registry [DRAFT v0.1]/Sheet1.csv, 281 data rows x 26 columns (boss_kind populated main/sub/environmental).

H2 MACHINE COMBAT-SPEC COLUMNS — EXISTS (this was the named wall; it is CLOSED). win_condition, win_shape, composure_nodes, character_engagement_node, ws_writes are live on the header and back-filled on all 281 rows (verified BE_0002/BE_0002_S1/BE_0002_S2 carry real values e.g. REDUCE;FREE / standard / direct=lunge_feint_dodge__cornered_frenzy_punish;stealth=... / phase=P2;verb=weigh;integrity_routed=true). Declared through the standing discipline in docs/registry_extensions.json under system combat-encounter; docs/fidelity_baseline.json re-baselined. STILL MISSING from the T99 §4 proposal: signature_counters, phase_trigger, escalation_vector, and the boss_kind enum extension (trade_gate|school|weapon|mmo_world).

H3 MACHINE VALIDATION — EXISTS. harness/check_boss_axes.py v2 (335 lines) enforces five invariants (never-zero axis; the ruled 10-verb win_condition + 9-value win_shape binding incl. fixed CH_55/59/60/61/62/63/67/70/75/76 main shapes; main-row character node regex; composure presence; sub-ladder >=3 mode span; ladder character beat) with shrink-only, adjudicated waivers in docs/boss_axes_baseline.json. Enrolled as gate boss_axes in harness/gates_config.json (20-gate roster). Non-vacuous by construction.

H4 CANON ROW → UE TYPE — EXISTS. C:/dev/Humanity/Humanity/Source/Humanity/Public/Data/BossEncounterRow.h — FBossEncounterRow : FTableRowBase mirrors all 26 columns 1:1 including the five new ones.

H5 CSV → DATATABLE ASSET — PARTIAL. C:/dev/Humanity/Humanity/Tools/import_registry_datatable.py is a verified bulk seam over NeoStack MCP (create_asset 'datatable' with native /Script/... Struct → FillDataTableFromCSVString → read-back → save). It has only ever been run on the 3-row Chapter smoke: Content/Data/Smoke/DT_ImportSmoke.uasset. No DT_Boss_Encounter exists anywhere under Content/. The import has never been run for this lane.

H6 DATATABLE → LIVE ATTRIBUTE GRAPH — PARTIAL. Source/Humanity/Public/Combat/HumanityAttributeSet.h compiles and declares the J7 bars (Health/Vril/Stamina/Rage) + Composure + all EIGHT mode sub-node attributes incl. the standalone Composure_Character (R4 correct). But NOTHING owns it: there is no boss actor/pawn, no AbilitySystemComponent owner, no IAbilitySystemInterface, and no code that reads a FBossEncounterRow and initializes anything. Source/ contains exactly 4 .cpp files (Humanity.cpp + the three Combat ones).

H7 VERBS → GAMEPLAYABILITIES / PHASES → GAMEPLAYTAGS / VFX → CUES — MISSING. Zero UGameplayAbility subclasses, zero UGameplayEffect, zero GameplayCue, zero GA_/GE_/GC_ Content assets. No GameplayTag source declares Boss.Phase.* or Boss.Composure.Node.* — yet UCombatTelemetrySubsystem::RecordNodeBreak(FGameplayTag) already takes a mode tag with no tag table behind it.

H8 PHASE/CLOCK AI → STATETREE — MISSING. GameplayAbilities, StateTree, GameplayStateTree, PCG, PCGToolset are all enabled in Humanity.uproject, and StateTreeModule is in Source/Humanity/Humanity.Build.cs. Zero StateTree assets, zero C++ StateTree Tasks/Conditions/schema. Nothing carries the ~30 clocks, phase transitions, or evolve-not-swap.

H9 THE DIAL — PARTIAL. Source/Humanity/Public/Combat/HumanityDensitySubsystem.h holds WS_024 clamped [0,2] with the C1 realm+site law and the d_local note in the class comment. But tier_baseline has no home, d_local = clamp(tier_baseline * WS_024/2, 0, 1) is computed nowhere, and nothing feeds a GameplayEffect SetByCaller or a MetaSound Builder Input. The headline thesis (one authored boss at two world-tensions, zero enemy-stat delta) has no executable path today.

H10 DIAL SOURCE OF TRUTH — PARTIAL. The C1-authoritative pair T0_Region_Index.env_density_band_default + env_emitter_site_ids/env_drain_site_ids are declared as environment-grammar extension columns in docs/registry_extensions.json; nothing in-engine reads them.

H11 ENVIRONMENT AS COMBAT SURFACE (Chaos + D-verbs) — MISSING/PARTIAL. registries/T0_Environment_Grammar_Registry [DRAFT v0.1]/Sheet1.csv has exactly TWO rows (EG_0001 Lava Vent, EG_0002 Sieidi Stone) against an 11-verb D-verb vocabulary. NO region page cites a single EG_ id — harness/build_readiness_scorecard.md reports the Combat lane BLOCKED on all 4 built pages (flores_island, bali, sumatra_java, angkor_khmer) on exactly two inputs: a machine care_tier field and EG_ ids. Verified: flores_island.md contains neither. No Chaos destruction assets exist.

H12 WORLDSTATE / SAVE — PARTIAL. WS_041 composure_node_mastery and WS_042 banked_tell_reads ARE minted in registries/T0_Worldstate_Variables [ACTIVE v0.1]/Sheet1.csv (R8 landed), and harness/check_ws_value_form.py gates the form. The UWorldStateSubsystem / UWorldStateSaveGame C++ does NOT exist — so the ws_writes column on all 281 rows has no consumer. This is the shared trunk the cinematic lane is also blocked on.

H13 BOSS COMBAT-STATE EVENT → CINEMATIC TRIGGER — MISSING (C-14). Depends entirely on H8.

H14 TELEMETRY → SCORER — PARTIAL. UCombatTelemetrySubsystem (producer) EXISTS and compiles, writing Saved/Telemetry/<session>.json with node-breaks/tell-reads/dial-samples. Its named consumer harness/score_greybox.py (spec'd at docs/proposals/SELF_IMPROVING_QUALITY_LOOPS.md §2.2 L153-155, emitting harness/combat_greybox_scorecard.{md,json}) DOES NOT EXIST — a live orphan: a producer with no consumer.

H15 RUNTIME GENERATIVE BARKS — MISSING. harness/recall.py EXISTS and works (node/aliases/hardlines/counts/open/types, --json). The recall packs exporter, the V1-V5 validator, the authored-fallback bank, and the runtime_generation_log + pass-rate scorer do not exist in harness/. No local generative model on the machine (fastembed is embeddings-only). T0_Hard_Lines.applies_to_pipeline has no Runtime enum value, so the pack's hardline_rule_vector would be vacuous today.

H16 CONTRACT PARENT — MISSING (C-1). _source/01_Tier_1_Foundation/T1_Build_Pipeline_Contracts [ACTIVE v1.0].md has §0-§10 (UE5, Meshy, AIVA, ElevenLabs, Cinematic, Quest, Region Page, Book, Story Spine, SFX). There is NO combat/runtime section. Combat is the only lane with a Translation Doc and no contract parent.

H17 DOC STATUS — PARTIAL. docs/translation/T99_Translation_Combat.md is still labelled DRAFT v0.1. Both declared ACTIVE-flip gates have now landed (the §5 D-COMBAT-TD rulings; the §4 registry extension declared + back-filled + gate-enforcing). Only the fresh-context normalize-doc critic pass remains.

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• THE FORMER TOP WALL IS CLOSED: docs/translation/T99_Translation_Combat.md LANDED 2026-07-19 — 810 lines, five-doc bar, 3-critic adversarially gated (14 fixes incl. the BYPASS restoration, the boss_kind-not-boss_scale reconcile, the WS_024 [0,2]->d_local [0,1] normalization, the seam tags, the §8.1 PARAMETERS BLOCK). The GAS/StateTree/Chaos forks are RESOLVED in-doc.
• D-COMBAT-TD FULLY RULED (Josh, 2026-07-19, wf_89c44de5-e16, 9 units R1-R9) + D-EVADE-TOKEN (2026-07-20, the 10th verb) + D-COMBAT-MODE4. This closes THREE named walls at once: the win-condition taxonomy (10-verb enum + a REQUIRED 9-value win_shape axis), the three-axis source authority (Patterns/Puzzles/Preparation in order + the decode-vs-investment boundary + the R2 free-knowledge-route canon rule), and the mechanical definition of the mandatory character-engagement field (a STANDALONE 8th Composure node, decoupled from astral).
• THE BOSS SCHEMA EXTENSION IS APPLIED, NOT MERELY PROPOSED: win_condition, win_shape, composure_nodes, character_engagement_node, ws_writes are LIVE on the T0_Boss_Encounter_Registry header (26 columns) and BACK-FILLED across all 281 rows. Declared in docs/registry_extensions.json under system combat-encounter; docs/fidelity_baseline.json re-baselined. The 'lacks machine combat-spec columns' wall is now only PARTIALLY open (3 of 8 proposed columns remain).
• harness/check_boss_axes.py v2 BUILT and ENROLLED as gate boss_axes in harness/gates_config.json — enforcing five invariants over all 281 rows, non-vacuous by construction (missing registry/column/malformed cell = hard FAIL), with shrink-only adjudicated waivers in docs/boss_axes_baseline.json (4 mode-span, 18 ladder-beat, each carrying its author+critic+director evidence).
• WS_041 composure_node_mastery and WS_042 banked_tell_reads MINTED as canonical rows in T0_Worldstate_Variables (R8); harness/check_ws_value_form.py exists and is gate-enrolled. The C-6 canon half is closed; only the FWorldStateValue typing remains engineering.
• THE C++ GREYBOX FOUNDATION COMPILES CLEAN on UE 5.8.0: UHumanityAttributeSet (J7 Health/Vril/Stamina/Rage + Composure + all EIGHT mode sub-nodes incl. the standalone Composure_Character, and deliberately avoiding the 5.8-deprecated AttributeSet init path per spike C-7), UHumanityDensitySubsystem (WS_024 clamped [0,2] with the C1 realm+site law), UCombatTelemetrySubsystem (node-breaks / tell-reads / dial-samples -> Saved/Telemetry/<session>.json), FBossEncounterRow (all 26 columns), FChapterIndexRow. GameplayAbilities + StateTree + GameplayStateTree plugins enabled in Humanity.uproject; GameplayAbilities/GameplayTags/GameplayTasks/StateTreeModule wired in Humanity.Build.cs.
• THE DATATABLE BULK SEAM IS VERIFIED END-TO-END (2026-07-20): Tools/import_registry_datatable.py over the NeoStack MCP channel, with the hard-won facts recorded (option key is Struct not RowStruct; must be a NATIVE /Script/ UScriptStruct; UserDefinedStructs are a dead end; first CSV column is the row name; every post-init request must echo MCP-Session-Id). Evidence: /Game/Data/Smoke/DT_ImportSmoke.
• harness/check_build_readiness.py EXISTS with a Combat lane predicate — the lane's per-region-page readiness is now machine-queryable rather than prose, with a both-directions self-test that runs on every real invocation.
• docs/spine/DECISIONS_PENDING_JOSH.md now reports ZERO open decision items queue-wide, and the ratified standing order is RR-62 -> §6.5 completion -> angkor_khmer -> D-1 audit -> GREYBOX. There is no combat item waiting on Josh.

Genuinely external (not ours to build):

• 5090 workstation delivery (hardware, inbound) — genuinely gates ONLY four things in this lane: the 14B on-device reference model for dev-side quality prototyping, the runtime-inference perf budget (latency P99 / VRAM / quant / gen-s / speculative decode), Chaos destruction perf at scale, and the nightly first-try-pass-rate eval at corpus scale. It gates NOTHING in the deterministic spine, the boss data path, GAS/StateTree, the dial, the worldstate subsystem, the scorer, the packs exporter, the validator, or the 3-4B ship-target bark smoke.
• Console packaging (Xbox int4/DirectML, PS5 compute-shader paths) is DEVKIT-gated — requires platform devkits and NDA'd SDKs. Neither the current machine nor the 5090 unblocks it. This is the one genuinely external, cannot-build-our-way-past item in the lane.
• No local generative model on this machine today — no ollama, no llama.cpp, no GGUF; fastembed is embeddings-only. This is a download + build step, not a purchase or a service, and the roadmap explicitly places the 3-4B ship-target smoke on the CURRENT GPU. Treat as a setup task, not an external constraint.
• The UE 5.8.0 BuildId 55116800 engine pin plus the NeoStack-as-source rule: NeoStackAI must be rebuilt from source against that exact BuildId on any engine or plugin update; a prebuilt/marketplace binary drop-in re-breaks. This couples the lane to an upstream vendor's release cadence.
• The NeoStack Agent Chat sign-in stall is an upstream plugin defect (their ACPClient.cpp auth-method parser never populates the terminal-auth command, then spawns the bridge in JSON-RPC server mode waiting on stdin). Worked around, not fixed by us; a durable fix means patching a third-party plugin we happen to build from source.
• Every editor seam in this lane (NeoStack MCP :9315, Epic ModelContextProtocol :8000, the UE-Python bridge, the DataTable import, the Landscape import) requires the UE EDITOR to be RUNNING. No headless path is verified, so every bulk import is an attended operation until a commandlet path is built.

ue5

Critical path: docs/REGISTRY_ROW_STRUCT_SPEC.md plus Tools/gen_row_struct.py — the column-to-UE-type contract and the codegen that consumes it. Every other hop in this lane is either already proven or waiting behind a row type. The DataTable seam is verified production-grade and has already carried 360 real rows into the engine, so the ONLY thing standing between canon and the engine for the remaining ~34 registries is 'a native USTRUCT exists for this table' — a step START_HERE has named as the standing build-lane next item on three separate days and which is still being done by hand, one struct at a time. It is also upstream of the second-most-critical item: the spine-row extractor's output (sites, beats, forks, scenes, SQ) cannot enter the engine without row structs either, so codegen serves both branches. It costs nothing external, is not 5090-gated, needs no Josh ruling (type mapping is engineering, and the one canon-adjacent choice — FText for player-facing columns — is already a binding ruled law that the current hand-authored structs violate), and it converts an O(34 sessions) hand task into one script run plus one compile. Second on the path, and buildable in parallel by a different worker: harness/extract_spine_rows.py, whose effort just dropped materially because harness/check_spine_graph.py already contains the corpus-hardened section router and beat/fork parsers it needs.

CHAIN: canon row -> USTRUCT -> DataTable -> PCG -> World Partition level. Verified against the live tree 2026-07-22 (canon repo C:/dev/humanity-forgotten @ master 6f98b70; game repo C:/dev/Humanity/Humanity @ master 76691a2).

HOP 1 — Canon row at rest. EXISTS. 36 registries as CSV under registries/<name>/<tab>.csv (T0_Chapter_Index 79 rows, T0_Boss_Encounter_Registry 281, T0_Creature_Roster 132, T0_Region_Index 76, T0_Vril_Site_Registry 42, T0_Environment_Grammar_Registry 2). Live-canon layer; divergence declared in docs/fidelity_baseline.json; open columns declared in docs/registry_extensions.json and enforced by harness/check_registry_extensions.py.

HOP 2 — Spine typed rows (site/beat/fork/scene/SQ/boss-thin-index) -> extractable table. PARTIAL/MISSING. The rows are real and machine-shaped inside docs/spine/CH_NN.md (e.g. CH_02 - liang_bua_cave: terrain cave_system · functions [...] · ambient_threat moderate · vril_density low · climactic_affordance none · protected true; the §13 scene table is a 7-column markdown table). The PARSERS already exist inside harness/check_spine_graph.py (_sections() header router, parse_beats(), parse_forks(), parse_file() which already buckets sites/scene/sq/boss/seam bodies). What is MISSING is the emitter: no harness/extract_spine_rows.py, no CSV/JSON output anywhere. extract_claims.py and enrich.py do not produce it. This is the §3 pre-step the Translation Doc says every UE step depends on.

HOP 3 — Region page Zone Catalog -> extractable table. PARTIAL. _source/02_Tier_2_Region_Pages/flores_island.md ## Zone Catalog carries 10+ real zone rows (zone_id | source site_id | terrain | gameplay functions | ambient_threat | vril_density | climactic_affordances | protected | area_bounds | build_priority). MISSING: (a) worldcover_biome (the PCG Biome Core / auto-material vegetation key) — absent on all 4 live pages; (b) georeferenced bounds — area_bounds is size-only prose ("220×180×60 karst interior", "300×300"), no world anchor; (c) any extractor. harness/check_build_readiness.py run TODAY reports UE5 = BLOCKED on exactly those two inputs for all four pages (angkor_khmer, bali, flores_island, sumatra_java). Note the georeference IS partly recoverable: T0_Region_Index.coordinates already carries WGS84 point anchors (flores_island = 8.5333°S 120.4400°E Liang Bua; 8.6110°S 120.4689°E Ruteng) and terrain_feature_class_ids already carries EG_ ids. Also note harness/apply_region_page_sections.py (the only deterministic page writer) replaces ### Section N spans ONLY — ## Zone Catalog is a top-level block outside its span logic, so there is no writer for these columns.

HOP 4 — CSV column -> C++ USTRUCT : FTableRowBase. PARTIAL, 2 of ~36. Source/Humanity/Public/Data/ChapterIndexRow.h (FChapterIndexRow, 51 cols) and BossEncounterRow.h (FBossEncounterRow, 26 cols incl. the five ruled combat columns) exist and compile (UE 5.8.0). Both hand-authored, all-FString for player-facing text — which VIOLATES the binding localization law (game CLAUDE.md "localization from the first string"; Translation Doc §2.4 requires FText for title, boss_name, any player-facing column). MISSING: the column-to-UE-type spec doc (no such file in docs/), any codegen tool, and the other ~34 row types (FCreatureRow, FRegionIndexRow, FVrilSiteRow, FCharacterRow, FWorldstateVariableRow, ...). Hard-won constraint recorded: UserDefinedStructs are a DEAD END on this seam (NeoStack add_variable is Blueprint-only; Epic bug UE-152346).

HOP 5 — CSV -> DataTable asset. EXISTS, VERIFIED, PRODUCTION-GRADE. Tools/import_registry_datatable.py runs the whole import through the UE-PYTHON BRIDGE (invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand') over the NeoStack MCP channel :9315) -> unreal.DataTableFactory create-or-load -> fill_data_table_from_csv_string -> row-name read-back -> save. REAL imports landed: /Game/Data/Registries/DT_ChapterIndex (79 rows) and DT_BossEncounter (281 rows), all columns field-verified, Unicode preserved. Two real transport bugs already fixed (Lua 5.3 rejects JSON \uXXXX escapes; NeoStack Lua create_asset trips on a stale in-memory empty package). Quirk recorded: UE strips the F prefix — /Script/Humanity.ChapterIndexRow resolves, the F-prefixed path returns None.

HOP 6 — GameplayTag taxonomy from registry ids. MISSING. No Config/Tags/*.ini and no generator. Tags load at engine init, so this must precede any Blueprint/StateTree that keys on ws.* or THREAD_01..22.

HOP 7 — DEM -> heightmap -> Landscape actor. EXISTS. Tools/terrain_fetch_preprocess.py (OpenTopography COP30 fetch -> UTM reproject at chosen m/vertex -> 16-bit PNG + machine meta JSON: Liang Bua bbox -8.58/-8.48/120.39/120.49, EPSG:32751, 30 m/vertex, 371x372 px, elev 141.75-1187.07 m, ue_landscape_z_scale 204.164). The LANDSCAPE SEAM is verified: open_level() handle method lvl:import_heightmap({file, scale}) produced a REAL Landscape at Content/Maps/LiangBua_TerrainSmoke.umap (379x379, 36 components) with World Partition external actors committed. This obsoletes the Translation Doc's Step-4 C++ ALandscape::Import() shim, which §4 spike 2 calls "the single highest-priority engineering dependency in the whole chain." No shim is needed.

HOP 8 — World Partition level per region + Data Layers. PARTIAL. One WP level exists (the smoke map). MISSING: a per-region scaffolder script, CellSize setting, and the protected-zone -> SafeZone Data Layer tagging pass (unreal.DataLayerEditorSubsystem is scriptable; nothing has run it).

HOP 9 — Landscape auto-material from ESA WorldCover. MISSING. No master material, no layer-blend graph, and terrain_fetch_preprocess.py fetches DEM only — there is no WorldCover fetch/sample leg at all.

HOP 10 — Zone row -> parameterized PCG graph. PARTIAL (seam proven, content absent). The Epic MCP PCG seam is VERIFIED LIVE (http://127.0.0.1:8000/mcp, PCG+PCGToolset+EditorToolset enabled, auto-start seeded via repo-tracked Config/DefaultEditorPerProjectUserSettings.ini; smoke: CreateGraph -> AddNode "Surface Sampler" -> ConnectNodePins -> GetGraphStructure, saved at Content/Data/Smoke/PCG_HelloGraph). MISSING: any biome/terrain_type template graph, any Load Data Table / Data Table Row to Attribute Set wiring, the terrain_type->template binding table (grep-confirmed absent across docs/ and _source/), and the population numbers (ambient_threat->density, vril_density->creature-tier filter, climactic_affordances->marker class) — the Translation Doc assigns these to its own inference layer and the layer is empty.

HOP 11 — Headless whole-region bake. MISSING. PCGWorldPartitionBuilder never invoked; the community cell-loading/Grid-Size edge case is untested against our graphs.

HOP 12 — Boss marker -> playable fight. PARTIAL. GAS foundation compiles (UHumanityAttributeSet with the eight ruled Composure sub-nodes, UHumanityDensitySubsystem = the vril-density dial, UCombatTelemetrySubsystem). Content/Combat/ST_BossPhases_Greybox.uasset exists with a valid StateTreeComponentSchema and the three phases recorded as asset metadata — but the internal state graph is EMPTY: UStateTree.EditorData is a protected UPROPERTY, unreachable via py-bridge/find_object, and NeoStack exposes no StateTree authoring domain. No PCG-spawned marker actor class exists yet.

HOP 13 — ws.* worldstate + save. MISSING ENTIRELY. Source/Humanity/ contains only Humanity.Build.cs/cpp/h, three Combat classes, and two Data row headers. No UWorldStateSubsystem, no FWorldStateValue, no UWorldStateSaveGame. This is the shared blocker the cinematic lane also names.

HOP 14 — DataValidation + cook/package. MISSING. No UEditorValidatorBase subclass, no RunUAT invocation.

NET: hops 1, 5, 7 and the three automation channels are solid and proven with real data. The chain breaks in three places at once — nothing extracts the spine/zone rows into tables (hop 2/3), nothing types a registry column into C++ at scale (hop 4), and nothing binds a zone row to a PCG graph (hop 10). Everything downstream of hop 10 (bake, fight, worldstate, cook) is unstarted but unblocked-by-construction once those three close.

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• THE LANDSCAPE C++ SHIM IS OBSOLETE, NOT PENDING. T99_Translation_UE5_Build §4 spike 2 calls the ALandscape::Import() shim 'the single highest-priority engineering dependency in the whole chain' and says no region's Step 4 runs before it exists. It was bypassed on 2026-07-20: the NeoStack open_level() handle method lvl:import_heightmap({file, scale}) builds a real Landscape directly from a 16-bit PNG. Evidence: Content/Maps/LiangBua_TerrainSmoke.umap (371x372 png -> 379x379, 36 components, X/Y 3000, Z 204.164) with World Partition external actors committed at game commit d780968. No shim needs writing.
• EPIC MCP PCG TOOLSET VERIFY (spike 5) IS RESOLVED. The roadmap and Translation Doc both say 'STILL PENDING (2026-07-19): enabled but NOT auto-started and no toolset enabled yet.' As of 2026-07-20 the ModelContextProtocol server is auto-started via the repo-tracked Config/DefaultEditorPerProjectUserSettings.ini seed, PCG + PCGToolset + EditorToolset are enabled in the uproject, and the PCG authoring path is smoke-tested end to end (CreateGraph -> AddNode 'Surface Sampler' -> ConnectNodePins with auto type-filter insertion -> GetGraphStructure), saved at Content/Data/Smoke/PCG_HelloGraph. The dispatch quirks are recorded (call_tool with unprefixed tool_name, every inputSchema param required, display-name node types, fromPinLabel/toPinLabel).
• THE DATATABLE SEAM MOVED FROM SMOKE TO REAL PRODUCTION DATA. Not 3 smoke rows — /Game/Data/Registries/DT_ChapterIndex (79 rows, all 51 columns) and DT_BossEncounter (281 rows, all 26 columns incl. the five new combat-spec columns), field-verified by read-back with Unicode em-dashes preserved (game commit 76691a2). Tools/import_registry_datatable.py was hardened against two real transport bugs the ASCII smoke never hit (Lua 5.3 rejects json.dumps's \uXXXX escapes; NeoStack Lua create_asset trips on a stale in-memory empty package) by routing the entire import through the UE-Python bridge over a UTF-8 temp file.
• TWO NATIVE ROW STRUCTS ARE AUTHORED AND COMPILING. Source/Humanity/Public/Data/ChapterIndexRow.h and BossEncounterRow.h, snake_case members matching CSV headers 1:1 with zero renames needed. Compile verified on UE 5.8.0. The struct-path quirk is recorded: UE strips the F prefix, so /Script/Humanity.ChapterIndexRow resolves and the F-prefixed path returns None (the tool docstring example was wrong).
• THE UE-PYTHON BRIDGE IS A VERIFIED UNIVERSAL VECTOR. invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand') over the NeoStack channel reaches the full unreal Python API — anything the MCP toolsets lack (file imports, AssetTools tasks, batch ops) routes through it. Proven on both an AssetImportTask mp3->SoundWave import and the whole DataTable create+fill+save+readback path.
• THE BOSS_ENCOUNTER COMBAT-COLUMN EXTENSION IS APPLIED AND MIRRORED IN C++. All 281 rows carry win_condition / win_shape / composure_nodes / character_engagement_node / ws_writes, declared under 'combat-encounter' in docs/registry_extensions.json with the fidelity baseline re-emitted; FBossEncounterRow already carries all five. The roadmap wall 'Boss_Encounter lacks the machine combat-spec columns' is closed.
• THE COMBAT GREYBOX C++ FOUNDATION COMPILES. UHumanityAttributeSet (GAS, eight ruled Composure sub-nodes incl. the standalone character-engagement node), UHumanityDensitySubsystem (the vril-density dial, WS_024 [0..2]), UCombatTelemetrySubsystem. GameplayAbilities + StateTree + GameplayStateTree plugins enabled. Content/Combat/ST_BossPhases_Greybox.uasset created with a valid StateTreeComponentSchema.
• TERRAIN MACHINE PARAMS EXIST FOR THE FIRST REGION AND THE KEYS ARE IN. Tools/terrain_fetch_preprocess.py emits Saved/Terrain/liang_bua_terrain_meta.json with region_bbox_wgs84, EPSG:32751, meters_per_vertex, elevation range, ue_landscape_z_scale, and the Copernicus attribution. OpenTopography and ElevenLabs keys are in and probe-verified.
• D-MPV IS RULED. The tiered meters_per_vertex ladder was ruled by Josh 2026-07-21 and applied at e7bd120 — the roadmap wall 'No single resolved meters_per_vertex value ... Josh ruling' no longer needs a ruling, only a writeback of the ruled value onto each page's Section 1.
• THE READINESS GATE ITSELF EXISTS AND ENFORCES. harness/check_build_readiness.py (review row BJ) runs today, self-tests both directions on every real run, and reports the UE5 lane's BLOCKED-ON inputs by name per page — so the lane's gap list is machine-derived, not hand-maintained.

Genuinely external (not ours to build):

• MetaHuman cloud round-trip (Step 7). request_auto_rigging and request_texture_sources go to Epic's cloud per character; it is not scriptable away and there is no local path. Throughput, latency, and rate limits at 'hundreds of NPCs' scale are undocumented by Epic. Genuinely external — the only response we own is an empirical throughput test plus keeping the classic modular-NPC fallback ready (the MetaHuman Crowd plugin is Experimental, 'use caution when shipping').
• Epic EULA generative-AI clause. The 'prompt-based input' scope is ambiguous per Epic's own community and the EULA pages return 403 to automated fetch. Legal read only, explicitly not resolvable by research or engineering. Safe working design meanwhile: AI authors and drives, Epic content never becomes training data.
• Gaea licensing tier for headless CLI. Indie ($99) may not include CLI automation; Pro ($199) may be required; Gaea 3.0 shipped-status unconfirmed. IMPORTANT SCOPE CORRECTION: the chain does NOT depend on this — Liang Bua landed as a real Landscape straight from raw COP30 with no Gaea pass. Gaea is an optional erosion-detail quality step, so this is a purchase decision on a nice-to-have, not a lane blocker.
• OpenTopography terms. 50 calls per 24h on the non-academic key, and an Enterprise key is required for commercial software integration. The keyless Copernicus AWS mirror is the bulk fallback, so this constrains convenience, not capability.
• Epic component maturity we do not control: PCG Biome Core is Experimental v0.2 (verify runtime perf before it is load-bearing); PCGWorldPartitionBuilder has a community-reported iterative-cell-loading + Grid Size node executor error; the Remote Control /remote/batch crash bug is forum-reported and untested against our usage; UserDefinedStructs are rejected by the DataTable importer (Epic bug UE-152346) which is why native C++ row structs are mandatory.
• UStateTree.EditorData is a protected UPROPERTY. No MCP channel, no Python bridge, and no NeoStack domain can reach it, so boss phase graphs cannot be authored over any existing seam. This is a hard engine-API boundary for the CHANNELS — but not for us, because we compile our own editor module; the escape hatch is listed as a build item rather than accepted as external.
• Console packaging (Xbox int4/DirectML, PS5 compute-shader) is devkit-gated — neither the current machine nor the 5090 changes it.
• Genuinely 5090-gated in this lane, and only these: the 69-region headless PCG/HLOD/Nanite batch bake at 8129-vertex landscapes; bulk terrain preprocess and kilometre-scale erosion sims; MetaHuman generation at roster scale; the render/streaming perf-budget validation across the four spec classes; and the 14B on-device reference model for the NeoStack interpretive seam. Everything else in this lane — every spec, every tool, every row struct, every template graph, the first region end to end — runs on the current machine today. No build item above is 5090-gated.

cinematic

Critical path: harness/extract_spine_scene_rows.py + the Scene_Spec population it feeds. The lane's canon input is COMPLETE and gate-validated — 439 typed scene rows across all 79 spine nodes (| scene_anchor_id | beat_ref | scene_type | path_bucket | anchor_type | participant_refs | hard_line_relevance |), already checked by harness/check_spine_graph.py (scene_type against the §5.5 eleven, beat_ref resolving to a real beat). But only 16 of those 439 exist as machine rows anywhere: T0_Scene_Spec_Registry covers Ch 55/58/76/77/Prologue/Epilogue and nothing else. Every downstream hop — the FSceneSpecRow struct, the DataTable import (seam PROVEN at 79 and 281 rows), template selection, participant resolution, dispatch, the cinematic gate — operates on rows that today live only as markdown in 79 files. The extractor is small, depends on nothing, is gated by nothing, and is the single item that moves the lane from 3.6% row coverage to 100%. Runner-up: UWorldStateSubsystem (item 8) — but that only unblocks the LOCKED/path-conditional minority of rows, whereas the extractor unblocks all of them.

CANON ROW -> THING IN THE RUNNING GAME. Eleven hops. Verified against the live tree 2026-07-22, not against the 2026-07-19 wall list.

HOP 1 — Spine §13 scene row. EXISTS (and is far stronger than the wall list implies). 439 typed scene rows across all 79 nodes, shape | scene_anchor_id | beat_ref | scene_type | path_bucket | anchor_type | participant_refs | hard_line_relevance | (e.g. docs/spine/CH_02.md:193-199, CH_76.md:183, CH_PROLOGUE.md:162). Already gate-validated: harness/check_spine_graph.py:645-680 checks scene_type against the §5.5 eleven-value set, resolves every beat_ref to a real beat, and validates path_bucket. DOC-CURRENCY DEFECT FOUND: T99_Translation_Cinematic §3 Step 1 states the 7th spine column is thematic_anchor and that hard_line_relevance has "no spine column at all" — the executed spine is the exact reverse on all 79 nodes. Step 1's inference instruction is inverted.

HOP 2 — extract markdown table -> CSV. MISSING. No extractor in harness/ (28 scripts; enrich.py and extract_claims.py do not produce it). This is the roadmap's named "spine-row extractor" wall, still true, and it is the lane's bottleneck.

HOP 3 — T0_Scene_Spec_Registry (31 columns, ACTIVE v0.1). PARTIAL. registries/T0_Scene_Spec_Registry [ACTIVE v0.1]/T0_Scene_Spec_Registry.csv holds 16 rows for 6 nodes only (Ch 55, 58, 76, 77, Prologue, Epilogue) — a 2026-07-21 director pass re-keyed them to the executed v3.1 spine. ~423 spine scene rows have no registry row. The Contract §5.5 audio-trio (audio_priority_layer / scene_audio_intent / hard_line_relevance) is populated only on those 16.

HOP 4 — registry CSV -> UE DataTable. PARTIAL — mechanism PROVEN, struct MISSING. C:/dev/Humanity/Humanity/Tools/import_registry_datatable.py landed real imports at scale (commit 76691a2: DT_ChapterIndex 79 rows / 51 cols, DT_BossEncounter 281 rows / 26 cols), with the transport bugs already fixed (CSV rides a UTF-8 temp file through the UE-Python bridge, not a Lua string literal; create-or-load via unreal.DataTableFactory). Missing: Source/Humanity/Public/Data/SceneSpecRow.h — only ChapterIndexRow.h and BossEncounterRow.h exist. UserDefinedStructs are a RULED dead end on this seam (NeoStack add_variable is Blueprint-only), so the native USTRUCT is mandatory. Gotcha already learned: UE strips the F prefix — /Script/Humanity.SceneSpecRow resolves, the F-prefixed path is None.

HOP 5 — scene_type -> shot-template Level Sequence. MISSING (spec AND asset) — but the SEAM IS MUCH BETTER THAN THE WALL LIST SAYS. No shot-grammar doc exists anywhere in docs/ or _source/ (only the roadmap's own mention of the gap). Content/Cinematics/ does not exist; zero Level Sequences in the project. HOWEVER: NeoStack's Sequencer Lua domain IS installed and rich — Plugins/NeoStackAI/Source/NeoStackAI/Private/Lua/Bindings/LuaBinding_Sequencer.cpp is 6,603 lines exposing add("binding",{actor_name,spawnable,spawn_ownership,component_name}), add("track",{track_type,binding,start_time,end_time,camera_binding,sequence,sound_asset,animation_asset,property_name,shot_display_name,row_index}), add("keyframe",{binding,track_type,channel_index,time,value,string_value,object_path,interp}), add("section"), add("marked_frame"), add("folder"), add("binding_tag"), plus list("channels"/"keyframes"/"properties") read-back and _enrich_sequencer handles. Camera blocking, cut timing and shot rhythm ARE fully scriptable. The 11 templates are an authoring task with a proven automation vector, not a hand-only wall.

HOP 6 — beat_ref -> site -> region -> .umap. PARTIAL. The join is specified (TD Step 3, corpus-corrected: anchor_type is a TRIGGER class, not a map anchor) and all inputs exist (spine beats carry site; region pages carry Zone Catalogs). Missing: any joiner tool, and any region .umap — Content/Maps holds only LiangBua_TerrainSmoke (the terrain-lane smoke), no region base map for any of the 69 regions.

HOP 7 — participant_refs (CHAR_id) -> MetaHuman asset path. MISSING — wall CONFIRMED, and the roadmap's fix-route is mis-ordered. Byte-verified: registries/T0_Character_Index [ACTIVE v1.1]/T0_Character_Index DRAFT v1.1.csv is 163 rows / 20 columns with NO mesh_pipeline_type and NO asset-path column; T0_Antagonist_Network_Registry/Sheet1.csv is 8 columns, likewise none. Contract §1.5.1's claim that both registries "default mesh_pipeline_type to metahuman" is not true of the live CSVs. The roadmap calls this "cross-lane — the UE build must generate MetaHumans and emit stable asset IDs first"; that ordering is wrong — the COLUMN can be declared and left empty now, which unblocks the extractor, the row struct and the gate immediately, and is populated as MetaHumans land. Second constraint found: NeoStack's core LuaBinding_MetaHuman.cpp is a 2-line stub reading "moved to the NSAI_MetaHuman extension module". CORRECTED 2026-08-13 — that sentence names where the code WENT, and this line read it as absence. The extension module is present, compiled and fully implemented: Plugins/NeoStackAI/Binaries/Win64/UnrealEditor-NSAI_MetaHuman_Integration.dll at 938,496 bytes (ControlRig 1,278,464 / IKRig 927,232 for scale; a WITH_NSAI_METAHUMAN_INTEGRATION=0 stub build would be a few KB), linking MetaHumanCharacter.dll + MetaHumanCharacterEditor.dll + MetaHumanCharacterPalette.dll + MetaHumanIdentity.dll — imports that appear ONLY in the Build.cs bHasMetaHumanCharacter branch, so it compiled with the integration ON. It exposes 66 Lua functions including metahuman_fit_face_to_vertices (Mesh-to-MetaHuman), metahuman_conform_body, metahuman_request_textures, metahuman_is_auto_rigging, metahuman_build, metahuman_spawn_actor and metahuman_compare_face. A Build.cs-only Source dir is the shipping format for all 64 NSAI integrations (bUsePrecompiled = true), and LoadingPhase: None is load-on-demand used by 62 of them including working modules — neither is disablement. All nine engine MetaHuman plugins are installed and MetaHumanCharacter is enabled at Humanity.uproject:105. So MetaHuman work does NOT have to route through the UE-Python bridge; the Lua domain is available and the roster-scale auto-rig path is scriptable. Evidence, with the DLL sha256 and the full function list: build/ops/NEOSTACK_METAHUMAN_BINDING_2026-08-13.json. Not yet verified: no call has been executed live — that is one character end to end, and it is the next step, not a claim.

HOP 8 — audio FKs -> SoundWave. PARTIAL — the wall is stated imprecisely. The scene ROW does carry audio FKs: T0_Scene_Spec_Registry already has music_cue_id_ref, voice_refs, sfx_id_ref_array, sfx_category_array, dialogue_dataset_ref. Three real gaps: (a) those cells are empty on nearly every row; (b) T0_Theme_Registry [DRAFT v0.1] (12 rows), T0_Voice_Registry [DRAFT v0.1] (10 rows) and T0_SFX_Registry [ACTIVE v1.0] (12 rows) carry NO UE asset-path column, so an id cannot resolve to /Game/Audio/...; (c) the SPINE seven-column row carries no audio column at all — that is the true form of "no SoundWave FK on the scene row". Import mechanism is PROVEN: Content/Audio/SFX/smoke_stone_door landed via AssetImportTask over the bridge, and Tools/generate_sfx.py + a live ElevenLabs key produce the source WAV/MP3.

HOP 9 — path_bucket dispatch -> DT_SceneDispatch + ws.* WorldStateSubsystem. MISSING in code; MUCH better specified than the wall says. registries/T0_Worldstate_Variables [ACTIVE v0.1]/Sheet1.csv is LIVE and POPULATED (42 rows) with exactly the dispatch keys: WS_004 path_bucket (enum TRULY_GOOD/GOOD_ENOUGH/EVIL/UNLOCKED, default UNLOCKED), WS_005 path_lock_in_state, WS_013 cassius_velheim_state (RESOLVED_TGP_PURGE/RETREATED_GE/VICTORY_EVIL), WS_017 father_encounter_variant (REUNION_TGP/NEGOTIATION_GE/COMBAT_EVIL) — and WS_017's consumer list literally names "Ch76_77_cinematic_dispatcher". T99_Translation_Combat Step 7 now FULLY SPECS the shared subsystem: UWorldStateSubsystem : UGameInstanceSubsystem holding TMap<FGameplayTag, FWorldStateValue> (tagged union bool/int/enum), persisted via UWorldStateSaveGame : USaveGame with AsyncSaveGameToSlot, "shared verbatim with UE5_BUILD Step 10". So the ws.* design is RULED; only the C++ is absent, and it is gated by nothing. Two live defects: WS_004's enum omits ALL (which SPINE_SCHEMA_v3 §1 and every Scene_Spec row use), and WS_013/WS_017 consumer strings still name the SUPERSEDED chapter homes ("Ch74_phase_3_resolver", "Ch75_father_encounter_dispatcher") after the endgame re-cascade moved them to Ch 76.

HOP 10 — boss combat-state event. MISSING in code; the SPEC NOW EXISTS (wall is stale). T99_Translation_Combat Step 2 maps boss phase state to GameplayTags Boss.Phase.1/2/3 and Boss.Composure.Node.<mode>.Broken; Step 7 says verbatim "Boss cinematics fire off a boss combat-state event StateTree emits (the cinematic lane's spike 4 dependency resolves here — a GameplayTag/StateTree event the Sequencer trigger listens for)." A greybox asset exists at /Game/Combat/ST_BossPhases_Greybox. NEW ENGINE CONSTRAINT discovered at commit 76691a2: UStateTree.EditorData is a protected UPROPERTY unreachable via the py-bridge or find_object, and the asset exposes 0 editable properties — the state GRAPH must be authored in-editor by hand. Cinematic does NOT have to wait for that: define the tag channel + a listener component + a debug emitter in C++ and the whole cinematic trigger path is testable today.

HOP 11 — delivery: realtime LevelSequenceActor / MRQ dailies. MISSING as run; mechanism available. NeoStack's MRQ Lua domain is NOT installed (LuaBinding_MovieRenderQueue.cpp is a 2-line "moved to the NSAI_MovieRenderPipeline extension module" stub), as is IKRig/IKRetargeter. Route via the VERIFIED universal UE-Python bridge (invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand',...) -> MoviePipelineQueueEngineSubsystem / MoviePipelinePythonHostExecutor) or headless UnrealEditor-Cmd. Nothing external gates a 720p placeholder render.

BONUS FINDING — one named wall is currently VACUOUS: "ambient rows carry no beat_ref". All four live region pages (flores_island, bali, sumatra_java, angkor_khmer) state "page-authored ambient-cinematic additions: none yet". Zero ambient rows exist, so nothing is blocked by it today; fixing it now is cheap pre-emption, not unblocking.

Already done since the 2026-07-19 audit (was reported as a wall, is not one now):

• T99_Translation_Combat.md LANDED (2026-07-19) and it RESOLVES two of the cinematic lane's own spikes at the spec layer: Step 7 fully specifies the shared UWorldStateSubsystem : UGameInstanceSubsystem / TMap<FGameplayTag,FWorldStateValue> / UWorldStateSaveGame+AsyncSaveGameToSlot design (spike 3), and Step 2 + Step 7 rule the boss combat-state event as GameplayTags Boss.Phase.1/2/3 and Boss.Composure.Node.<mode>.Broken with the explicit sentence 'the cinematic lane's spike 4 dependency resolves here'. The wall list's 'the ws.* WorldStateSubsystem does not exist' and 'boss cinematics need a combat-state event no boss AI emits' are now IMPLEMENTATION gaps with ruled designs, not open design questions.
• NeoStack's Sequencer Lua domain is INSTALLED AND RICH — Plugins/NeoStackAI/Source/NeoStackAI/Private/Lua/Bindings/LuaBinding_Sequencer.cpp is 6,603 lines exposing add('binding') with spawnable/possessable and spawn_ownership, add('track') with camera_cut/subsequence/audio/animation/property and start/end times, add('keyframe') with channel_index/time/value/interp, add('section'), add('marked_frame'), add('folder'), add('binding_tag'), plus list('channels'|'keyframes'|'properties') read-back. Camera blocking, cut timing and shot rhythm are FULLY SCRIPTABLE. The 11 shot templates are an automation task, not hand labour — a materially different picture from the wall list.
• The DataTable bulk-import seam is PROVEN AT REAL SCALE, not just smoke (game commit 76691a2, 2026-07-20): DT_ChapterIndex 79 rows / 51 columns and DT_BossEncounter 281 rows / 26 columns, read-back verified, Unicode preserved. The transport bugs are already fixed in Tools/import_registry_datatable.py (CSV rides a UTF-8 temp file through the UE-Python bridge because Lua 5.3 rejects JSON \uXXXX escapes; create-or-load via unreal.DataTableFactory because NeoStack's Lua create_asset trips on a stale in-memory package). The F-prefix struct-path gotcha is documented (/Script/Humanity.SceneSpecRow, not F-prefixed).
• The UE-PYTHON BRIDGE is VERIFIED as the universal vector (invoke('/Script/PythonScriptPlugin.PythonScriptLibrary','ExecutePythonCommand',...)) — which matters more than the roadmap knew, for MovieRenderQueue, whose NSAI extension module is genuinely absent. CORRECTED 2026-08-13: the same sentence originally swept in MetaHuman and IKRig, and that was wrong — the core files are 2-line stubs pointing at extension modules, and those extension modules are PRESENT and compiled (UnrealEditor-NSAI_MetaHuman_Integration.dll 938,496 B with 66 Lua functions; UnrealEditor-NSAI_IKRig_Integration.dll 927,232 B). A stub that names its successor is a forwarding address, not an absence. MRQ routes through the bridge; MetaHuman and retargeting have native Lua domains. Evidence: build/ops/NEOSTACK_METAHUMAN_BINDING_2026-08-13.json.
• The canon input corpus is COMPLETE, not partial: 439 typed scene rows exist across ALL 79 spine nodes in the full seven-column shape, and harness/check_spine_graph.py ALREADY validates them (scene_type against the §5.5 eleven-value set at line 86-89, beat_ref resolution to a real beat at line 680, path_bucket). The lane's problem is extraction, not authorship.
• T0_Worldstate_Variables [ACTIVE v0.1] is LIVE and POPULATED (42 rows) with exactly the dispatch keys the lane needs, typed with enums, defaults and named consumers: WS_004 path_bucket, WS_005 path_lock_in_state, WS_013 cassius_velheim_state (RESOLVED_TGP_PURGE/RETREATED_GE/VICTORY_EVIL), WS_017 father_encounter_variant (REUNION_TGP/NEGOTIATION_GE/COMBAT_EVIL) — whose consumer list literally names 'Ch76_77_cinematic_dispatcher'. The dispatch keys are canon on disk.
• T0_Theme_Registry and T0_Voice_Registry EXIST with rows (12 and 10) and both carry cinematic_anchor_array; T0_SFX_Registry is ACTIVE v1.0 with 12 rows; Theme already carries the declared adaptive-audio extension columns (tempo_bpm, bar_length, per_stem_role) in docs/registry_extensions.json. T99_Translation_Cinematic §2.6's 'not yet created' is stale.
• A SoundWave import round-trip is PROVEN end to end: Tools/generate_sfx.py (live ElevenLabs key, probe-verified) -> Content/Audio/SFX/smoke_stone_door imported via AssetImportTask over the bridge. The audio seam's mechanism is no longer hypothetical.
• T0_Scene_Spec_Registry's 16 rows were RE-KEYED to the executed v3.1 spine in a director pass dated 2026-07-21 — Ch 55, Ch 58, Prologue and Epilogue rows now cite their real spine anchors (SC_CH55_the_craft_wakes, SC_CH58_the_overview, SC_CHPRO_the_sealing, SC_CHEPI_the_unseen_reader), with three Drive-era shape errors corrected in place (the Ch-58 'Vimana Activation' misnomer, the three-row Epilogue split, two CVD §17.5->§17.9/§17.2 mis-cites).
• The registry-extension discipline is a SOLVED, GATED procedure — docs/registry_extensions.json + docs/fidelity_baseline.json added_columns + harness/check_registry_extensions.py, with T0_Character_Index and T0_Theme_Registry already carrying declared extensions. Every 'add a column' item in this lane rides an existing rail rather than inventing one.
• harness/check_build_readiness.py EXISTS and emits a per-page Cinematic-lane verdict with named missing inputs (currently: flores/bali BLOCKED-ON beat_ref + scene_type + participant_refs; sumatra/angkor BLOCKED-ON scene_type + participant_refs only). The lane has a machine-readable scorecard already.
• One named wall is currently VACUOUS: 'ambient rows carry no beat_ref'. All four live region pages state 'page-authored ambient-cinematic additions: none yet' — zero ambient rows exist, so nothing is blocked by it today.
• A StateTree boss-phase greybox asset exists at /Game/Combat/ST_BossPhases_Greybox with the GameplayStateTree plugin enabled and the three phases recorded as asset metadata — the combat lane's scaffolding for the boss-cinematic trigger is partially standing.

Genuinely external (not ours to build):

• MetaHuman Creator cloud batch throughput, latency and rate limits at 'hundreds of characters' scale are UNDOCUMENTED by Epic (TD §4 spike 1, shared with UE5_Build spike 4). Genuinely external — no amount of our code answers it. Does NOT block a single-MetaHuman participant test, which is the only thing the first cinematic artifact needs.
• NeoStack ships MovieRenderQueue, MetaHuman and IKRig/IKRetargeter as SEPARATE NSAI_* extension modules that are NOT present in this install (all three Lua binding files are 2-line 'moved to the NSAI_* extension module' stubs). Vendor packaging decision, not ours. Fully worked around by the verified UE-Python bridge; optionally resolved by acquiring/installing the extension modules — and note the standing plugin law: NeoStack is built AS SOURCE against BuildId 55116800, so any extension must be rebuilt, never dropped in prebuilt.
• UStateTree.EditorData is a protected UPROPERTY, unreachable via the py-bridge or find_object, and a StateTree asset exposes 0 editable properties. The boss phase-state GRAPH therefore cannot be authored over ANY script channel — it is an in-editor manual (judgment-seam) pass. An engine constraint, discovered at game commit 76691a2. The cinematic lane routes around it via its own tag channel + debug emitter and must not be parked behind it.
• A mocap / body-animation library must be ACQUIRED and LICENSED (Fab / ActorCore / Mixamo class). No code we write produces body performance data. Distinguish sharply from audio-driven FACIAL animation, which is documented, scriptable and needs no external acquisition.
• Bespoke NON-audio-driven hero-beat performance (the specific nuanced take for a canonical set piece such as the Ch 76 naming or the Ch 77 reveal) has no pipeline and no tool substitute — UE_BUILD_AUTOMATION §5.4 is explicit that 'a signature shot's creative performance is still authored, not conjured'. It needs a capture session or hand animation, and only for the handful of director-in-loop rows.
• 5090-gated, HONESTLY SCOPED — and it is a short list: render-fidelity validation (Lumen/Nanite/strand-groom at LOD0), many-simultaneous-MetaHuman groom cost, batch dailies at real volume, and MetaHuman generation at roster scale. NOT 5090-gated: every item in the build list above. The extractor, the registry population, the row struct, the DataTable import, the 11 shot templates, the assembly driver, the WorldStateSubsystem, the dispatch table, the trigger channel, the gate and a 720p placeholder MRQ render all ship on the current machine.
• No local generative model exists on this machine today (no ollama, no llama.cpp; fastembed is embeddings-only). Irrelevant to this lane — nothing in the cinematic chain requires local inference. NeoStack's 'interpretive seam' for template authoring is a Claude-in-the-loop step, not a local-model step.

Generated by harness/site/structure_site.py — the URL path is the repo path. review root