Deploy NEXUS command center v2.2

.coderabbit.yaml

@@ -0,0 +1,40 @@
+language: en-US
+early_access: false
+reviews:
+  profile: assertive
+  request_changes_workflow: true
+  high_level_summary: true
+  high_level_summary_instructions: |
+    Summarize this PR as work on NEXUS Visual Weaver, a Hugging Face Build Small
+    Hackathon Gradio command-center for governed visual creation. Lead with
+    user-facing dashboard/workflow impact, then model-governance impact, then
+    security/export-gate impact, then verification evidence.
+
+    Preserve these project anchors in summaries when relevant:
+    - FLUX.2 is the pinned image-generation lane.
+    - NVIDIA LocateAnything-3B is the pinned grounding lane.
+    - ST3GG is the always-on security/export gate.
+    - Adult Mode must remain opt-in and must not disable provenance, consent,
+      age, export, dataset-partition, or ST3GG gates.
+    - ModelRelay/GMR helper rotation is quota-aware and only applies to helper
+      lanes, not pinned core lanes.
+
+    Avoid marketing filler, poems, exaggerated claims, or claims that provider
+    calls actually ran unless tests or logs prove it. Distinguish implemented
+    runtime behavior from dry-run preview surfaces and planning scaffolds.
+  poem: false
+  review_status: true
+  collapse_walkthrough: false
+  path_filters:
+    - "!outputs/**"
+    - "!**/__pycache__/**"
+    - "!pytest-cache-files-*/**"
+  path_instructions:
+    - path: "src/nexus_visual_weaver/**"
+      instructions: "Focus on Gradio runtime correctness, defensive security gates, model-lane governance, parameter-budget logic, and test coverage for fallback behavior."
+    - path: "app.py"
+      instructions: "Check that UI callbacks update the intended regions, never leak secrets, and keep Adult Mode security gates active."
+    - path: "tests/**"
+      instructions: "Prefer focused regression tests for workflow routing, ST3GG evidence, catalog filtering, and ModelRelay quota behavior."
+chat:
+  auto_reply: true

.env.example

@@ -0,0 +1,9 @@
+# Copy to .env locally or configure these as Hugging Face Space secrets.
+# Never commit real values.
+
+HF_TOKEN=
+MODAL_TOKEN_ID=
+MODAL_TOKEN_SECRET=
+OPENAI_API_KEY=
+NEXUS_PORT=7860
+

.gitattributes

@@ -1,35 +1,11 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+* text=auto eol=lf
+*.py text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+*.json text eol=lf
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.webp binary
+

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+* @specimba
+

.github/pull_request_template.md

@@ -0,0 +1,19 @@
+## What Changed
+- 
+
+## Why
+- 
+
+## Safety Gates
+- [ ] No secrets, tokens, generated auth folders, or provider credentials are committed.
+- [ ] Adult catalog behavior remains opt-in and does not disable ST3GG, consent, provenance, export, or dataset gates.
+- [ ] Pinned lanes remain pinned: FLUX.2 image generation, LocateAnything grounding, ST3GG security.
+- [ ] Generated outputs, moodboards, logs, caches, and local previews stay untracked.
+
+## Verification
+- [ ] `python -m compileall app.py src tests`
+- [ ] `python -m pytest -q tests -p no:cacheprovider --basetemp=C:\tmp\pytest-nvw-full`
+
+## Screenshots / Notes
+- 
+

.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Python tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: pip
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements.txt
+
+      - name: Compile
+        run: python -m compileall app.py src tests
+
+      - name: Import app
+        run: python -c "import app; print('app import ok')"
+
+      - name: Test
+        env:
+          PYTEST_DISABLE_PLUGIN_AUTOLOAD: "1"
+        run: python -m pytest -q tests -p no:cacheprovider

.gitignore

@@ -0,0 +1,69 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+pytest-cache-files-*/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+
+# Packaging/build artifacts
+build/
+dist/
+*.egg-info/
+.eggs/
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# Local secrets and credentials
+.env
+.env.*
+!.env.example
+.envrc
+*.pem
+*.key
+*.p12
+*.pfx
+.huggingface/
+.cache/huggingface/
+.modal.toml
+.netrc
+.pypirc
+
+# App/runtime outputs
+.gradio/
+.playwright-mcp/
+server*.log
+*.log
+outputs/
+nexus-visual-weaver-command-center*.png
+
+# Codex/local tool state
+.codex-home/
+outputs/moodboards/*/.codex-home/
+
+# Notebooks/docs build
+.ipynb_checkpoints/
+docs/_build/
+site/
+
+# OS/editor noise
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+tempCodeRunnerFile.py
+

AGENTS.md

@@ -0,0 +1,31 @@
+# AGENTS.md
+
+## Operating Rules
+
+- Keep changes scoped and verifiable.
+- Prefer focused tests over broad, slow runs.
+- Do not launch long-running local servers unless the user asks for visual validation.
+- Do not commit generated outputs, local logs, caches, preview artifacts, or credentials.
+- Use Hugging Face Space secrets and local `.env` files for provider credentials.
+- Preserve the pinned lanes unless the user explicitly approves a model-governance change:
+  - FLUX.2 for image generation
+  - LocateAnything-3B for grounding
+  - ST3GG for security/export review
+
+## Verification
+
+Use these gates before claiming completion:
+
+```powershell
+python -m compileall app.py src tests
+$env:PYTEST_DISABLE_PLUGIN_AUTOLOAD='1'
+python -m pytest -q tests -p no:cacheprovider --basetemp=C:\tmp\pytest-nvw-full
+```
+
+## Review Focus
+
+- Gradio callback wiring and region updates.
+- Adult Mode starts off and never disables safety gates.
+- ModelRelay respects parameter, license, quota, cooldown, and pinned-lane rules.
+- ST3GG scan results do not expose payload bytes or raw hidden content.
+

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,14 +1,108 @@
 ---
 title: NEXUS Visual Weaver
-emoji: 🖼
-colorFrom: purple
-colorTo: red
+emoji: 🧵
+colorFrom: red
+colorTo: gray
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 6.12.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: create cutting edge images, scenarios, videos and lores
+short_description: Governed gothic couture visual creation command center
+models:
+  - black-forest-labs/FLUX.2-klein-9B
+  - nvidia/LocateAnything-3B
+tags:
+  - gradio
+  - mcp-server
+  - visual-creation
+  - hackathon
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NEXUS Visual Weaver
+
+Dark creative-operations command center for the Hugging Face Build Small Hackathon.
+
+NEXUS Visual Weaver is a Gradio Space prototype for governed image and video creation. It combines a couture-oriented workflow dashboard, outfit and lore planning, model-lane governance, and an always-on defensive export gate.
+
+## Direction
+
+The interface is built around a command-center surface:
+
+- workflow graph for `Seed Prompt -> Refine -> Judge -> Locate -> Generate -> Video Path -> Human Checkpoint`
+- contextual inspector with taste rings, material checks, model stack, relay status, and ST3GG evidence
+- wardrobe drawer for garments, materials, footwear, accessories, locks, and reference-region intent
+- lore-to-video timeline for compact cinematic beats
+- provider handoff cards for dry-run visibility before any paid, gated, or quota-limited call
+
+## Model Governance
+
+Pinned lanes do not rotate:
+
+- `image_generation`: FLUX.2 primary image lane
+- `grounding`: NVIDIA LocateAnything-3B grounding anchor
+- `security`: ST3GG defensive scanner/export gate
+
+Helper lanes may rotate with quota, license, health, and parameter-budget checks:
+
+- prompt routing
+- taste judging
+- audio lore TTS
+- video repair
+- HF catalog research
+- Modal job runner
+
+Public demo mode excludes private, commercial-uncleared, and research-only helper models. Private research mode can expose more candidates, but it never disables consent, provenance, ST3GG, export, or dataset-partition gates.
+
+## Current Features
+
+- Gradio Blocks dashboard with split update regions.
+- Active workflow graph and checkpointed run record.
+- Taste profile scoring from `assets/taste_profile.json`.
+- Wardrobe slot planning for couture, gothic, fantasy, footwear, accessories, and material control.
+- HF model and LoRA catalog with Adult Mode hidden by default.
+- GMR/ModelRelay-inspired helper model selection.
+- ST3GG-inspired scan adapter with magic detection, mismatch review, purification actions, and export-gate state.
+- Focused regression tests for catalog scope, workflow planning, ModelRelay behavior, and scanner evidence.
+
+## Local Setup
+
+```powershell
+python -m pip install -r requirements.txt
+python app.py
+```
+
+The app reads `NEXUS_PORT` or `PORT` when present, otherwise it launches on `7860`.
+
+## Verification
+
+```powershell
+python -m compileall app.py src tests
+$env:PYTEST_DISABLE_PLUGIN_AUTOLOAD='1'
+python -m pytest -q tests -p no:cacheprovider --basetemp=C:\tmp\pytest-nvw-full
+```
+
+## Secret Policy
+
+Do not commit provider credentials. Use Hugging Face Space secrets or local `.env` files for:
+
+- `HF_TOKEN`
+- `MODAL_TOKEN_ID`
+- `MODAL_TOKEN_SECRET`
+- `OPENAI_API_KEY`
+- provider-specific API keys or bearer tokens
+
+Generated outputs, local moodboards, logs, caches, auth folders, and preview artifacts are intentionally ignored.
+
+## Review Workflow
+
+- Bootstrap commit establishes the public GitHub repository baseline.
+- Future substantial changes should use `codex/specimba/<scope>` branches and draft pull requests.
+- GitHub Actions runs compile and pytest.
+- CodeRabbit is configured to focus review on Gradio runtime correctness, model governance, security gates, Adult Mode behavior, and regression coverage.
+
+See [docs/RELEASE_WORKFLOW.md](docs/RELEASE_WORKFLOW.md) for the push and review gate.
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).

SECURITY.md

@@ -0,0 +1,39 @@
+# Security Policy
+
+## Supported Scope
+
+This repository is an active hackathon prototype. Security-sensitive changes include:
+
+- provider authentication
+- file upload handling
+- ST3GG scan/export behavior
+- Adult Mode catalog gating
+- model relay and provider routing
+- generated artifact handling
+
+## Secret Handling
+
+Never commit real tokens, API keys, bearer tokens, private keys, OAuth material, or provider credentials.
+
+Use:
+
+- Hugging Face Space secrets for deployment
+- local `.env` files for development
+- `.env.example` for placeholder names only
+
+Ignored local paths include `.env*`, `.huggingface/`, `.modal.toml`, `.codex-home/`, logs, caches, and generated `outputs/`.
+
+## Required Review Gates
+
+Before merging or deploying:
+
+1. Run compile and pytest.
+2. Run a secret-pattern scan over tracked files.
+3. Confirm Adult Mode remains opt-in.
+4. Confirm ST3GG, consent, provenance, export, and dataset-partition gates remain active in every mode.
+5. Confirm generated outputs and local auth folders are not committed.
+
+## Reporting
+
+Open a private issue or contact the repository owner if you find a credential leak, unsafe export path, or bypass of Adult Mode/ST3GG behavior.
+

app.py

@@ -1,154 +1,295 @@
+"""NEXUS Visual Weaver - Build Small Hackathon command center."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
 import gradio as gr
-import numpy as np
-import random
-
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
+
+ROOT = Path(__file__).resolve().parent
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+try:
+    import spaces  # type: ignore  # noqa: F401
+except Exception:  # pragma: no cover - local development does not require Spaces.
+    spaces = None
+
+from nexus_visual_weaver.catalog import catalog_summary
+from nexus_visual_weaver.model_relay import WeaverModelRelay
+from nexus_visual_weaver.planner import build_command_center_run
+from nexus_visual_weaver.render import render_catalog_table, render_command_header, render_dashboard_regions
+from nexus_visual_weaver.security import scan_file
+from nexus_visual_weaver.styles import APP_CSS
+
+APP_THEME = gr.themes.Base(
+    primary_hue="rose",
+    secondary_hue="cyan",
+    neutral_hue="slate",
+    radius_size="sm",
+    font=["Inter", "ui-sans-serif", "system-ui"],
+)
+
+
+DEFAULT_PROMPT = (
+    "A Slavic archivist in a rain-slick neon city, wearing a structured black patent "
+    "leather long coat with faux fur collar, Chantilly lace neckline, glowing crimson "
+    "hardware, platform boots, NEXUS sigils and floating code streams behind her."
+)
+
+MODEL_RELAY = WeaverModelRelay()
+
+
+def _relay_snapshot(adult_mode: bool = False) -> dict[str, Any]:
+    return MODEL_RELAY.dashboard_snapshot(public_demo=not adult_mode)
+
+
+def _file_path(uploaded: Any) -> str | None:
+    if uploaded is None:
+        return None
+    if isinstance(uploaded, str):
+        return uploaded
+    path = getattr(uploaded, "name", None)
+    return str(path) if path else None
+
+
+SECTIONS = ["Forge", "Wardrobe", "Lore", "Models", "Security", "Runs"]
+
+
+def _dashboard_regions(
+    run: Any | None = None,
+    adult_mode: bool = False,
+    scan: dict[str, Any] | None = None,
+    active_section: str = "Forge",
+) -> dict[str, str]:
+    return render_dashboard_regions(
+        run=run,
+        adult_mode=adult_mode,
+        scan=scan,
+        relay_status=_relay_snapshot(adult_mode),
+        active_section=active_section,
+    )
+
+
+def run_weave(
+    prompt: str,
+    reasoning_mode: str,
+    video_preset: str,
+    adult_mode: bool,
+    upload: Any,
+    active_section: str,
+) -> tuple[str, str, str, str, str, str, str, str, str, str, dict[str, Any], dict[str, Any], dict[str, Any]]:
+    prompt = prompt.strip() or DEFAULT_PROMPT
+    run = build_command_center_run(
         prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
+        mode=reasoning_mode,
+        video_preset=video_preset,
+        adult_mode=adult_mode,
+    )
+    scan = scan_file(_file_path(upload))
+    regions = _dashboard_regions(run=run, adult_mode=adult_mode, scan=scan, active_section=active_section)
+    catalog = render_catalog_table(adult_mode=adult_mode)
+    return (
+        regions["topbar"],
+        regions["command_rail"],
+        regions["workflow"],
+        regions["operations"],
+        regions["inspector"],
+        regions["drawer"],
+        regions["status"],
+        regions["artifacts"],
+        regions["providers"],
+        catalog,
+        run.to_dict(),
+        catalog_summary(adult_mode),
+        scan,
+    )
 
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
+def toggle_adult_visibility(
+    adult_mode: bool,
+    active_section: str,
+    upload: Any,
+) -> tuple[str, str, str, str, str, str, str, dict[str, Any], dict[str, Any]]:
+    scan = scan_file(_file_path(upload))
+    regions = _dashboard_regions(adult_mode=adult_mode, scan=scan, active_section=active_section)
+    return (
+        regions["topbar"],
+        regions["command_rail"],
+        regions["operations"],
+        regions["inspector"],
+        regions["artifacts"],
+        regions["providers"],
+        render_catalog_table(adult_mode=adult_mode),
+        catalog_summary(adult_mode),
+        scan,
+    )
 
-        result = gr.Image(label="Result", show_label=False)
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
+def refresh_section(
+    active_section: str,
+    adult_mode: bool,
+    upload: Any,
+) -> tuple[str, str, str, str, str, dict[str, Any]]:
+    scan = scan_file(_file_path(upload))
+    regions = _dashboard_regions(adult_mode=adult_mode, scan=scan, active_section=active_section)
+    return regions["command_rail"], regions["operations"], regions["inspector"], regions["artifacts"], regions["providers"], scan
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-            )
 
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+initial_regions = _dashboard_regions(scan=scan_file(None))
 
-            with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
+with gr.Blocks(title="NEXUS Visual Weaver") as demo:
+    topbar_html = gr.HTML(initial_regions["topbar"], container=False)
 
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+    with gr.Group(elem_id="nw-inputs", elem_classes=["nw-control-panel"]):
+        gr.HTML(render_command_header(), container=False)
+        with gr.Row():
+            prompt = gr.Textbox(
+                value=DEFAULT_PROMPT,
+                label="Creative Brief",
+                lines=3,
+                max_lines=6,
+                scale=5,
+            )
+            with gr.Column(scale=2):
+                reasoning_mode = gr.Radio(
+                    ["Strict", "Frontier"],
+                    value="Strict",
+                    label="Reasoning Mode",
                 )
-
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
+                video_preset = gr.Dropdown(
+                    ["Wan2.2 I2V", "LTX-2.3"],
+                    value="Wan2.2 I2V",
+                    label="Video Path Preset",
                 )
+        with gr.Row():
+            upload = gr.File(
+                label="Reference / Output For ST3GG Scan",
+                file_count="single",
+                type="filepath",
+                scale=3,
+            )
+            adult_mode = gr.Checkbox(
+                value=False,
+                label="Adult Mode 18+ catalog scope",
+                info="Off by default. Enables adult-tagged catalog entries but does not disable security, consent, or export gates.",
+                scale=2,
+            )
+            run_btn = gr.Button("Run Active Weave", variant="primary", scale=1)
+            stop_btn = gr.Button("Stop Provider Job", variant="stop", interactive=False, scale=1)
 
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
-                )
+    with gr.Row(elem_id="nw-workspace", elem_classes=["nw-workspace"]):
+        with gr.Column(scale=1, min_width=150, elem_id="nw-native-rail"):
+            section_nav = gr.Radio(
+                SECTIONS,
+                value="Forge",
+                label="Command Rail",
+                elem_id="nw-section-nav",
+            )
+            command_rail_html = gr.HTML(initial_regions["command_rail"], container=False)
+        with gr.Column(scale=5, min_width=620, elem_id="nw-main-column"):
+            workflow_html = gr.HTML(initial_regions["workflow"], container=False)
+            operations_html = gr.HTML(initial_regions["operations"], container=False)
+            artifact_html = gr.HTML(initial_regions["artifacts"], container=False)
+            drawer_html = gr.HTML(initial_regions["drawer"], container=False)
+        with gr.Column(scale=2, min_width=340, elem_id="nw-side-column"):
+            inspector_html = gr.HTML(initial_regions["inspector"], container=False)
+            provider_html = gr.HTML(initial_regions["providers"], container=False)
 
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
+    status_html = gr.HTML(initial_regions["status"], container=False)
+
+    with gr.Accordion("Catalog, run record, and security evidence", open=False):
+        catalog_html = gr.HTML(render_catalog_table(False), container=False)
+        with gr.Row():
+            run_json = gr.JSON(label="GenerationRun")
+            catalog_json = gr.JSON(label="Catalog Summary")
+            scan_json = gr.JSON(label="ST3GG Scan")
+
+    run_btn.click(
+        fn=run_weave,
+        inputs=[prompt, reasoning_mode, video_preset, adult_mode, upload, section_nav],
+        outputs=[
+            topbar_html,
+            command_rail_html,
+            workflow_html,
+            operations_html,
+            inspector_html,
+            drawer_html,
+            status_html,
+            artifact_html,
+            provider_html,
+            catalog_html,
+            run_json,
+            catalog_json,
+            scan_json,
+        ],
+        api_name="run_active_weave",
+    )
+    prompt.submit(
+        fn=run_weave,
+        inputs=[prompt, reasoning_mode, video_preset, adult_mode, upload, section_nav],
+        outputs=[
+            topbar_html,
+            command_rail_html,
+            workflow_html,
+            operations_html,
+            inspector_html,
+            drawer_html,
+            status_html,
+            artifact_html,
+            provider_html,
+            catalog_html,
+            run_json,
+            catalog_json,
+            scan_json,
+        ],
+        api_name=False,
+    )
+    adult_mode.change(
+        fn=toggle_adult_visibility,
+        inputs=[adult_mode, section_nav, upload],
+        outputs=[
+            topbar_html,
+            command_rail_html,
+            operations_html,
+            inspector_html,
+            artifact_html,
+            provider_html,
+            catalog_html,
+            catalog_json,
+            scan_json,
         ],
-        outputs=[result, seed],
+        api_name="toggle_adult_catalog",
+    )
+    section_nav.change(
+        fn=refresh_section,
+        inputs=[section_nav, adult_mode, upload],
+        outputs=[command_rail_html, operations_html, inspector_html, artifact_html, provider_html, scan_json],
+        api_name=False,
+    )
+    demo.load(
+        fn=lambda: (render_catalog_table(False), catalog_summary(False), scan_file(None)),
+        outputs=[catalog_html, catalog_json, scan_json],
+        api_name=False,
     )
 
+
 if __name__ == "__main__":
-    demo.launch()
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    if hasattr(sys.stderr, "reconfigure"):
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("NEXUS_PORT", os.environ.get("PORT", "7860"))),
+        quiet=True,
+        mcp_server=True,
+        ssr_mode=False,
+        css=APP_CSS,
+        theme=APP_THEME,
+    )

assets/taste_profile.json

@@ -0,0 +1,69 @@
+{
+  "version": "1.0.0",
+  "last_updated": "2026-06-04T04:30:00+03:00",
+  "source": "GROK_IMAGINE taste_profile.json, normalized for NEXUS Visual Weaver",
+  "description": "Locked taste profile for governed visual creation. Every prompt, outfit, image edit, and video plan is scored against this profile.",
+  "locked_features": {
+    "materials": {
+      "primary": ["patent_leather"],
+      "accents": ["faux_fur", "chantilly_lace"],
+      "hardware": ["crimson_hardware"]
+    },
+    "footwear": ["platform_boots"],
+    "model_aesthetic": {
+      "ethnicity": "slavic_model",
+      "features": ["high_cheekbones", "intense_focused_eyes", "pale_matte_skin", "full_lips"]
+    },
+    "lighting_and_atmosphere": [
+      "cinematic_dramatic_lighting",
+      "deep_obsidian_shadows",
+      "electric_neon_highlights",
+      "rain_slicked_surfaces",
+      "floating_code_data_streams"
+    ],
+    "thematic_elements": [
+      "gothic_haute_couture",
+      "cyberpunk_decadence",
+      "nexus_sigils",
+      "orchestrator_node_glyphs",
+      "holographic_butterfly_wings",
+      "iridescent_data_streams"
+    ],
+    "rendering": {
+      "style": "ultra_photorealistic_flux2",
+      "detail_level": "extreme_micro_detail",
+      "materials_detail": [
+        "leather_grain",
+        "fur_texture",
+        "lace_threads",
+        "metallic_reflections",
+        "skin_pores"
+      ]
+    }
+  },
+  "enforcement_rules": {
+    "must_include": [
+      "At least one primary material (patent_leather)",
+      "Slavic model features",
+      "Crimson hardware accents",
+      "Platform boots or equivalent strong footwear detail"
+    ],
+    "should_include": [
+      "Faux fur or Chantilly lace accents",
+      "NEXUS thematic elements",
+      "High-contrast material textures"
+    ],
+    "forbidden": [
+      "Soft pastel colors unless used as deliberate neon contrast",
+      "Realistic modern fashion without cyberpunk/gothic elevation",
+      "Low-detail or blurry material rendering"
+    ],
+    "trust_scoring_guidelines": {
+      "0.90-1.00": "Perfect alignment - promote to Wisdom",
+      "0.80-0.89": "Strong alignment - approve with minor notes",
+      "0.70-0.79": "Acceptable but needs refinement",
+      "< 0.70": "Reject or force major re-refinement"
+    }
+  }
+}
+

docs/HACKATHON_EVALUATION.md

@@ -0,0 +1,34 @@
+# Hackathon Evaluation Snapshot
+
+## Judge-Facing Product Signal
+
+NEXUS Visual Weaver should open as a working command center, not a landing page. The current target is a Gradio dashboard where judges can immediately see:
+
+- a central workflow graph from prompt to human checkpoint
+- a contextual operations panel for Forge, Wardrobe, Lore, Models, Security, and Runs
+- a right-side inspector with taste, material, ModelRelay, and ST3GG state
+- an artifact preview lane that is honest about dry-run/provider handoff status
+- wardrobe and lore drawers that make gothic couture, footwear, accessories, and video continuity concrete
+
+## Current Strengths
+
+- Gradio-compatible app shape with `mcp_server=True`.
+- Pinned model governance is visible: FLUX.2, LocateAnything-3B, and ST3GG.
+- Adult Mode starts off and is framed as catalog scope, not a safety bypass.
+- ModelRelay/GMR helper rotation is represented without replacing pinned lanes.
+- Tests cover catalog scope, workflow planning, ModelRelay behavior, scanner evidence, and dashboard fallback rendering.
+
+## Remaining Gaps
+
+- Provider calls are still represented as dry-run handoff surfaces.
+- The dashboard needs at least one judge-safe generation or mocked provider success path with clear provenance.
+- Visual validation screenshots should be captured after the next UI pass.
+- Docstring coverage is repo-wide 0/76 and should be handled separately if we decide to enforce that review gate.
+- GitHub Actions cannot run until the account billing lock is resolved.
+
+## Next Implementation Priority
+
+1. Add a judge-safe demo run path that produces deterministic visible output without secrets.
+2. Add provider-status badges for configured, dry-run, blocked, and failed states in the top bar and artifact lane.
+3. Add Playwright/browser visual checks for desktop and mobile overflow once CI is unblocked.
+4. Prepare the Hugging Face Space README and app card with model-governance, safety, and hackathon reward framing.

docs/RELEASE_WORKFLOW.md

@@ -0,0 +1,35 @@
+# Release Workflow
+
+NEXUS Visual Weaver uses GitHub for rollback-safe development and Hugging Face Spaces for the hackathon demo.
+
+## Branching
+
+- Bootstrap only: first commit can land on `main` because the public repository starts empty.
+- Normal work: create `codex/specimba/<short-scope>` branches.
+- Big changes: open draft pull requests and let CI plus review bots comment before merge.
+
+## Push Gate
+
+Before pushing:
+
+1. Run `python -m compileall app.py src tests`.
+2. Run `python -m pytest -q tests -p no:cacheprovider --basetemp=C:\tmp\pytest-nvw-full`.
+3. Run a secret scan over tracked files.
+4. Confirm generated outputs, local logs, caches, Space auth folders, and provider tokens are ignored.
+
+## Secrets
+
+Use Hugging Face Space secrets or local `.env` files. Do not commit real values for:
+
+- `HF_TOKEN`
+- `MODAL_TOKEN_ID`
+- `MODAL_TOKEN_SECRET`
+- `OPENAI_API_KEY`
+- Provider-specific API keys or bearer tokens
+
+## Review Automation
+
+- GitHub Actions runs compile and pytest on `main` and pull requests.
+- CodeRabbit can review pull requests using `.coderabbit.yaml`.
+- Human review should focus on model governance, Adult Mode gates, ST3GG export behavior, and hackathon demo clarity.
+

pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+pythonpath = src
+testpaths = tests
+

requirements.txt

@@ -1,6 +1,3 @@
-accelerate
-diffusers
-invisible_watermark
-torch
-transformers
-xformers
+gradio==6.12.0
+huggingface_hub==1.18.0
+pytest==9.0.3

src/nexus_visual_weaver/__init__.py

@@ -0,0 +1,47 @@
+"""NEXUS Visual Weaver command-center package."""
+
+from .catalog import DEFAULT_ACTIVE_STACK, catalog_summary, filter_catalog, parameter_budget
+from .model_relay import ContextPacket, LaneDecision, ModelRecord, WeaverModelRelay
+from .planner import build_command_center_run
+from .schema import (
+    AdapterRecipe,
+    CreativeRequest,
+    GenerationRun,
+    GroundingTarget,
+    HumanCheckpoint,
+    InspectionReport,
+    LoreBeatSet,
+    ModelCandidate,
+    OutfitGraph,
+    TasteProfile,
+    TasteRefinedPrompt,
+    VideoPlan,
+    WardrobeSlot,
+    WisdomRecord,
+)
+
+__all__ = [
+    "AdapterRecipe",
+    "CreativeRequest",
+    "GenerationRun",
+    "GroundingTarget",
+    "HumanCheckpoint",
+    "InspectionReport",
+    "LoreBeatSet",
+    "ModelCandidate",
+    "OutfitGraph",
+    "TasteProfile",
+    "TasteRefinedPrompt",
+    "VideoPlan",
+    "WardrobeSlot",
+    "WisdomRecord",
+    "ContextPacket",
+    "DEFAULT_ACTIVE_STACK",
+    "LaneDecision",
+    "ModelRecord",
+    "WeaverModelRelay",
+    "build_command_center_run",
+    "catalog_summary",
+    "filter_catalog",
+    "parameter_budget",
+]

src/nexus_visual_weaver/catalog.py

@@ -0,0 +1,171 @@
+"""Seeded HF model and adapter catalog for the command center."""
+
+from __future__ import annotations
+
+from .schema import AdapterRecipe, ModelCandidate
+
+MODEL_CATALOG: list[ModelCandidate] = [
+    ModelCandidate(
+        repo_id="black-forest-labs/FLUX.2-klein-9B",
+        role="image_generator",
+        task="image-to-image",
+        params_b=9.0,
+        runtime="diffusers / provider",
+        license="other",
+        gated=True,
+        source_url="https://hf.co/black-forest-labs/FLUX.2-klein-9B",
+    ),
+    ModelCandidate(
+        repo_id="Brunobkr/OFFELLIA_Q4_0_gemma-4-12B-it.gguf",
+        role="multimodal_judge",
+        task="image-text-to-text",
+        params_b=12.0,
+        runtime="llama.cpp GGUF",
+        license="apache-2.0",
+        source_url="https://hf.co/Brunobkr/OFFELLIA_Q4_0_gemma-4-12B-it.gguf",
+    ),
+    ModelCandidate(
+        repo_id="nvidia/LocateAnything-3B",
+        role="visual_grounding",
+        task="image-text-to-text",
+        params_b=3.83,
+        runtime="transformers",
+        license="other",
+        source_url="https://hf.co/nvidia/LocateAnything-3B",
+    ),
+    ModelCandidate(
+        repo_id="openbmb/MiniCPM5-1B",
+        role="router",
+        task="text-generation / tool-calling",
+        params_b=1.08,
+        runtime="transformers",
+        license="apache-2.0",
+        source_url="https://hf.co/openbmb/MiniCPM5-1B",
+    ),
+    ModelCandidate(
+        repo_id="onnx-community/functiongemma-270m-it-ONNX",
+        role="fallback_router",
+        task="text-generation",
+        params_b=0.27,
+        runtime="transformers.js / ONNX",
+        license="gemma",
+        source_url="https://hf.co/onnx-community/functiongemma-270m-it-ONNX",
+    ),
+    ModelCandidate(
+        repo_id="Brunobkr/OFFELLIA_IQ4_XS_gemma-4-12B-it-heretic",
+        role="adult_mode_text_judge",
+        task="text-generation",
+        params_b=12.0,
+        runtime="llama.cpp GGUF",
+        license="other",
+        adult_only=True,
+        source_url="https://hf.co/Brunobkr/OFFELLIA_IQ4_XS_gemma-4-12B-it-heretic",
+    ),
+    ModelCandidate(
+        repo_id="Wan-AI/Wan2.2-I2V-A14B-Diffusers",
+        role="video_swap_preset",
+        task="image-to-video",
+        params_b=14.0,
+        runtime="diffusers / provider",
+        license="apache-2.0",
+        source_url="https://hf.co/Wan-AI/Wan2.2-I2V-A14B-Diffusers",
+    ),
+    ModelCandidate(
+        repo_id="Lightricks/LTX-2.3",
+        role="video_swap_preset",
+        task="image-to-video",
+        params_b=22.0,
+        runtime="diffusers",
+        license="other",
+        source_url="https://hf.co/Lightricks/LTX-2.3",
+    ),
+]
+
+ADAPTER_CATALOG: list[AdapterRecipe] = [
+    AdapterRecipe(
+        repo_id="DeverStyle/Flux.2-Klein-Loras",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="text-to-image style stack",
+        license="apache-2.0",
+    ),
+    AdapterRecipe(
+        repo_id="nomadoor/flux-2-klein-9B-schematic-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-base-9B",
+        task="pose/depth/segmentation schematic control",
+        license="other",
+    ),
+    AdapterRecipe(
+        repo_id="fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA",
+        adapter_for="Qwen/Qwen-Image-Edit-2511",
+        task="camera-angle edit",
+        license="apache-2.0",
+    ),
+    AdapterRecipe(
+        repo_id="joyfox/LTX-2.3-Transition-LORA",
+        adapter_for="Lightricks/LTX-2.3",
+        task="image-to-video transition",
+        license="apache-2.0",
+    ),
+    AdapterRecipe(
+        repo_id="LiconStudio/Ltx2.3-VBVR-lora-I2V",
+        adapter_for="Lightricks/LTX-2.3",
+        task="video reasoning / I2V",
+        license="other",
+    ),
+    AdapterRecipe(
+        repo_id="ScottzillaSystems/qwen-image-edit-plus-nsfw-lora",
+        adapter_for="Qwen/Qwen-Image-Edit-2511",
+        task="adult image edit catalog entry",
+        license="openrail++",
+        adult_only=True,
+    ),
+    AdapterRecipe(
+        repo_id="lopi999/Wan2.2-I2V_General-NSFW-LoRA",
+        adapter_for="Wan-AI/Wan2.2-I2V-A14B",
+        task="adult video adapter catalog entry",
+        license="unknown",
+        adult_only=True,
+    ),
+]
+
+DEFAULT_ACTIVE_STACK = [
+    "black-forest-labs/FLUX.2-klein-9B",
+    "Brunobkr/OFFELLIA_Q4_0_gemma-4-12B-it.gguf",
+    "nvidia/LocateAnything-3B",
+    "openbmb/MiniCPM5-1B",
+]
+
+
+def filter_catalog(adult_mode: bool = False) -> tuple[list[ModelCandidate], list[AdapterRecipe]]:
+    models = [model for model in MODEL_CATALOG if adult_mode or not model.adult_only]
+    adapters = [adapter for adapter in ADAPTER_CATALOG if adult_mode or not adapter.adult_only]
+    return models, adapters
+
+
+def active_stack(adult_mode: bool = False) -> list[ModelCandidate]:
+    allowed, _ = filter_catalog(adult_mode)
+    by_id = {model.repo_id: model for model in allowed}
+    return [by_id[repo_id] for repo_id in DEFAULT_ACTIVE_STACK if repo_id in by_id]
+
+
+def parameter_budget(stack: list[ModelCandidate] | None = None) -> dict[str, float | str]:
+    chosen = stack or active_stack(False)
+    total = round(sum(model.params_b for model in chosen), 2)
+    return {
+        "active_b": total,
+        "limit_b": 32.0,
+        "remaining_b": round(32.0 - total, 2),
+        "status": "pass" if total <= 32.0 else "over_budget",
+    }
+
+
+def catalog_summary(adult_mode: bool = False) -> dict[str, int | float | str]:
+    models, adapters = filter_catalog(adult_mode)
+    budget = parameter_budget(active_stack(adult_mode))
+    return {
+        "models_visible": len(models),
+        "adapters_visible": len(adapters),
+        "adult_catalog": "enabled" if adult_mode else "hidden",
+        **budget,
+    }
+

src/nexus_visual_weaver/grounding.py

@@ -0,0 +1,33 @@
+"""LocateAnything-style grounding simulation for planning and UI state."""
+
+from __future__ import annotations
+
+from .schema import GroundingTarget, InspectionReport, OutfitGraph
+
+
+def inspect_outfit(outfit: OutfitGraph) -> InspectionReport:
+    targets: list[GroundingTarget] = []
+    for slot in outfit.slots:
+        if slot.name in {"outerwear", "upper_body", "footwear", "jewelry", "background_context"}:
+            confidence = 0.92 if slot.locked else 0.78
+            targets.append(
+                GroundingTarget(
+                    slot_name=slot.name,
+                    query=f"locate {slot.description}",
+                    expected_region=slot.locate_region,
+                    confidence=confidence,
+                )
+            )
+
+    drift_flags: list[str] = []
+    if not any(slot.name == "footwear" and slot.locked for slot in outfit.slots):
+        drift_flags.append("footwear requires stronger prompt lock")
+    if outfit.score < 0.78:
+        drift_flags.append("material contrast needs refinement before render")
+
+    return InspectionReport(
+        status="pass" if not drift_flags else "review",
+        targets=targets,
+        drift_flags=drift_flags,
+    )
+

src/nexus_visual_weaver/lore.py

@@ -0,0 +1,39 @@
+"""Lore beat and checkpointed video planning."""
+
+from __future__ import annotations
+
+from .schema import LoreBeatSet, VideoPlan
+
+
+def build_lore_beats(prompt: str) -> LoreBeatSet:
+    seed = prompt.strip()[:90] or "The Archivist enters the neon archive."
+    beats = [
+        {"id": "01", "title": "The Archivist", "cue": seed},
+        {"id": "02", "title": "Neon Gates", "cue": "rain-lit threshold, NEXUS glyphs waking in the glass"},
+        {"id": "03", "title": "The Confrontation", "cue": "wardrobe details and crimson hardware become identity anchors"},
+        {"id": "04", "title": "Shattered Truth", "cue": "LocateAnything confirms outfit continuity under motion"},
+        {"id": "05", "title": "Raven's Choice", "cue": "human checkpoint decides whether to promote the run"},
+        {"id": "06", "title": "Into the Rain", "cue": "video path locks the final camera move and frame pacing"},
+    ]
+    return LoreBeatSet(beats=beats, tone="gothic couture cyberpunk / controlled cinematic tension")
+
+
+def build_video_plan(preset: str = "Wan2.2 I2V") -> VideoPlan:
+    if "LTX" in preset:
+        return VideoPlan(
+            preset="LTX-2.3",
+            source="approved image candidate",
+            camera_move="slow parallax push with fabric and rain continuity locks",
+            duration_seconds=5.3,
+            fps=24,
+            continuity_locks=["wardrobe slots", "face/pose", "crimson hardware", "rain direction"],
+        )
+    return VideoPlan(
+        preset="Wan2.2 I2V",
+        source="approved image candidate",
+        camera_move="controlled dolly-in with coat, lace, boots, and code-stream stabilization",
+        duration_seconds=4.8,
+        fps=24,
+        continuity_locks=["outerwear", "footwear", "jewelry", "NEXUS sigils"],
+    )
+

src/nexus_visual_weaver/model_relay.py

@@ -0,0 +1,823 @@
+"""Quota-aware helper model rotation for NEXUS Visual Weaver.
+
+The relay mirrors the useful GMR/ModelRelay ideas from NEXUS without copying
+the source: pinned creative anchors stay fixed, helper lanes can rotate, and
+all decisions carry a compact context packet for fallback continuity.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+
+PINNED_LANES = {"image_generation", "grounding", "security"}
+ROTATABLE_LANES = {
+    "prompt_router",
+    "taste_judge",
+    "audio_lore_tts",
+    "video_repair",
+    "hf_catalog_research",
+    "modal_job_runner",
+}
+PUBLIC_SAFE_LICENSES = {"apache-2.0", "mit", "bsd-3-clause", "gemma", "public_safe", "openrail"}
+PRIVATE_LICENSES = {"private_research", "research_noncommercial", "commercial_required", "other", "unknown", "review_required"}
+STRATEGY_ALIASES = {
+    "speed": "latency_first",
+    "fast": "latency_first",
+    "safe_public": "license_safe_public",
+    "public": "license_safe_public",
+    "private": "private_research",
+}
+DEFAULT_ROTATION_BUDGET_B = 5.0
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _iso(value: datetime | None) -> str | None:
+    return value.isoformat(timespec="seconds") if value else None
+
+
+@dataclass
+class ContextPacket:
+    lane: str
+    task: str
+    public_demo: bool
+    budget_b: float
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ModelRecord:
+    model_id: str
+    lane: str
+    provider: str
+    repo_id: str
+    license_gate: str
+    params_b: float
+    cost_hint: str
+    rpm_limit: int
+    rpd_limit: int
+    cooldown_until: datetime | None = None
+    health: str = "healthy"
+    latency_ms: int = 500
+    quality_score: float = 0.75
+    fallback_chain: tuple[str, ...] = ()
+    pinned: bool = False
+    adult_capable: bool = False
+    last_failure: str | None = None
+    success_count: int = 0
+    failure_count: int = 0
+    minute_calls: list[datetime] = field(default_factory=list)
+    day_calls: list[datetime] = field(default_factory=list)
+
+    @property
+    def public_safe(self) -> bool:
+        return self.license_gate in PUBLIC_SAFE_LICENSES and not self.adult_capable
+
+    def in_cooldown(self, now: datetime | None = None) -> bool:
+        now = now or utc_now()
+        return bool(self.cooldown_until and self.cooldown_until > now)
+
+    def to_dict(self, now: datetime | None = None) -> dict[str, Any]:
+        now = now or utc_now()
+        return {
+            "model_id": self.model_id,
+            "lane": self.lane,
+            "provider": self.provider,
+            "repo_id": self.repo_id,
+            "license_gate": self.license_gate,
+            "params_b": self.params_b,
+            "cost_hint": self.cost_hint,
+            "rpm_limit": self.rpm_limit,
+            "rpd_limit": self.rpd_limit,
+            "cooldown_until": _iso(self.cooldown_until),
+            "in_cooldown": self.in_cooldown(now),
+            "health": self.health,
+            "latency_ms": self.latency_ms,
+            "quality_score": self.quality_score,
+            "fallback_chain": list(self.fallback_chain),
+            "pinned": self.pinned,
+            "adult_capable": self.adult_capable,
+            "last_failure": self.last_failure,
+            "success_count": self.success_count,
+            "failure_count": self.failure_count,
+            "rpm_used": len(self.minute_calls),
+            "rpd_used": len(self.day_calls),
+        }
+
+
+@dataclass
+class LaneDecision:
+    lane: str
+    strategy: str
+    primary: ModelRecord | None
+    fallbacks: list[ModelRecord]
+    reason: str
+    expected_cost_hint: str
+    quota_impact: dict[str, Any]
+    context_packet: ContextPacket
+    skipped: list[str] = field(default_factory=list)
+
+    @property
+    def pinned(self) -> bool:
+        return bool(self.primary and self.primary.pinned)
+
+    @property
+    def rotatable(self) -> bool:
+        return self.lane in ROTATABLE_LANES
+
+    def to_dict(self, now: datetime | None = None) -> dict[str, Any]:
+        now = now or utc_now()
+        return {
+            "lane": self.lane,
+            "strategy": self.strategy,
+            "primary": self.primary.to_dict(now) if self.primary else None,
+            "fallbacks": [record.to_dict(now) for record in self.fallbacks],
+            "reason": self.reason,
+            "expected_cost_hint": self.expected_cost_hint,
+            "quota_impact": self.quota_impact,
+            "context_packet": self.context_packet.to_dict(),
+            "skipped": self.skipped,
+            "pinned": self.pinned,
+            "rotatable": self.rotatable,
+        }
+
+
+@dataclass
+class _DedupEntry:
+    value: Any
+    expires_at: datetime
+
+
+class WeaverModelRelay:
+    """Selects helper models while preserving pinned creative anchors."""
+
+    def __init__(
+        self,
+        records: list[ModelRecord] | None = None,
+        now_fn: Callable[[], datetime] = utc_now,
+    ) -> None:
+        self._now_fn = now_fn
+        self.records: dict[str, ModelRecord] = {record.model_id: record for record in (records or default_model_records())}
+        self._dedup: dict[str, _DedupEntry] = {}
+        self._dedup_hits = 0
+
+    def select_lane(
+        self,
+        lane: str,
+        task: str = "",
+        budget: float | None = None,
+        public_demo: bool = True,
+        strategy: str = "quality_first",
+    ) -> LaneDecision:
+        lane = self.normalize_lane(lane)
+        strategy = self.normalize_strategy(strategy)
+        budget_b = float(budget if budget is not None else (32.0 if lane in PINNED_LANES else DEFAULT_ROTATION_BUDGET_B))
+        now = self._now()
+        context = ContextPacket(lane=lane, task=task or lane, public_demo=public_demo, budget_b=budget_b)
+
+        lane_records = [record for record in self.records.values() if record.lane == lane]
+        if lane in PINNED_LANES:
+            primary = next((record for record in lane_records if record.pinned), None)
+            return LaneDecision(
+                lane=lane,
+                strategy="pinned",
+                primary=primary,
+                fallbacks=[],
+                reason="Pinned core lane; rotation disabled for creative identity, grounding, or security.",
+                expected_cost_hint=primary.cost_hint if primary else "unavailable",
+                quota_impact=self._quota_impact(primary, now) if primary else {},
+                context_packet=context,
+                skipped=[] if primary else [f"{lane}: no pinned model registered"],
+            )
+
+        candidates, skipped = self._eligible_records(lane_records, budget_b, public_demo, strategy, now)
+        ordered = sorted(candidates, key=lambda record: self._score(record, strategy, now), reverse=True)
+        primary = ordered[0] if ordered else None
+        fallbacks = ordered[1:4]
+        if primary:
+            reason = self._decision_reason(primary, strategy, public_demo)
+            cost_hint = primary.cost_hint
+            quota_impact = self._quota_impact(primary, now)
+        else:
+            reason = "No eligible helper model for lane after budget, license, health, and quota filters."
+            cost_hint = "blocked"
+            quota_impact = {"status": "blocked"}
+
+        return LaneDecision(
+            lane=lane,
+            strategy=strategy,
+            primary=primary,
+            fallbacks=fallbacks,
+            reason=reason,
+            expected_cost_hint=cost_hint,
+            quota_impact=quota_impact,
+            context_packet=context,
+            skipped=skipped,
+        )
+
+    def record_success(self, model_id: str, latency_ms: int | None = None) -> None:
+        record = self._require_model(model_id)
+        now = self._now()
+        self._prune_calls(record, now)
+        record.minute_calls.append(now)
+        record.day_calls.append(now)
+        record.success_count += 1
+        record.last_failure = None
+        record.health = "healthy"
+        if latency_ms is not None:
+            record.latency_ms = int((record.latency_ms * 0.7) + (latency_ms * 0.3))
+
+    def record_failure(self, model_id: str, error: str = "execution failed") -> None:
+        record = self._require_model(model_id)
+        record.failure_count += 1
+        record.last_failure = error
+        record.health = "degraded" if record.failure_count < 3 else "unhealthy"
+        if record.failure_count >= 3:
+            self.enter_cooldown(model_id, retry_after_seconds=300)
+
+    def enter_cooldown(self, model_id: str, retry_after_seconds: int = 60) -> None:
+        record = self._require_model(model_id)
+        record.cooldown_until = self._now() + timedelta(seconds=retry_after_seconds)
+
+    def metadata_lookup(self, key: str, resolver: Callable[[], Any], ttl_seconds: int = 300) -> Any:
+        now = self._now()
+        cached = self._dedup.get(key)
+        if cached and cached.expires_at > now:
+            self._dedup_hits += 1
+            return cached.value
+        value = resolver()
+        self._dedup[key] = _DedupEntry(value=value, expires_at=now + timedelta(seconds=ttl_seconds))
+        return value
+
+    def get_rotation_status(self) -> dict[str, Any]:
+        now = self._now()
+        for record in self.records.values():
+            self._prune_calls(record, now)
+        pinned = {record.lane: record.to_dict(now) for record in self.records.values() if record.pinned}
+        lanes = {}
+        for lane in sorted(PINNED_LANES | ROTATABLE_LANES):
+            lane_records = [record for record in self.records.values() if record.lane == lane]
+            if not lane_records:
+                continue
+            blocked = [record for record in lane_records if self._quota_blocked(record, now) or record.in_cooldown(now)]
+            lanes[lane] = {
+                "pinned": lane in PINNED_LANES,
+                "models": len(lane_records),
+                "blocked": len(blocked),
+                "healthy": sum(1 for record in lane_records if record.health == "healthy"),
+            }
+        rotation_safe = all(record.health != "unhealthy" and not record.in_cooldown(now) for record in self.records.values() if record.pinned)
+        return {
+            "rotation_safe": rotation_safe,
+            "pinned": pinned,
+            "lanes": lanes,
+            "dedup_cache_size": len(self._dedup),
+            "dedup_hits": self._dedup_hits,
+            "updated_at": _iso(now),
+        }
+
+    def dashboard_snapshot(self, public_demo: bool = True) -> dict[str, Any]:
+        status = self.get_rotation_status()
+        preview_lanes = [
+            ("prompt_router", "strict tool JSON and prompt routing", "latency_first"),
+            ("taste_judge", "taste/profile checkpoint", "quality_first"),
+            ("audio_lore_tts", "optional lore narration, off by default", "license_safe_public" if public_demo else "quality_first"),
+            ("hf_catalog_research", "HF metadata search/cache", "quota_saver"),
+            ("modal_job_runner", "Modal credit jobs and LoRA evaluation", "private_research" if not public_demo else "license_safe_public"),
+        ]
+        status["decisions"] = [
+            self.select_lane(lane, task=task, public_demo=public_demo, strategy=strategy).to_dict(self._now())
+            for lane, task, strategy in preview_lanes
+        ]
+        return status
+
+    @staticmethod
+    def normalize_strategy(strategy: str) -> str:
+        lowered = strategy.strip().lower()
+        normalized = STRATEGY_ALIASES.get(lowered, lowered)
+        allowed = {"quality_first", "quota_saver", "latency_first", "license_safe_public", "private_research"}
+        return normalized if normalized in allowed else "quality_first"
+
+    @staticmethod
+    def normalize_lane(lane: str) -> str:
+        normalized = lane.strip().lower().replace("-", "_").replace(" ", "_")
+        aliases = {
+            "image": "image_generation",
+            "locate": "grounding",
+            "st3gg": "security",
+            "router": "prompt_router",
+            "judge": "taste_judge",
+            "tts": "audio_lore_tts",
+            "catalog": "hf_catalog_research",
+            "modal": "modal_job_runner",
+        }
+        return aliases.get(normalized, normalized)
+
+    def _eligible_records(
+        self,
+        records: list[ModelRecord],
+        budget_b: float,
+        public_demo: bool,
+        strategy: str,
+        now: datetime,
+    ) -> tuple[list[ModelRecord], list[str]]:
+        eligible: list[ModelRecord] = []
+        skipped: list[str] = []
+        require_public_safe = public_demo or strategy == "license_safe_public"
+        for record in records:
+            self._prune_calls(record, now)
+            if record.pinned:
+                skipped.append(f"{record.model_id}: pinned lane cannot rotate")
+                continue
+            if record.health in {"excluded", "unhealthy"}:
+                skipped.append(f"{record.model_id}: health={record.health}")
+                continue
+            if record.params_b > budget_b:
+                skipped.append(f"{record.model_id}: {record.params_b:.2f}B exceeds {budget_b:.2f}B helper budget")
+                continue
+            if require_public_safe and not record.public_safe:
+                skipped.append(f"{record.model_id}: license gate {record.license_gate} excluded for public demo")
+                continue
+            if record.in_cooldown(now):
+                skipped.append(f"{record.model_id}: cooldown active until {_iso(record.cooldown_until)}")
+                continue
+            if self._quota_blocked(record, now):
+                record.cooldown_until = now + timedelta(seconds=60)
+                skipped.append(f"{record.model_id}: quota exhausted, cooldown entered")
+                continue
+            eligible.append(record)
+        return eligible, skipped
+
+    def _score(self, record: ModelRecord, strategy: str, now: datetime) -> float:
+        rpm_headroom = 1.0 - (len(record.minute_calls) / max(record.rpm_limit, 1))
+        rpd_headroom = 1.0 - (len(record.day_calls) / max(record.rpd_limit, 1))
+        quota_headroom = max(0.0, (rpm_headroom + rpd_headroom) / 2)
+        latency_score = 1.0 / max(record.latency_ms, 1)
+        provider_bonus = 0.06 if record.provider in {"local", "hf_cli", "hf_api"} else 0.0
+        public_bonus = 0.08 if record.public_safe else 0.0
+        health_penalty = 0.12 if record.health == "degraded" else 0.0
+
+        if strategy == "quota_saver":
+            return (quota_headroom * 0.46) + (provider_bonus * 2.0) + (latency_score * 40.0) + (record.quality_score * 0.18) - health_penalty
+        if strategy == "latency_first":
+            return (latency_score * 250.0) + (record.quality_score * 0.28) + (quota_headroom * 0.20) + provider_bonus - health_penalty
+        if strategy == "license_safe_public":
+            return (public_bonus * 2.0) + (record.quality_score * 0.55) + (quota_headroom * 0.25) + (latency_score * 40.0) - health_penalty
+        if strategy == "private_research":
+            private_bonus = 0.06 if record.license_gate in PRIVATE_LICENSES else 0.0
+            return (record.quality_score * 0.88) + (quota_headroom * 0.10) + (latency_score * 5.0) + private_bonus - health_penalty
+        return (record.quality_score * 0.64) + (quota_headroom * 0.20) + (latency_score * 30.0) + public_bonus - health_penalty
+
+    def _decision_reason(self, primary: ModelRecord, strategy: str, public_demo: bool) -> str:
+        if strategy == "license_safe_public":
+            return f"{primary.model_id} selected because it is public-demo safe and within helper budget."
+        if strategy == "quota_saver":
+            return f"{primary.model_id} selected to preserve provider quota and reuse cheaper metadata paths."
+        if strategy == "latency_first":
+            return f"{primary.model_id} selected for fast dashboard feedback."
+        if strategy == "private_research" and not public_demo:
+            return f"{primary.model_id} selected for private research quality; public export gates still apply."
+        return f"{primary.model_id} selected by quality-first helper rotation."
+
+    def _quota_impact(self, record: ModelRecord | None, now: datetime) -> dict[str, Any]:
+        if record is None:
+            return {"status": "blocked"}
+        self._prune_calls(record, now)
+        return {
+            "status": "ready" if not self._quota_blocked(record, now) and not record.in_cooldown(now) else "limited",
+            "provider": record.provider,
+            "rpm_used": len(record.minute_calls),
+            "rpm_limit": record.rpm_limit,
+            "rpd_used": len(record.day_calls),
+            "rpd_limit": record.rpd_limit,
+            "cooldown_until": _iso(record.cooldown_until),
+        }
+
+    def _quota_blocked(self, record: ModelRecord, now: datetime) -> bool:
+        self._prune_calls(record, now)
+        return len(record.minute_calls) >= record.rpm_limit or len(record.day_calls) >= record.rpd_limit
+
+    def _prune_calls(self, record: ModelRecord, now: datetime) -> None:
+        minute_cutoff = now - timedelta(minutes=1)
+        day_cutoff = now - timedelta(days=1)
+        record.minute_calls = [stamp for stamp in record.minute_calls if stamp > minute_cutoff]
+        record.day_calls = [stamp for stamp in record.day_calls if stamp > day_cutoff]
+        if record.cooldown_until and record.cooldown_until <= now:
+            record.cooldown_until = None
+
+    def _require_model(self, model_id: str) -> ModelRecord:
+        try:
+            return self.records[model_id]
+        except KeyError as exc:
+            raise KeyError(f"Unknown model_id: {model_id}") from exc
+
+    def _now(self) -> datetime:
+        value = self._now_fn()
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value
+
+
+def default_model_records() -> list[ModelRecord]:
+    return [
+        ModelRecord(
+            model_id="flux2-klein-primary",
+            lane="image_generation",
+            provider="hf",
+            repo_id="black-forest-labs/FLUX.2-klein-9B",
+            license_gate="review_required",
+            params_b=9.0,
+            cost_hint="provider_or_local",
+            rpm_limit=8,
+            rpd_limit=60,
+            quality_score=0.96,
+            latency_ms=26000,
+            pinned=True,
+        ),
+        ModelRecord(
+            model_id="locateanything-3b-anchor",
+            lane="grounding",
+            provider="hf_nvidia",
+            repo_id="nvidia/LocateAnything-3B",
+            license_gate="review_required",
+            params_b=3.83,
+            cost_hint="provider_or_local",
+            rpm_limit=30,
+            rpd_limit=300,
+            quality_score=0.92,
+            latency_ms=1800,
+            pinned=True,
+        ),
+        ModelRecord(
+            model_id="st3gg-local-scan",
+            lane="security",
+            provider="local",
+            repo_id="ST3GG/local-defensive-scan",
+            license_gate="internal",
+            params_b=0.0,
+            cost_hint="local",
+            rpm_limit=10000,
+            rpd_limit=100000,
+            quality_score=0.9,
+            latency_ms=20,
+            pinned=True,
+        ),
+        ModelRecord(
+            model_id="functiongemma-270m-router",
+            lane="prompt_router",
+            provider="local",
+            repo_id="onnx-community/functiongemma-270m-it-ONNX",
+            license_gate="gemma",
+            params_b=0.27,
+            cost_hint="local_free",
+            rpm_limit=240,
+            rpd_limit=10000,
+            quality_score=0.74,
+            latency_ms=80,
+            fallback_chain=("minicpm5-1b-router", "qwen3-0.6b-router"),
+        ),
+        ModelRecord(
+            model_id="minicpm5-1b-router",
+            lane="prompt_router",
+            provider="hf",
+            repo_id="openbmb/MiniCPM5-1B",
+            license_gate="apache-2.0",
+            params_b=1.08,
+            cost_hint="free_tier",
+            rpm_limit=60,
+            rpd_limit=1000,
+            quality_score=0.79,
+            latency_ms=160,
+            fallback_chain=("functiongemma-270m-router", "qwen3-0.6b-router"),
+        ),
+        ModelRecord(
+            model_id="qwen3-0.6b-router",
+            lane="prompt_router",
+            provider="hf",
+            repo_id="Qwen/Qwen3-0.6B",
+            license_gate="apache-2.0",
+            params_b=0.60,
+            cost_hint="free_tier",
+            rpm_limit=60,
+            rpd_limit=1000,
+            quality_score=0.72,
+            latency_ms=130,
+        ),
+        ModelRecord(
+            model_id="netlify-ai-gateway-helper",
+            lane="prompt_router",
+            provider="netlify",
+            repo_id="netlify/ai-gateway",
+            license_gate="public_safe",
+            params_b=0.0,
+            cost_hint="optional_gateway_secret_required",
+            rpm_limit=0,
+            rpd_limit=0,
+            quality_score=0.76,
+            latency_ms=320,
+            health="excluded",
+        ),
+        ModelRecord(
+            model_id="cloudflare-agent-helper",
+            lane="prompt_router",
+            provider="cloudflare",
+            repo_id="cloudflare/agents-sdk",
+            license_gate="public_safe",
+            params_b=0.0,
+            cost_hint="optional_post_mvp_agent",
+            rpm_limit=0,
+            rpd_limit=0,
+            quality_score=0.72,
+            latency_ms=280,
+            health="excluded",
+        ),
+        ModelRecord(
+            model_id="offellia-gemma4-12b-private",
+            lane="taste_judge",
+            provider="local",
+            repo_id="Brunobkr/OFFELLIA_Q4_0_gemma-4-12B-it.gguf",
+            license_gate="private_research",
+            params_b=12.0,
+            cost_hint="local_gpu",
+            rpm_limit=20,
+            rpd_limit=200,
+            quality_score=0.95,
+            latency_ms=4200,
+            fallback_chain=("nemotron-mini-4b-judge", "smolvlm2-2.2b-judge"),
+        ),
+        ModelRecord(
+            model_id="nemotron-mini-4b-judge",
+            lane="taste_judge",
+            provider="hf_nvidia",
+            repo_id="nvidia/Nemotron-Mini-4B-Instruct",
+            license_gate="public_safe",
+            params_b=4.0,
+            cost_hint="free_tier_or_provider",
+            rpm_limit=35,
+            rpd_limit=600,
+            quality_score=0.86,
+            latency_ms=900,
+            fallback_chain=("smolvlm2-2.2b-judge", "functiongemma-270m-judge-lite"),
+        ),
+        ModelRecord(
+            model_id="smolvlm2-2.2b-judge",
+            lane="taste_judge",
+            provider="hf",
+            repo_id="HuggingFaceTB/SmolVLM2-2.2B-Instruct",
+            license_gate="apache-2.0",
+            params_b=2.2,
+            cost_hint="free_tier",
+            rpm_limit=45,
+            rpd_limit=800,
+            quality_score=0.81,
+            latency_ms=760,
+        ),
+        ModelRecord(
+            model_id="functiongemma-270m-judge-lite",
+            lane="taste_judge",
+            provider="local",
+            repo_id="onnx-community/functiongemma-270m-it-ONNX",
+            license_gate="gemma",
+            params_b=0.27,
+            cost_hint="local_free",
+            rpm_limit=240,
+            rpd_limit=10000,
+            quality_score=0.64,
+            latency_ms=90,
+        ),
+        ModelRecord(
+            model_id="dia-1.6b-tts",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="nari-labs/Dia-1.6B",
+            license_gate="review_required",
+            params_b=1.6,
+            cost_hint="free_tier_or_modal",
+            rpm_limit=25,
+            rpd_limit=300,
+            quality_score=0.88,
+            latency_ms=2100,
+        ),
+        ModelRecord(
+            model_id="vibevoice-1.5b-tts",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="microsoft/VibeVoice-1.5B",
+            license_gate="review_required",
+            params_b=1.5,
+            cost_hint="free_tier_or_modal",
+            rpm_limit=25,
+            rpd_limit=300,
+            quality_score=0.85,
+            latency_ms=1900,
+        ),
+        ModelRecord(
+            model_id="qwen3-tts-1.7b",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="Qwen/Qwen3-TTS-1.7B",
+            license_gate="review_required",
+            params_b=1.7,
+            cost_hint="free_tier_or_modal",
+            rpm_limit=25,
+            rpd_limit=300,
+            quality_score=0.84,
+            latency_ms=1800,
+        ),
+        ModelRecord(
+            model_id="voxcpm2-tts",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="openbmb/VoxCPM2",
+            license_gate="apache-2.0",
+            params_b=2.4,
+            cost_hint="free_tier_or_modal",
+            rpm_limit=25,
+            rpd_limit=300,
+            quality_score=0.82,
+            latency_ms=1700,
+        ),
+        ModelRecord(
+            model_id="zonos-tts",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="Zyphra/Zonos-v0.1-transformer",
+            license_gate="apache-2.0",
+            params_b=1.6,
+            cost_hint="free_tier_or_modal",
+            rpm_limit=25,
+            rpd_limit=300,
+            quality_score=0.81,
+            latency_ms=1600,
+        ),
+        ModelRecord(
+            model_id="kokoro-82m-tts",
+            lane="audio_lore_tts",
+            provider="local",
+            repo_id="hexgrad/Kokoro-82M",
+            license_gate="apache-2.0",
+            params_b=0.082,
+            cost_hint="local_free",
+            rpm_limit=240,
+            rpd_limit=10000,
+            quality_score=0.73,
+            latency_ms=120,
+        ),
+        ModelRecord(
+            model_id="chatterbox-tts",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="ResembleAI/chatterbox",
+            license_gate="mit",
+            params_b=0.5,
+            cost_hint="free_tier",
+            rpm_limit=40,
+            rpd_limit=800,
+            quality_score=0.76,
+            latency_ms=420,
+        ),
+        ModelRecord(
+            model_id="higgs-audio-v3-excluded",
+            lane="audio_lore_tts",
+            provider="hf",
+            repo_id="bosonai/higgs-audio-v3",
+            license_gate="commercial_required",
+            params_b=4.0,
+            cost_hint="paid_or_uncleared",
+            rpm_limit=0,
+            rpd_limit=0,
+            quality_score=0.89,
+            latency_ms=1800,
+            health="excluded",
+        ),
+        ModelRecord(
+            model_id="netflix-void-modal",
+            lane="video_repair",
+            provider="modal",
+            repo_id="Netflix/VOID",
+            license_gate="private_research",
+            params_b=1.3,
+            cost_hint="modal_credits",
+            rpm_limit=10,
+            rpd_limit=120,
+            quality_score=0.84,
+            latency_ms=12000,
+            fallback_chain=("void-q5-offline",),
+        ),
+        ModelRecord(
+            model_id="void-q5-offline",
+            lane="video_repair",
+            provider="local",
+            repo_id="local/VOID-Q5-video-repair",
+            license_gate="private_research",
+            params_b=1.3,
+            cost_hint="offline",
+            rpm_limit=20,
+            rpd_limit=200,
+            quality_score=0.78,
+            latency_ms=16000,
+        ),
+        ModelRecord(
+            model_id="fal-media-adapter",
+            lane="video_repair",
+            provider="fal",
+            repo_id="fal-ai/optional-media-generation",
+            license_gate="commercial_required",
+            params_b=0.0,
+            cost_hint="optional_external_provider",
+            rpm_limit=0,
+            rpd_limit=0,
+            quality_score=0.8,
+            latency_ms=6000,
+            health="excluded",
+        ),
+        ModelRecord(
+            model_id="hf-api-metadata-cache",
+            lane="hf_catalog_research",
+            provider="hf_api",
+            repo_id="huggingface/hub-api",
+            license_gate="public_safe",
+            params_b=0.0,
+            cost_hint="free_tier_cached",
+            rpm_limit=180,
+            rpd_limit=3000,
+            quality_score=0.86,
+            latency_ms=240,
+            fallback_chain=("hf-cli-model-search", "local-catalog-cache"),
+        ),
+        ModelRecord(
+            model_id="hf-cli-model-search",
+            lane="hf_catalog_research",
+            provider="hf_cli",
+            repo_id="huggingface/hub-cli",
+            license_gate="public_safe",
+            params_b=0.0,
+            cost_hint="free_tier_cli",
+            rpm_limit=60,
+            rpd_limit=1000,
+            quality_score=0.84,
+            latency_ms=600,
+        ),
+        ModelRecord(
+            model_id="local-catalog-cache",
+            lane="hf_catalog_research",
+            provider="local",
+            repo_id="local/nexus-weaver-catalog-cache",
+            license_gate="public_safe",
+            params_b=0.0,
+            cost_hint="local_cache",
+            rpm_limit=10000,
+            rpd_limit=100000,
+            quality_score=0.65,
+            latency_ms=6,
+        ),
+        ModelRecord(
+            model_id="modal-lora-eval-runner",
+            lane="modal_job_runner",
+            provider="modal",
+            repo_id="modal/nexus-lora-eval",
+            license_gate="private_research",
+            params_b=0.0,
+            cost_hint="modal_251_credit",
+            rpm_limit=20,
+            rpd_limit=180,
+            quality_score=0.87,
+            latency_ms=30000,
+            fallback_chain=("modal-dry-run-planner",),
+        ),
+        ModelRecord(
+            model_id="modal-video-repair-batch",
+            lane="modal_job_runner",
+            provider="modal",
+            repo_id="modal/nexus-video-repair-batch",
+            license_gate="private_research",
+            params_b=0.0,
+            cost_hint="modal_251_credit",
+            rpm_limit=10,
+            rpd_limit=80,
+            quality_score=0.82,
+            latency_ms=45000,
+        ),
+        ModelRecord(
+            model_id="modal-dry-run-planner",
+            lane="modal_job_runner",
+            provider="local",
+            repo_id="local/modal-job-dry-run",
+            license_gate="public_safe",
+            params_b=0.0,
+            cost_hint="local_free",
+            rpm_limit=10000,
+            rpd_limit=100000,
+            quality_score=0.58,
+            latency_ms=12,
+        ),
+    ]

src/nexus_visual_weaver/planner.py

@@ -0,0 +1,55 @@
+"""High-level command-center orchestration."""
+
+from __future__ import annotations
+
+from uuid import uuid4
+
+from .catalog import ADAPTER_CATALOG, active_stack
+from .grounding import inspect_outfit
+from .lore import build_lore_beats, build_video_plan
+from .schema import CreativeRequest, GenerationRun, HumanCheckpoint
+from .taste import refine_prompt
+from .wardrobe import build_outfit_graph
+
+
+def build_command_center_run(
+    prompt: str,
+    mode: str = "Strict",
+    video_preset: str = "Wan2.2 I2V",
+    adult_mode: bool = False,
+) -> GenerationRun:
+    request = CreativeRequest(prompt=prompt, adult_mode=adult_mode)
+    refined = refine_prompt(prompt, adult_mode=adult_mode)
+    outfit = build_outfit_graph(refined.refined, adult_mode=adult_mode)
+    inspection = inspect_outfit(outfit)
+    lore = build_lore_beats(refined.refined)
+    video = build_video_plan(video_preset)
+    stack = active_stack(adult_mode)
+    adapters = [adapter for adapter in ADAPTER_CATALOG if adult_mode or not adapter.adult_only][:4]
+    trust_score = round((refined.score + outfit.score + (0.86 if inspection.status == "pass" else 0.72)) / 3, 2)
+    required_actions = []
+    if adult_mode:
+        required_actions.append("Confirm 18+ session scope and keep exports partitioned")
+    if inspection.drift_flags:
+        required_actions.extend(inspection.drift_flags)
+    if mode.lower().startswith("frontier"):
+        required_actions.append("Frontier mode requires human checkpoint before video render")
+
+    checkpoint = HumanCheckpoint(
+        checkpoint_id=f"nw-{uuid4().hex[:8]}",
+        recommendation="approve_candidate" if trust_score >= 0.78 else "revise_before_generation",
+        trust_score=trust_score,
+        required_actions=required_actions or ["Review candidate thumbnails before promotion"],
+    )
+    return GenerationRun(
+        request=request,
+        refined_prompt=refined,
+        outfit=outfit,
+        model_stack=stack,
+        adapters=adapters,
+        inspection=inspection,
+        lore=lore,
+        video=video,
+        checkpoint=checkpoint,
+    )
+

src/nexus_visual_weaver/render.py

@@ -0,0 +1,681 @@
+"""HTML rendering helpers for the Gradio command center."""
+
+from __future__ import annotations
+
+import os
+from html import escape
+
+from .catalog import catalog_summary, parameter_budget
+from .schema import GenerationRun
+from .workflow import WorkflowState
+
+
+def badge(label: str, tone: str = "neutral") -> str:
+    return f'<span class="nw-badge nw-{tone}">{escape(label)}</span>'
+
+
+def icon(name: str) -> str:
+    paths = {
+        "forge": '<path d="M12 2l2.2 5.1L19 9.1l-4.8 2L12 16l-2.2-4.9L5 9.1l4.8-2L12 2z"/><path d="M4 14l1.3 3L8 18.2l-2.7 1.1L4 22l-1.3-2.7L0 18.2 2.7 17 4 14z" transform="translate(2 -1)"/>',
+        "wardrobe": '<path d="M9 3h6l1.5 3 3 1.5-2 4.5-2.5-1.1V21H9V10.9L6.5 12l-2-4.5 3-1.5L9 3z"/><path d="M9 3c.5 1.5 1.5 2.3 3 2.3S14.5 4.5 15 3"/>',
+        "lore": '<path d="M5 4h10a4 4 0 014 4v12H8a3 3 0 00-3-3V4z"/><path d="M5 17a3 3 0 013-3h11"/><path d="M9 8h6M9 11h5"/>',
+        "models": '<path d="M12 2l8 4.6v9.2L12 20.5l-8-4.7V6.6L12 2z"/><path d="M4 6.6l8 4.6 8-4.6M12 11.2v9.3"/>',
+        "security": '<path d="M12 2l8 3v6c0 5-3.4 9.2-8 11-4.6-1.8-8-6-8-11V5l8-3z"/><path d="M8.5 12l2.2 2.2 4.8-5"/>',
+        "runs": '<path d="M6 4h12v16H6z"/><path d="M9 8h6M9 12h6M9 16h3"/>',
+        "zoom": '<circle cx="10" cy="10" r="5"/><path d="M14 14l5 5M10 7v6M7 10h6"/>',
+        "frame": '<path d="M4 9V4h5M15 4h5v5M20 15v5h-5M9 20H4v-5"/>',
+        "lock": '<rect x="5" y="10" width="14" height="10" rx="2"/><path d="M8 10V7a4 4 0 018 0v3"/>',
+        "dot": '<circle cx="12" cy="12" r="5"/>',
+    }
+    return f'<svg class="nw-icon" viewBox="0 0 24 24" aria-hidden="true">{paths.get(name, paths["dot"])}</svg>'
+
+
+def _metric(label: str, value: str, tone: str = "neutral") -> str:
+    return f'<div class="nw-metric nw-metric-{tone}"><small>{escape(label)}</small><strong>{escape(value)}</strong></div>'
+
+
+def _env_configured(*names: str) -> bool:
+    return any(bool(os.environ.get(name)) for name in names)
+
+
+def _space_runtime_status() -> dict[str, str]:
+    space_id = os.environ.get("SPACE_ID") or os.environ.get("HF_SPACE_ID") or "local-preview"
+    hardware = os.environ.get("SPACE_HARDWARE") or os.environ.get("NEXUS_SPACE_HARDWARE") or "ZeroGPU"
+    bucket = "/data mounted" if os.path.isdir("/data") else "bucket optional"
+    secrets = "providers configured" if _env_configured("FAL_KEY", "NETLIFY_AUTH_TOKEN", "OPENAI_API_KEY", "MODAL_TOKEN_ID") else "no provider secrets"
+    return {
+        "space_id": space_id,
+        "hardware": hardware,
+        "bucket": bucket,
+        "secrets": secrets,
+    }
+
+
+def render_command_header() -> str:
+    return f"""
+    <section class="nw-command-header">
+      <div>
+        <small>COMMAND INPUT</small>
+        <strong>Raven Chronicle Active Weave</strong>
+        <span>Prompt, reference scan, model route, and checkpoint controls stay in one sticky operator strip.</span>
+      </div>
+      <div class="nw-command-pills">
+        {badge("SFW DEFAULT", "pass")}
+        {badge("ST3GG ALWAYS ON", "cyan")}
+        {badge("FLUX.2 PINNED", "accent")}
+        {badge("HUMAN CHECKPOINT", "warn")}
+      </div>
+    </section>
+    """
+
+
+def render_topbar(adult_mode: bool = False, relay_status: dict | None = None) -> str:
+    summary = catalog_summary(adult_mode)
+    active = float(summary["active_b"])
+    pct = max(0, min(100, int((active / 32.0) * 100)))
+    adult_label = "ON - research partition" if adult_mode else "OFF"
+    relay_status = relay_status or {}
+    rotation_safe = bool(relay_status.get("rotation_safe", True))
+    relay_label = "Rotation Safe" if rotation_safe else "Rotation Limited"
+    relay_tone = "pass" if rotation_safe else "warn"
+    space = _space_runtime_status()
+    return f"""
+    <div class="nw-topbar">
+      <div class="nw-brand"><span>NEXUS</span><strong>Visual Weaver</strong></div>
+      <div class="nw-topitem"><small>Project</small><strong>Raven Chronicle</strong><i></i></div>
+      <div class="nw-topitem"><small>Active Preset</small><strong>Dark Couture v2.4</strong><i></i></div>
+      <div class="nw-budget">
+        <div><strong>32B Parameter Budget</strong><small>{active:.2f}B / 32B ({pct}%)</small></div>
+        <div class="nw-meter"><i style="width:{pct}%"></i></div>
+      </div>
+      <div class="nw-status"><span class="nw-live-dot"></span><strong>HF Connected</strong><small>Hugging Face</small></div>
+      <div class="nw-status nw-gmr"><small>HF / Modal / GMR</small>{badge(relay_label, relay_tone)}<small>Helper rotation only</small></div>
+      <div class="nw-status nw-space"><small>{escape(space["space_id"])}</small><strong>{escape(space["hardware"])}</strong><small>{escape(space["bucket"])} / {escape(space["secrets"])}</small></div>
+      <div class="nw-adult">
+        <strong>Adult Mode {icon("lock")}</strong>
+        <span class="nw-toggle {'is-on' if adult_mode else ''}"><i></i>{escape(adult_label)}</span>
+      </div>
+      <div class="nw-locked"><b>18+</b><span>Locked. Enable in Security with explicit justification.</span></div>
+    </div>
+    """
+
+
+def render_left_rail(active_section: str = "Forge") -> str:
+    items = [("Forge", "forge"), ("Wardrobe", "wardrobe"), ("Lore", "lore"), ("Models", "models"), ("Security", "security"), ("Runs", "runs")]
+    rows = "".join(
+        f'<div class="nw-rail-item {"active" if label == active_section else ""}">{icon(icon_name)}<span>{escape(label)}</span></div>'
+        for label, icon_name in items
+    )
+    return f"""
+    <nav class="nw-rail">
+      <div class="nw-rail-main">{rows}</div>
+      <div class="nw-rail-foot">
+        <div>{icon("security")}<strong>Security Guardian</strong><span>Active</span></div>
+        <div>{icon("lock")}<strong>ST3GG v2.3.1</strong><span>Always-on</span></div>
+      </div>
+    </nav>
+    """
+
+
+def render_command_rail(active_section: str = "Forge") -> str:
+    section = escape(active_section)
+    hints = {
+        "Forge": ("Active Weave", "Prompt, judge, locate, generate, checkpoint."),
+        "Wardrobe": ("Outfit Slots", "Materials, footwear, locks, reference regions."),
+        "Lore": ("Video Continuity", "Identity, garment meaning, scene motion."),
+        "Models": ("Relay Stack", "Pinned core plus quota-aware helper rotation."),
+        "Security": ("ST3GG Gate", "Scan, purify, provenance, export decision."),
+        "Runs": ("Run Ledger", "Checkpointed dry-runs and handoff packets."),
+    }
+    title, body = hints.get(active_section, hints["Forge"])
+    return f"""
+    <div class="nw-native-rail">
+      <strong>{escape(title)}</strong>
+      <span>{escape(body)}</span>
+      {badge(f"Selected: {section}", "muted")}
+    </div>
+    """
+
+
+def render_workflow(run: GenerationRun | None = None) -> str:
+    workflow = WorkflowState.default()
+    score = run.checkpoint.trust_score if run else 0.82
+    checkpoint_id = run.checkpoint.checkpoint_id if run else "nw-dry-run"
+    recommendation = run.checkpoint.recommendation.replace("_", " ").title() if run else "Awaiting Run"
+    required_actions = run.checkpoint.required_actions if run else ["Review candidate thumbnails before promotion"]
+    action_label = required_actions[0] if required_actions else "No action pending"
+    model_label = _short_repo(run.model_stack[0].repo_id) if run and run.model_stack else "FLUX.2"
+    locate_label = run.inspection.locate_model.split("/")[-1] if run else "LocateAnything-3B"
+    nodes = {
+        "seed": (35, 52, 190, 210, "Seed Prompt", ["Rogue archivist moving", "through rain-slick neon", "city, couture layers."], "Text-to-Image (FLUX.2)", "complete", "red"),
+        "refine": (275, 52, 185, 160, "Refine", ["Prompt Refiner", "Style Harmonizer", "Negative Purge"], "Qwen2.5-7B", "complete", "violet"),
+        "judge": (540, 52, 185, 160, "Judge", ["Aesthetic Scorer", "ST3GG Policy Filter", f"Score {score:.2f}"], "OFFELLIA / Gemma", "complete", "blue"),
+        "locate": (785, 52, 185, 160, "Locate", ["Reference Locator", "Pose & Composition", "IP-Adapter"], "Refs 3/5", "complete", "cyan"),
+        "generate": (275, 280, 235, 210, "Generate", ["Image / Video Generation", "FLUX.2 + adapter stack", "High-detail couture"], "Steps 30  CFG 7.5", "ready", "green"),
+        "video": (590, 280, 235, 210, "Video Path", ["Image to Video", "Frame interpolation", run.video.preset if run else "Wan2.2 / LTX swap"], "Duration 5.6s  24fps", "ready", "blue"),
+        "checkpoint": (880, 285, 185, 185, "Human Checkpoint", ["Human review required", "Verify intent, vibe,", "and output before final."], "Review Now", "paused", "amber"),
+    }
+    edges = [
+        ("seed", "refine"), ("refine", "judge"), ("judge", "locate"), ("locate", "video"),
+        ("refine", "generate"), ("generate", "video"), ("video", "checkpoint"), ("judge", "checkpoint"),
+    ]
+    lines = []
+    for source, target in edges:
+        x1, y1, w1, h1, *_ = nodes[source]
+        x2, y2, w2, h2, *_ = nodes[target]
+        y_offset = 76 if source in {"seed", "refine", "judge", "locate"} else 96
+        lines.append(
+            f'<path d="M{x1 + w1} {y1 + y_offset} C{x1 + w1 + 55} {y1 + y_offset}, {x2 - 55} {y2 + 76}, {x2} {y2 + 76}" />'
+        )
+    cards = []
+    for node_id, (x, y, width, height, title, body, footer, status, tone) in nodes.items():
+        body_lines = "".join(f'<text x="{x + 16}" y="{y + 74 + idx * 22}" class="nw-node-line">{escape(line)}</text>' for idx, line in enumerate(body))
+        thumb_strip = ""
+        if node_id in {"generate", "video"}:
+            thumbs = []
+            for idx in range(4):
+                tx = x + 16 + idx * 47
+                thumbs.append(
+                    f'<rect class="nw-thumb nw-thumb-{idx}" x="{tx}" y="{y + 112}" rx="4" width="39" height="52"></rect>'
+                )
+            thumb_strip = "".join(thumbs)
+        cards.append(
+            f"""
+            <g class="nw-node nw-node-{status} nw-node-{tone}">
+              <rect x="{x}" y="{y}" rx="9" width="{width}" height="{height}"></rect>
+              <text x="{x + 16}" y="{y + 31}" class="nw-node-title">{escape(title)}</text>
+              {body_lines}
+              {thumb_strip}
+              <line x1="{x + 16}" y1="{y + height - 48}" x2="{x + width - 16}" y2="{y + height - 48}" class="nw-node-sep" />
+              <text x="{x + 16}" y="{y + height - 20}" class="nw-node-footer">{escape(footer)}</text>
+              <circle cx="{x + width - 20}" cy="{y + height - 20}" r="5" class="nw-node-ok"></circle>
+            </g>
+            """
+        )
+    return f"""
+    <section class="nw-panel nw-canvas">
+      <div class="nw-panel-head nw-canvas-head">
+        <div><strong>Active Weave</strong><small><span class="nw-live-dot"></span> Live / Weave ID: 4f7c9e2b</small></div>
+        <div class="nw-tools nw-static-tools"><span>Layout Auto</span><span>{icon("zoom")}</span><span>{icon("frame")}</span></div>
+      </div>
+      <svg class="nw-graph" viewBox="0 0 1110 530" role="img" aria-label="NEXUS workflow graph">
+        <defs>
+          <pattern id="nw-grid" width="12" height="12" patternUnits="userSpaceOnUse">
+            <circle cx="1" cy="1" r="0.8" fill="#2d3944" />
+          </pattern>
+          <linearGradient id="nw-node-shine" x1="0" x2="1"><stop offset="0" stop-color="rgba(255,255,255,.07)" /><stop offset="1" stop-color="rgba(255,255,255,0)" /></linearGradient>
+        </defs>
+        <rect width="1110" height="530" fill="url(#nw-grid)"></rect>
+        <g class="nw-edges">{"".join(lines)}</g>
+        {"".join(cards)}
+      </svg>
+      <div class="nw-legend">
+        {badge("Text Flow", "accent")} {badge("Refine Loop", "violet")} {badge("Policy Gate", "blue")} {badge("Media Flow", "cyan")} {badge("Human Gate", "warn")}
+      </div>
+      <div class="nw-weave-console">
+        <div class="nw-console-card nw-console-primary">
+          <small>Selected Node</small>
+          <strong>Human Checkpoint</strong>
+          <span>{escape(recommendation)} / {escape(checkpoint_id)}</span>
+        </div>
+        <div class="nw-console-card">
+          <small>Next Operator Action</small>
+          <strong>{escape(action_label)}</strong>
+          <span>Checkpoint blocks video promotion until reviewed.</span>
+        </div>
+        <div class="nw-console-card">
+          <small>Pinned Model Lanes</small>
+          <strong>{escape(model_label)} + {escape(locate_label)} + ST3GG</strong>
+          <span>Core lanes stay fixed; helper lanes may rotate.</span>
+        </div>
+        <div class="nw-console-card">
+          <small>Hackathon Signal</small>
+          <strong>Workflow, governance, visual creation</strong>
+          <span>Judge view keeps product purpose visible without a landing page.</span>
+        </div>
+      </div>
+    </section>
+    """
+
+
+def render_artifact_lane(run: GenerationRun | None = None, scan: dict | None = None) -> str:
+    scan = scan or {"status": "idle", "export_gate": "pending"}
+    prompt_label = "Prompt proof"
+    outfit_label = "Outfit map"
+    locate_label = "Grounding overlay"
+    video_label = run.video.preset if run else "Video path"
+    active_prompt = run.refined_prompt.refined[:150] if run else "Awaiting first weave. The preview stage shows dry-run handoff packets until provider output exists."
+    checkpoint = getattr(run.checkpoint, "recommendation", "pending") if run else "pending"
+    demo_seed = (run.checkpoint.checkpoint_id[-4:] if run else "0000").upper()
+    artifacts = [
+        (prompt_label, "Taste-refined brief", "dry-run", "material-0", "01"),
+        (outfit_label, "Wardrobe slots and locks", "checkpointed", "material-1", "02"),
+        (locate_label, "LocateAnything region plan", "configured", "material-4", "03"),
+        (video_label, "Checkpointed storyboard", "blocked" if scan.get("export_gate") == "blocked" else "ready", "story-2", "04"),
+    ]
+    cards = "".join(
+        f"""
+        <div class="nw-artifact-card">
+          <small>{escape(index)}</small>
+          <i class="nw-{texture}"></i>
+          <strong>{escape(title)}</strong>
+          <span>{escape(body)}</span>
+          {badge(status.upper(), "warn" if status == "blocked" else "muted")}
+        </div>
+        """
+        for title, body, status, texture, index in artifacts
+    )
+    export_gate = str(scan.get("export_gate", "pending")).upper()
+    continuity = ", ".join(run.video.continuity_locks[:4]) if run else "outerwear, footwear, jewelry, NEXUS sigils"
+    return f"""
+    <section class="nw-panel nw-artifacts">
+      <div class="nw-panel-head">
+        <div><strong>Artifact Preview Lane</strong><small>Honest handoff packets until a provider call succeeds</small></div>
+        {badge(f"Export {export_gate}", "warn" if export_gate == "BLOCKED" else "pass" if export_gate == "CLEAR" else "muted")}
+      </div>
+      <div class="nw-preview-stage">
+        <div class="nw-preview-frame">
+          <i class="nw-preview-image"></i>
+          <div class="nw-preview-caption">
+            <small>PRIMARY OUTPUT STAGE / JUDGE-SAFE DEMO OUTPUT / SEED {escape(demo_seed)}</small>
+            <strong>Deterministic Raven Chronicle proof frame</strong>
+            <span>{escape(active_prompt)}</span>
+          </div>
+        </div>
+        <div class="nw-preview-meta">
+          <div><small>checkpoint</small><strong>{escape(str(checkpoint).replace("_", " ").title())}</strong></div>
+          <div><small>export gate</small><strong>{escape(export_gate)}</strong></div>
+          <div><small>preview mode</small><strong>Dry Run</strong></div>
+        </div>
+      </div>
+      <div class="nw-preview-ribbon">
+        <span>{icon("security")} ST3GG before export</span>
+        <span>{icon("wardrobe")} continuity: {escape(continuity)}</span>
+        <span>{icon("models")} provider call remains checkpointed; state: dry-run / configured / blocked / failed</span>
+      </div>
+      <div class="nw-artifact-grid">{cards}</div>
+    </section>
+    """
+
+
+def render_operations_panel(
+    active_section: str = "Forge",
+    run: GenerationRun | None = None,
+    scan: dict | None = None,
+    relay_status: dict | None = None,
+    *,
+    adult_mode: bool = False,
+) -> str:
+    scan = scan or {"status": "idle", "export_gate": "pending", "findings": []}
+    relay_status = relay_status or {}
+    section = active_section if active_section in {"Forge", "Wardrobe", "Lore", "Models", "Security", "Runs"} else "Forge"
+    checkpoint = getattr(run, "checkpoint", None) if run else None
+    outfit = getattr(run, "outfit", None) if run else None
+    lore = getattr(run, "lore", None) if run else None
+    run_id = getattr(checkpoint, "checkpoint_id", "not-started")
+    outfit_count = len(getattr(outfit, "slots", []) or [])
+    lore_count = len(getattr(lore, "beats", []) or [])
+    scan_status = str(scan.get("status", "idle")).upper()
+    export_gate = str(scan.get("export_gate", "pending")).upper()
+    decisions = relay_status.get("decisions", [])
+    first_decision = decisions[0] if decisions else {}
+    first_primary = (first_decision.get("primary") or {}) if first_decision else {}
+    adult_scope = "Private research scope" if adult_mode else "Public demo scope"
+    panels = {
+        "Forge": [
+            ("Prompt contract", "Taste-refined prompt, material locks, negative purge, and checkpoint requirements."),
+            ("Active run", f"{run_id} / checkpoint remains human-reviewed before video promotion."),
+            ("Provider posture", "Dry-run packets are visible before paid or gated calls."),
+        ],
+        "Wardrobe": [
+            ("Slot coverage", f"{outfit_count or 9} garment/accessory regions tracked with locks and edit priority."),
+            ("Footwear focus", "Platform boots, stilettos, high-heel boots, hardware, and silhouette constraints stay first-class."),
+            ("Locate map", "Reference regions feed preflight and post-generation outfit verification."),
+        ],
+        "Lore": [
+            ("Beat budget", f"{lore_count or 6} compact beats: identity, garment meaning, world context, emotion, motion."),
+            ("Video checkpoint", "Video presets remain handoff plans until human approval."),
+            ("Continuity locks", "Lore-to-video keeps garment meaning and motion cue visible without tab sprawl."),
+        ],
+        "Models": [
+            ("Primary helper", _short_repo(str(first_primary.get("repo_id", "pending")))),
+            ("Rotation mode", "Pinned core stays fixed; helper lanes rotate by license, budget, quota, and health."),
+            ("Scope", adult_scope),
+        ],
+        "Security": [
+            ("ST3GG state", f"{scan_status} / export {export_gate}"),
+            (
+                "Findings",
+                "; ".join(str(item) for item in (scan.get("findings") or [])[:2])
+                or ("No findings." if scan_status != "IDLE" else "No upload selected."),
+            ),
+            ("Public export", "Consent, provenance, metadata, age, dataset, and payload gates stay active."),
+        ],
+        "Runs": [
+            ("Current checkpoint", run_id),
+            ("Ledger mode", "Run JSON, catalog summary, and ST3GG evidence remain in the evidence accordion."),
+            ("Rollback path", "Feature branches and draft PRs carry implementation checkpoints."),
+        ],
+    }
+    rows = "".join(
+        f"""
+        <div class="nw-operation-card">
+          <small>{escape(title)}</small>
+          <strong>{escape(body)}</strong>
+          <i></i>
+        </div>
+        """
+        for title, body in panels[section]
+    )
+    return f"""
+    <section class="nw-panel nw-operations">
+      <div class="nw-panel-head">
+        <div><strong>{escape(section)} Operations</strong><small>Section-aware control surface for the selected command rail lane</small></div>
+        {badge(f"{escape(section).upper()} ACTIVE", "cyan")}
+      </div>
+      <div class="nw-operation-grid">{rows}</div>
+    </section>
+    """
+
+
+def _short_repo(repo_id: str) -> str:
+    return repo_id.split("/")[-1]
+
+
+def _render_relay_panel(relay_status: dict | None = None) -> str:
+    relay_status = relay_status or {}
+    pinned = relay_status.get("pinned", {})
+    decisions = relay_status.get("decisions", [])
+    pinned_labels = []
+    for lane in ["image_generation", "grounding", "security"]:
+        record = pinned.get(lane)
+        if record:
+            pinned_labels.append(_short_repo(record["repo_id"]))
+    pinned_rows = [
+        f"""
+        <li>
+          <span>pinned core</span>
+          <strong>{escape(" / ".join(pinned_labels[:3]) or "pending")}</strong>
+          <em>image, grounding, and security never rotate</em>
+        </li>
+        """
+    ]
+    decision_rows = []
+    for decision in decisions[:2]:
+        primary = decision.get("primary") or {}
+        fallbacks = decision.get("fallbacks") or []
+        fallback_label = ", ".join(_short_repo(item["repo_id"]) for item in fallbacks[:2]) or "none"
+        decision_rows.append(
+            f"""
+            <li>
+              <span>{escape(decision["lane"].replace("_", " "))}</span>
+              <strong>{escape(_short_repo(primary.get("repo_id", "blocked")))}</strong>
+              <em>{escape(decision["strategy"])} / fallback: {escape(fallback_label)}</em>
+            </li>
+            """
+        )
+    rows = "".join(pinned_rows + decision_rows)
+    if not rows:
+        rows = "<li><span>GMR</span><strong>snapshot pending</strong><em>relay idle</em></li>"
+    dedup_hits = relay_status.get("dedup_hits", 0)
+    return f"""
+    <h3>GMR ModelRelay</h3>
+    <ul class="nw-relay">{rows}</ul>
+    <div class="nw-relay-foot">
+      {badge("FLUX.2 pinned", "pass")} {badge("LocateAnything pinned", "pass")} {badge(f"dedup hits {dedup_hits}", "muted")}
+    </div>
+    """
+
+
+def render_provider_cards(relay_status: dict | None = None, adult_mode: bool = False) -> str:
+    relay_status = relay_status or {}
+    decisions = relay_status.get("decisions", [])
+    optional_statuses = {
+        "fal": "configured" if _env_configured("FAL_KEY") else "blocked",
+        "netlify": "configured" if _env_configured("NETLIFY_AUTH_TOKEN", "NETLIFY_SITE_ID", "OPENAI_BASE_URL") else "blocked",
+        "cloudflare": "configured" if _env_configured("CLOUDFLARE_API_TOKEN", "CF_ACCOUNT_ID") else "blocked",
+    }
+    cards = []
+    for decision in decisions[:5]:
+        primary = decision.get("primary") or {}
+        quota = decision.get("quota_impact") or {}
+        provider = primary.get("provider", "blocked")
+        repo = _short_repo(primary.get("repo_id", "blocked"))
+        lane = decision.get("lane", "helper").replace("_", " ")
+        status = quota.get("status", "blocked")
+        provider_state = "dry-run" if status == "ready" else "blocked" if status == "blocked" else "limited"
+        if provider in optional_statuses:
+            provider_state = optional_statuses[provider]
+        tone = "pass" if provider_state == "configured" else "warn" if provider_state in {"limited", "blocked", "failed"} else "muted"
+        gate = primary.get("license_gate", "unknown")
+        cards.append(
+            f"""
+            <div class="nw-provider-card">
+              <small>{escape(lane)}</small>
+              <strong>{escape(repo)}</strong>
+              <span>{escape(str(provider))} / {escape(str(gate))}</span>
+              <i class="nw-provider-meter" style="--health:{'86' if provider_state in {'configured', 'dry-run'} else '52' if provider_state == 'limited' else '22'}"></i>
+              <div>{badge(provider_state.upper(), tone)}{badge("CHECKPOINTED", "muted")}</div>
+            </div>
+            """
+        )
+    if not cards:
+        cards.append('<div class="nw-provider-card"><small>providers</small><strong>snapshot pending</strong><span>relay idle</span><div>{}</div></div>'.format(badge("DRY-RUN", "muted")))
+    for provider, state in optional_statuses.items():
+        cards.append(
+            f"""
+            <div class="nw-provider-card nw-provider-optional">
+              <small>optional gateway</small>
+              <strong>{escape(provider.title())}</strong>
+              <span>off by default / secrets required</span>
+              <i class="nw-provider-meter" style="--health:{'74' if state == 'configured' else '18'}"></i>
+              <div>{badge(state.upper(), "pass" if state == "configured" else "warn")}{badge("NOT MVP DEFAULT", "muted")}</div>
+            </div>
+            """
+        )
+    mode_label = "private research" if adult_mode else "public demo safe"
+    return f"""
+    <section class="nw-panel nw-providers">
+      <div class="nw-panel-head">
+        <div><strong>Provider Handoff Cards</strong><small>Configured as visible packets before any paid or gated call</small></div>
+        {badge(mode_label.upper(), "warn" if adult_mode else "pass")}
+      </div>
+      <div class="nw-provider-grid">{"".join(cards)}</div>
+    </section>
+    """
+
+
+def _scan_status_tone(scan_status: str) -> str:
+    if scan_status == "pass":
+        return "pass"
+    if scan_status in {"review", "error"}:
+        return "warn"
+    return "muted"
+
+
+def render_inspector(run: GenerationRun | None = None, scan: dict | None = None, relay_status: dict | None = None) -> str:
+    if run:
+        checks = [
+            ("Patent Leather", True),
+            ("Faux Fur", any(slot.material == "faux_fur" for slot in run.outfit.slots)),
+            ("Lace / Mesh", any("lace" in slot.material for slot in run.outfit.slots)),
+            ("Crimson Hardware", any(slot.material == "crimson_hardware" for slot in run.outfit.slots)),
+            ("Platform Boots", any(slot.name == "footwear" for slot in run.outfit.slots)),
+            ("Layered Garments", True),
+        ]
+        stack_label = " / ".join(_short_repo(model.repo_id) for model in run.model_stack[:3])
+        model_rows = f"<li><span>active stack</span><strong>{escape(stack_label)}</strong></li>"
+        score = int(run.checkpoint.trust_score * 100)
+        scan_status = (scan or {}).get("status", "pass")
+    else:
+        checks = [(label, True) for label in ["Patent Leather", "Faux Fur", "Lace / Mesh", "Crimson Hardware", "Platform Boots", "Layered Garments"]]
+        model_rows = "<li><span>active stack</span><strong>FLUX.2 / OFFELLIA / LocateAnything</strong></li>"
+        score = 86
+        scan_status = (scan or {}).get("status", "pass")
+    checks_html = "".join(f'<li><span>{"✓" if ok else "!"}</span>{escape(label)}</li>' for label, ok in checks)
+    relay = _render_relay_panel(relay_status)
+    scan = scan or {"status": scan_status, "findings": [], "purification_actions": [], "export_gate": "pending"}
+    findings = scan.get("findings") or []
+    actions = scan.get("purification_actions") or ["metadata strip ready", "IEND truncation ready", "LSB review ready"]
+    finding_rows = "".join(f"<li>{escape(str(item))}</li>" for item in findings[:4]) or "<li>No upload selected. Scanner ready.</li>"
+    action_rows = "".join(f"<li>{escape(str(item))}</li>" for item in actions[:4])
+    export_gate = str(scan.get("export_gate", "pending")).upper()
+    return f"""
+    <aside class="nw-panel nw-inspector">
+      <div class="nw-panel-head"><strong>Inspector</strong>{badge("Selected: Judge", "muted")}</div>
+      <h3>Taste Profile</h3>
+      <div class="nw-rings">
+        <div style="--v:{score};--ring:#f59e42"><b>{score}</b><small>Composition</small></div>
+        <div style="--v:82;--ring:#fb6b5f"><b>82</b><small>Color</small></div>
+        <div style="--v:79;--ring:#e86158"><b>79</b><small>Mood</small></div>
+        <div style="--v:91;--ring:#ec4899"><b>91</b><small>Cohesion</small></div>
+      </div>
+      <h3>Material Checklist</h3>
+      <ul class="nw-checks">{checks_html}</ul>
+      <h3>Model Stack</h3>
+      <ul class="nw-models">{model_rows}</ul>
+      <h3>ST3GG Scan</h3>
+      <div class="nw-scan">
+        <div>{badge(str(scan_status).upper(), _scan_status_tone(str(scan_status)))}<span>Always-on defensive review</span></div>
+        <i style="width:78%"></i>
+        <dl><dt>Policy</dt><dd>NEXUS Safe Policy v2.1</dd><dt>Purify</dt><dd>{escape(", ".join(str(item) for item in actions[:2]))}</dd><dt>Export</dt><dd>{escape(export_gate)}</dd></dl>
+        <ul class="nw-scan-list">{finding_rows}</ul>
+        <ul class="nw-scan-list nw-scan-actions">{action_rows}</ul>
+      </div>
+      {relay}
+    </aside>
+    """
+
+
+def render_drawer(run: GenerationRun | None = None) -> str:
+    if run:
+        slots = run.outfit.slots
+        beats = run.lore.beats
+    else:
+        slots = []
+        beats = []
+    slot_cards = "".join(
+        f"""
+        <div class="nw-swatch {'is-locked' if slot.locked else ''}">
+          <i class="nw-material-{idx % 6}"></i><strong>{escape(slot.name.replace("_", " ").title())}</strong>
+          <small>{escape(slot.material.replace("_", " "))}</small>
+          <span>{'locked' if slot.locked else 'editable'} / p{slot.edit_priority}</span>
+        </div>
+        """
+        for idx, slot in enumerate(slots[:8])
+    )
+    if not slot_cards:
+        slot_cards = "".join(
+            f'<div class="nw-swatch"><i class="nw-material-{idx % 6}"></i><strong>{label}</strong><small>{mat}</small><span>editable / p{5 - idx // 2}</span></div>'
+            for idx, (label, mat) in enumerate([
+                ("Patent Leather", "jet black"), ("Faux Fur", "ash gray"), ("Lace Mesh", "noir"),
+                ("Crimson Hardware", "polished"), ("Platform Boots", "matte black"), ("Long Coat", "wool blend"),
+            ])
+        )
+    beat_cards = "".join(
+        f'<div class="nw-beat"><i class="nw-story-{idx % 6}"></i><strong>{escape(beat["id"])} {escape(beat["title"])}</strong><small>{escape(beat["cue"][:80])}</small><span class="nw-mini-chip">checkpointed</span></div>'
+        for idx, beat in enumerate(beats[:6])
+    )
+    if not beat_cards:
+        beat_cards = "".join(f'<div class="nw-beat"><i class="nw-story-{i % 6}"></i><strong>0{i} Beat</strong><small>Scene continuity cue</small><span class="nw-mini-chip">checkpointed</span></div>' for i in range(1, 7))
+    return f"""
+    <section class="nw-bottom">
+      <div class="nw-panel nw-wardrobe">
+        <div class="nw-panel-head"><div><strong>Outfit Wardrobe</strong><small>Couture slots, locks, LocateAnything regions, and edit priority</small></div><span class="nw-chip">All Categories</span></div>
+        <div class="nw-filter-row"><span>All</span><span>Patent</span><span>Lace</span><span>Hardware</span><span>Boots / heels</span><span>Outerwear</span><span>Props</span></div>
+        <div class="nw-swatches">{slot_cards}</div>
+      </div>
+      <div class="nw-panel nw-lore">
+        <div class="nw-panel-head"><div><strong>Lore-to-Video Timeline</strong><small>Identity, garment meaning, motion cue, and video checkpoint path</small></div><div class="nw-tools nw-static-tools"><span>6 Beats</span><span>24 FPS</span></div></div>
+        <div class="nw-beats">{beat_cards}</div>
+      </div>
+    </section>
+    """
+
+
+def render_status_bar() -> str:
+    space = _space_runtime_status()
+    return f"""
+    <footer class="nw-statusbar">
+      {_metric("Runs", "112")}
+      {_metric("Queue", "2")}
+      {_metric("GPU", "46%", "bar")}
+      {_metric("VRAM", "18.2 / 40 GB", "bar")}
+      {_metric("Temp", "62 C")}
+      {_metric("HF Space", space["hardware"])}
+      <div class="nw-autosave"><span class="nw-live-dot"></span><strong>Auto-save</strong><small>On</small></div>
+      <div class="nw-stop nw-stop-idle">No live provider job</div>
+    </footer>
+    """
+
+
+def render_catalog_table(adult_mode: bool = False) -> str:
+    from .catalog import filter_catalog
+
+    models, adapters = filter_catalog(adult_mode)
+    model_rows = "".join(
+        f"<tr><td>{escape(model.repo_id)}</td><td>{escape(model.role)}</td><td>{model.params_b:.2f}B</td><td>{escape(model.license)}</td><td>{'18+' if model.adult_only else 'General'}</td></tr>"
+        for model in models
+    )
+    adapter_rows = "".join(
+        f"<tr><td>{escape(adapter.repo_id)}</td><td>{escape(adapter.adapter_for)}</td><td>{escape(adapter.task)}</td><td>{'18+' if adapter.adult_only else 'General'}</td></tr>"
+        for adapter in adapters
+    )
+    return f"""
+    <div class="nw-catalog">
+      <h3>HF Model Catalog</h3>
+      <table><thead><tr><th>Repo</th><th>Role</th><th>Params</th><th>License</th><th>Scope</th></tr></thead><tbody>{model_rows}</tbody></table>
+      <h3>LoRA / Adapter Shelf</h3>
+      <table><thead><tr><th>Repo</th><th>Adapter For</th><th>Task</th><th>Scope</th></tr></thead><tbody>{adapter_rows}</tbody></table>
+    </div>
+    """
+
+
+def render_dashboard(
+    run: GenerationRun | None = None,
+    adult_mode: bool = False,
+    scan: dict | None = None,
+    relay_status: dict | None = None,
+    active_section: str = "Forge",
+) -> str:
+    regions = render_dashboard_regions(run, adult_mode, scan, relay_status, active_section)
+    return f"""
+    <div class="nw-app">
+      {regions["topbar"]}
+      <div class="nw-shell">
+        {regions["rail"]}
+        <div class="nw-main-stack">
+          {regions["workflow"]}
+          {regions["operations"]}
+          {regions["artifacts"]}
+        </div>
+        <div class="nw-side-stack">
+          {regions["inspector"]}
+          {regions["providers"]}
+        </div>
+        {regions["drawer"]}
+      </div>
+      {regions["status"]}
+    </div>
+    """
+
+
+def render_dashboard_regions(
+    run: GenerationRun | None = None,
+    adult_mode: bool = False,
+    scan: dict | None = None,
+    relay_status: dict | None = None,
+    active_section: str = "Forge",
+) -> dict[str, str]:
+    return {
+        "topbar": render_topbar(adult_mode, relay_status),
+        "rail": render_left_rail(active_section),
+        "command_rail": render_command_rail(active_section),
+        "workflow": render_workflow(run),
+        "operations": render_operations_panel(active_section, run, scan, relay_status, adult_mode=adult_mode),
+        "inspector": render_inspector(run, scan, relay_status),
+        "drawer": render_drawer(run),
+        "status": render_status_bar(),
+        "artifacts": render_artifact_lane(run, scan),
+        "providers": render_provider_cards(relay_status, adult_mode),
+    }

src/nexus_visual_weaver/schema.py

@@ -0,0 +1,153 @@
+"""Typed data surfaces for the NEXUS Visual Weaver dashboard."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+@dataclass(frozen=True)
+class CreativeRequest:
+    prompt: str
+    output_goal: str = "image_to_video"
+    adult_mode: bool = False
+    references: list[str] = field(default_factory=list)
+    created_at: str = field(default_factory=utc_now)
+
+
+@dataclass(frozen=True)
+class TasteProfile:
+    version: str
+    locked_features: dict[str, Any]
+    must_include: list[str]
+    should_include: list[str]
+    forbidden: list[str]
+
+
+@dataclass(frozen=True)
+class TasteRefinedPrompt:
+    original: str
+    refined: str
+    additions: list[str]
+    score: float
+    missing_features: list[str]
+
+
+@dataclass(frozen=True)
+class WardrobeSlot:
+    name: str
+    description: str
+    material: str
+    palette: str
+    lora_hint: str
+    locked: bool = False
+    adult_only: bool = False
+    locate_region: str = "pending"
+    edit_priority: int = 3
+
+
+@dataclass(frozen=True)
+class OutfitGraph:
+    slots: list[WardrobeSlot]
+    score: float
+
+    @property
+    def locked_count(self) -> int:
+        return sum(1 for slot in self.slots if slot.locked)
+
+
+@dataclass(frozen=True)
+class ModelCandidate:
+    repo_id: str
+    role: str
+    task: str
+    params_b: float
+    runtime: str
+    license: str
+    gated: bool = False
+    adult_only: bool = False
+    source_url: str = ""
+
+
+@dataclass(frozen=True)
+class AdapterRecipe:
+    repo_id: str
+    adapter_for: str
+    task: str
+    weight: float = 0.75
+    license: str = "unknown"
+    adult_only: bool = False
+    compatibility: str = "compatible"
+
+
+@dataclass(frozen=True)
+class GroundingTarget:
+    slot_name: str
+    query: str
+    expected_region: str
+    confidence: float
+
+
+@dataclass(frozen=True)
+class InspectionReport:
+    status: str
+    targets: list[GroundingTarget]
+    drift_flags: list[str]
+    locate_model: str = "nvidia/LocateAnything-3B"
+
+
+@dataclass(frozen=True)
+class LoreBeatSet:
+    beats: list[dict[str, str]]
+    tone: str
+
+
+@dataclass(frozen=True)
+class VideoPlan:
+    preset: str
+    source: str
+    camera_move: str
+    duration_seconds: float
+    fps: int
+    continuity_locks: list[str]
+    checkpoint_required: bool = True
+
+
+@dataclass(frozen=True)
+class HumanCheckpoint:
+    checkpoint_id: str
+    recommendation: str
+    trust_score: float
+    required_actions: list[str]
+
+
+@dataclass(frozen=True)
+class GenerationRun:
+    request: CreativeRequest
+    refined_prompt: TasteRefinedPrompt
+    outfit: OutfitGraph
+    model_stack: list[ModelCandidate]
+    adapters: list[AdapterRecipe]
+    inspection: InspectionReport
+    lore: LoreBeatSet
+    video: VideoPlan
+    checkpoint: HumanCheckpoint
+    created_at: str = field(default_factory=utc_now)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class WisdomRecord:
+    run_id: str
+    approved: bool
+    dataset_target: str
+    lessons: list[str]
+    created_at: str = field(default_factory=utc_now)
+

src/nexus_visual_weaver/security.py

@@ -0,0 +1,136 @@
+"""Always-on ST3GG-inspired defensive scanning adapter."""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Any
+
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"}
+ARCHIVE_EXTENSIONS = {".zip", ".7z", ".rar"}
+
+
+def _entropy(data: bytes) -> float:
+    if not data:
+        return 0.0
+    counts = [0] * 256
+    for byte in data:
+        counts[byte] += 1
+    total = len(data)
+    return -sum((count / total) * math.log2(count / total) for count in counts if count)
+
+
+def _magic_type(data: bytes) -> str:
+    if data.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "png"
+    if data.startswith(b"\xff\xd8\xff"):
+        return "jpeg"
+    if data.startswith((b"GIF87a", b"GIF89a")):
+        return "gif"
+    if len(data) >= 12 and data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "webp"
+    if data.startswith(b"BM"):
+        return "bmp"
+    if data.startswith(b"PK\x03\x04"):
+        return "zip"
+    if data.startswith(b"7z\xbc\xaf\x27\x1c"):
+        return "7z"
+    if data.startswith(b"Rar!\x1a\x07"):
+        return "rar"
+    if data.startswith(b"%PDF-"):
+        return "pdf"
+    return "unknown"
+
+
+def _expected_magic(extension: str) -> str | None:
+    return {
+        ".png": "png",
+        ".jpg": "jpeg",
+        ".jpeg": "jpeg",
+        ".webp": "webp",
+        ".gif": "gif",
+        ".bmp": "bmp",
+        ".zip": "zip",
+        ".7z": "7z",
+        ".rar": "rar",
+    }.get(extension)
+
+
+def _png_trailing_data(target: Path, size_bytes: int) -> bool:
+    if size_bytes > 5_000_000:
+        return False
+    data = target.read_bytes()
+    marker = b"IEND\xaeB`\x82"
+    idx = data.rfind(marker)
+    return idx >= 0 and idx + len(marker) < len(data)
+
+
+def scan_file(path: str | None) -> dict[str, Any]:
+    purification_actions = [
+        "strip metadata before export",
+        "truncate PNG after IEND when needed",
+        "run LSB statistical review",
+        "recompress JPEG/WebP derivative for public export",
+    ]
+    if not path:
+        return {
+            "status": "idle",
+            "scanner": "ST3GG defensive adapter",
+            "findings": ["No upload selected. Always-on scanner ready."],
+            "purification_actions": purification_actions,
+            "export_gate": "pending",
+            "payload_excerpt": None,
+        }
+
+    target = Path(path)
+    if not target.exists() or not target.is_file():
+        return {
+            "status": "error",
+            "scanner": "ST3GG defensive adapter",
+            "findings": ["File path is unavailable to scanner."],
+            "purification_actions": purification_actions,
+            "export_gate": "blocked",
+            "payload_excerpt": None,
+        }
+
+    size_bytes = target.stat().st_size
+    with target.open("rb") as handle:
+        sample = handle.read(65536)
+    entropy = round(_entropy(sample), 3)
+    extension = target.suffix.lower()
+    magic = _magic_type(sample)
+    expected_magic = _expected_magic(extension)
+    review_reasons: list[str] = []
+    findings = [
+        f"extension={extension or 'none'}",
+        f"magic={magic}",
+        f"size_bytes={size_bytes}",
+        f"entropy_sample={entropy}",
+    ]
+    if entropy > 7.7:
+        review_reasons.append("high entropy sample; review metadata/embedded payload risk")
+    if extension in IMAGE_EXTENSIONS:
+        findings.append("image file queued for metadata and LSB review")
+        if expected_magic and magic != expected_magic:
+            review_reasons.append("image extension does not match detected file signature")
+    if extension == ".png" and magic == "png" and _png_trailing_data(target, size_bytes):
+        review_reasons.append("PNG contains trailing data after IEND marker")
+    if extension in ARCHIVE_EXTENSIONS or magic in {"zip", "7z", "rar"}:
+        review_reasons.append("archive upload requires explicit review before export")
+    if expected_magic is None and magic in {"zip", "7z", "rar"}:
+        review_reasons.append("archive signature found without matching extension")
+
+    findings.extend(review_reasons)
+    status = "review" if review_reasons else "pass"
+    return {
+        "status": status,
+        "scanner": "ST3GG defensive adapter",
+        "findings": findings,
+        "purification_actions": purification_actions,
+        "export_gate": "clear" if status == "pass" else "blocked",
+        "size_bytes": size_bytes,
+        "extension": extension or "none",
+        "magic": magic,
+        "entropy_sample": entropy,
+        "payload_excerpt": None,
+    }

src/nexus_visual_weaver/styles.py

@@ -0,0 +1,877 @@
+"""CSS for the command center dashboard."""
+
+APP_CSS = """
+:root {
+  --nw-bg: #05070a;
+  --nw-panel: #090d12;
+  --nw-panel-2: #10161d;
+  --nw-panel-3: #151c24;
+  --nw-line: #222a33;
+  --nw-line-strong: #33404c;
+  --nw-text: #f3f7fb;
+  --nw-muted: #97a4ae;
+  --nw-faint: #66737d;
+  --nw-red: #ff365f;
+  --nw-red-soft: #46121d;
+  --nw-cyan: #20d9e8;
+  --nw-blue: #6b7dff;
+  --nw-violet: #b45cff;
+  --nw-green: #26d782;
+  --nw-amber: #e8b44e;
+}
+body, .gradio-container {
+  background: var(--nw-bg) !important;
+  color: var(--nw-text) !important;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif !important;
+}
+.gradio-container { max-width: none !important; padding: 0 !important; }
+footer { display: none !important; }
+.nw-app {
+  min-height: 100vh;
+  background:
+    linear-gradient(90deg, rgba(255,255,255,.025) 1px, transparent 1px),
+    linear-gradient(180deg, rgba(255,255,255,.018) 1px, transparent 1px),
+    linear-gradient(180deg, #070a0e 0%, #05070a 52%, #06090d 100%),
+    var(--nw-bg);
+  background-size: 48px 48px, 48px 48px, auto;
+}
+.nw-topbar {
+  min-height: 64px;
+  display: grid;
+  grid-template-columns: 220px 138px 164px minmax(200px, 1fr) 132px 150px 178px 138px 190px;
+  gap: 0;
+  align-items: stretch;
+  border-bottom: 1px solid #171c22;
+  background: rgba(5, 7, 10, 0.98);
+  box-shadow: 0 1px 0 rgba(255,255,255,.035), 0 12px 36px rgba(0,0,0,.36);
+}
+.nw-brand {
+  display: flex;
+  align-items: center;
+  padding: 0 22px;
+  font-size: 22px;
+  font-weight: 650;
+  letter-spacing: 0;
+  border-right: 1px solid var(--nw-line);
+  color: var(--nw-text);
+  white-space: nowrap;
+}
+.nw-brand span { color: var(--nw-red); margin-right: 10px; font-weight: 850; }
+.nw-brand strong { font-size: 18px; font-weight: 650; white-space: nowrap; }
+.nw-topbar strong,
+.nw-panel strong,
+.nw-inspector strong {
+  color: var(--nw-text);
+}
+.nw-topitem, .nw-budget, .nw-status, .nw-adult {
+  padding: 10px 18px;
+  border-right: 1px solid var(--nw-line);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  gap: 3px;
+  min-width: 0;
+}
+.nw-topitem small, .nw-budget small, .nw-adult small, .nw-status small { color: var(--nw-muted); font-size: 11px; line-height: 1.2; }
+.nw-topitem strong, .nw-budget strong, .nw-status strong, .nw-adult strong { font-size: 13px; line-height: 1.2; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.nw-topitem i {
+  position: absolute;
+  width: 6px;
+  height: 6px;
+  border-right: 1px solid var(--nw-muted);
+  border-bottom: 1px solid var(--nw-muted);
+  transform: rotate(45deg);
+  right: 18px;
+}
+.nw-gmr { gap: 5px; }
+.nw-space strong { color: var(--nw-cyan); }
+.nw-meter { height: 8px; background: #20262d; border-radius: 8px; overflow: hidden; margin-top: 5px; box-shadow: inset 0 0 0 1px rgba(255,255,255,.05); }
+.nw-meter i { display: block; height: 100%; background: linear-gradient(90deg, var(--nw-red), #ff6b7f); box-shadow: 0 0 16px rgba(255,54,95,.34); }
+.nw-live-dot { display: inline-block; width: 9px; height: 9px; border-radius: 50%; background: var(--nw-green); box-shadow: 0 0 12px rgba(38,215,130,.7); margin-right: 7px; vertical-align: -1px; }
+.nw-status { position: relative; }
+.nw-status .nw-live-dot { position: absolute; top: 21px; left: 18px; }
+.nw-status > strong { padding-left: 18px; }
+.nw-toggle {
+  display: inline-flex;
+  align-items: center;
+  width: fit-content;
+  gap: 7px;
+  min-height: 24px;
+  padding: 2px 8px 2px 3px;
+  border: 1px solid var(--nw-line-strong);
+  border-radius: 999px;
+  color: var(--nw-muted);
+  font-size: 11px;
+}
+.nw-toggle i { width: 20px; height: 20px; border-radius: 50%; background: #bac2c9; box-shadow: inset 0 -3px 8px rgba(0,0,0,.35); }
+.nw-toggle.is-on { color: var(--nw-amber); border-color: rgba(232,180,78,.45); }
+.nw-locked {
+  display: grid;
+  grid-template-columns: 38px 1fr;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 14px;
+  border-left: 1px solid var(--nw-line);
+  color: #ff6b7d;
+  background: linear-gradient(90deg, rgba(255,54,95,.12), rgba(255,54,95,.04));
+}
+.nw-locked b { border: 1px solid rgba(255,54,95,.55); border-radius: 5px; padding: 7px 6px; text-align: center; font-size: 13px; }
+.nw-locked span { font-size: 11px; line-height: 1.25; }
+.nw-icon { width: 18px; height: 18px; stroke: currentColor; fill: none; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
+.nw-shell {
+  display: grid;
+  grid-template-columns: 118px minmax(650px, 1fr) 360px;
+  grid-template-rows: 570px auto;
+  gap: 8px;
+  padding: 8px 8px 0;
+}
+.nw-rail {
+  grid-row: 1 / span 2;
+  background: linear-gradient(180deg, rgba(11, 15, 20, .98), rgba(6, 9, 12, .98));
+  border: 1px solid var(--nw-line);
+  border-radius: 7px;
+  padding: 8px 6px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+.nw-rail-main { display: grid; gap: 6px; }
+.nw-rail .nw-icon { width: 21px; height: 21px; }
+.nw-rail-foot { margin-top: auto; display: grid; gap: 8px; }
+.nw-rail-foot div {
+  border: 1px solid var(--nw-line);
+  border-radius: 7px;
+  background: rgba(255,255,255,.025);
+  color: var(--nw-muted);
+  padding: 9px 8px;
+  display: grid;
+  grid-template-columns: 22px 1fr;
+  gap: 2px 7px;
+}
+.nw-rail-foot strong { font-size: 11px; line-height: 1.25; }
+.nw-rail-foot span { grid-column: 2; color: var(--nw-muted); font-size: 11px; }
+.nw-rail-foot .nw-icon { color: var(--nw-green); grid-row: 1 / span 2; width: 19px; height: 19px; align-self: center; }
+.nw-rail-foot div:last-child .nw-icon { color: var(--nw-muted); }
+.nw-rail-foot div:last-child { margin-bottom: 70px; }
+.nw-rail::after {
+  content: "Runs 112   Queue 2";
+  color: var(--nw-muted);
+  font-size: 11px;
+  padding: 11px 6px 3px;
+  border-top: 1px solid var(--nw-line);
+}
+.nw-rail-item {
+  background: transparent;
+  border: 1px solid transparent;
+  color: #c9d0d8;
+  border-radius: 7px;
+  padding: 13px 10px;
+  font-size: 12px;
+  display: flex;
+  gap: 10px;
+  justify-content: flex-start;
+  align-items: center;
+  width: 100%;
+  min-height: 54px;
+}
+.nw-rail-item span {
+  color: currentColor;
+  font-size: 12px;
+  font-weight: 560;
+}
+.nw-rail-item.active {
+  color: var(--nw-text);
+  border-color: rgba(255,54,95,.32);
+  background: linear-gradient(90deg, rgba(255,54,95,.20), rgba(255,54,95,.05));
+  box-shadow: inset 3px 0 0 var(--nw-red);
+}
+.nw-panel {
+  background: linear-gradient(180deg, rgba(14, 19, 25, .97), rgba(7, 11, 15, .98));
+  border: 1px solid var(--nw-line);
+  border-radius: 7px;
+  box-shadow: 0 18px 55px rgba(0, 0, 0, .28), inset 0 1px 0 rgba(255,255,255,.04);
+}
+.nw-panel-head {
+  min-height: 50px;
+  padding: 10px 16px;
+  border-bottom: 1px solid var(--nw-line);
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+}
+.nw-panel-head strong { font-size: 15px; font-weight: 620; }
+.nw-panel-head small { display: block; color: var(--nw-muted); font-size: 12px; margin-top: 3px; }
+.nw-panel-head button,
+.nw-tools button,
+.nw-tools select,
+.nw-panel-head select,
+.nw-beat select {
+  min-height: 28px;
+  border: 1px solid var(--nw-line-strong);
+  background: rgba(255,255,255,.025);
+  color: var(--nw-text);
+  border-radius: 5px;
+  font-size: 11px;
+  padding: 4px 9px;
+}
+.nw-tools { display: flex; align-items: center; gap: 8px; color: var(--nw-muted); font-size: 12px; }
+.nw-tools .nw-icon { width: 15px; height: 15px; }
+.nw-static-tools span,
+.nw-chip,
+.nw-mini-chip {
+  min-height: 26px;
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  border: 1px solid var(--nw-line-strong);
+  background: rgba(255,255,255,.025);
+  color: var(--nw-muted);
+  border-radius: 5px;
+  font-size: 11px;
+  padding: 4px 8px;
+  white-space: nowrap;
+}
+.nw-mini-chip { width: fit-content; min-height: 22px; padding: 2px 7px; }
+.nw-canvas { overflow: hidden; height: 570px; }
+.nw-graph { width: 100%; min-height: 548px; display: block; background: #070b0f; }
+.nw-edges path {
+  fill: none;
+  stroke: var(--nw-cyan);
+  stroke-width: 2.2;
+  opacity: .82;
+}
+.nw-node rect {
+  fill: rgba(13, 18, 24, .96);
+  stroke: var(--nw-line-strong);
+  stroke-width: 1.25;
+  filter: drop-shadow(0 16px 18px rgba(0,0,0,.25));
+}
+.nw-node-red rect { stroke: rgba(255,54,95,.74); }
+.nw-node-violet rect { stroke: rgba(180,92,255,.72); }
+.nw-node-blue rect { stroke: rgba(107,125,255,.72); }
+.nw-node-cyan rect { stroke: rgba(32,217,232,.74); }
+.nw-node-green rect { stroke: rgba(38,215,130,.68); }
+.nw-node-amber rect { stroke: rgba(232,180,78,.78); }
+.nw-node-title { fill: var(--nw-text); font-size: 15px; font-weight: 650; }
+.nw-node-line { fill: #cbd4dc; font-size: 12px; }
+.nw-node-footer { fill: var(--nw-muted); font-size: 11px; }
+.nw-node-sep { stroke: rgba(255,255,255,.08); stroke-width: 1; }
+.nw-node-ok { fill: var(--nw-green); }
+.nw-thumb { stroke: rgba(255,255,255,.16); stroke-width: 1; fill: #17202a; }
+.nw-thumb-0 { fill: #101417; }
+.nw-thumb-1 { fill: #1e2428; }
+.nw-thumb-2 { fill: #33111b; }
+.nw-thumb-3 { fill: #0f2630; }
+.nw-legend { padding: 0 16px 13px; display: flex; gap: 8px; flex-wrap: wrap; }
+.nw-weave-console {
+  display: grid;
+  grid-template-columns: 1.1fr 1.4fr 1.25fr 1.35fr;
+  gap: 8px;
+  padding: 0 12px 12px;
+}
+.nw-console-card {
+  min-height: 88px;
+  border: 1px solid var(--nw-line);
+  border-radius: 6px;
+  background:
+    linear-gradient(135deg, rgba(255,255,255,.04), transparent 40%),
+    rgba(255,255,255,.018);
+  padding: 10px;
+  display: grid;
+  align-content: space-between;
+  gap: 5px;
+}
+.nw-console-primary {
+  border-color: rgba(255,54,95,.36);
+  background:
+    linear-gradient(135deg, rgba(255,54,95,.14), transparent 48%),
+    rgba(255,255,255,.02);
+}
+.nw-console-card small {
+  color: var(--nw-faint);
+  font-size: 10px;
+  font-weight: 760;
+  letter-spacing: 0;
+}
+.nw-console-card strong {
+  color: var(--nw-text);
+  font-size: 12px;
+  line-height: 1.25;
+}
+.nw-console-card span {
+  color: var(--nw-muted);
+  font-size: 11px;
+  line-height: 1.35;
+}
+.nw-badge {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 3px 9px;
+  border-radius: 5px;
+  border: 1px solid var(--nw-line-strong);
+  color: var(--nw-muted);
+  font-size: 11px;
+  font-weight: 650;
+  width: fit-content;
+}
+.nw-pass { color: var(--nw-green); border-color: rgba(46, 229, 157, .35); background: rgba(46, 229, 157, .08); }
+.nw-warn { color: var(--nw-amber); border-color: rgba(245, 184, 61, .35); background: rgba(245, 184, 61, .08); }
+.nw-accent { color: var(--nw-red); border-color: rgba(244, 63, 94, .35); background: rgba(244, 63, 94, .08); }
+.nw-cyan { color: var(--nw-cyan); border-color: rgba(34, 211, 238, .35); background: rgba(34, 211, 238, .08); }
+.nw-violet { color: var(--nw-violet); border-color: rgba(180,92,255,.35); background: rgba(180,92,255,.08); }
+.nw-blue { color: var(--nw-blue); border-color: rgba(107,125,255,.35); background: rgba(107,125,255,.08); }
+.nw-muted { color: var(--nw-muted); }
+.nw-inspector { grid-column: 3; grid-row: 1; height: 570px; padding-bottom: 12px; overflow-y: auto; }
+.nw-inspector h3 { font-size: 12px; margin: 12px 16px 6px; color: var(--nw-text); font-weight: 620; }
+.nw-rings { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; padding: 12px 16px; }
+.nw-rings div {
+  aspect-ratio: 1;
+  border-radius: 999px;
+  display: grid;
+  place-content: center;
+  text-align: center;
+  background:
+    radial-gradient(circle at center, #10161d 0 55%, transparent 56%),
+    conic-gradient(var(--ring) calc(var(--v) * 1%), rgba(255,255,255,.08) 0);
+  box-shadow: inset 0 0 0 1px rgba(255,255,255,.06);
+}
+.nw-rings b { font-size: 18px; }
+.nw-rings small { color: var(--nw-muted); font-size: 9px; max-width: 58px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.nw-checks, .nw-models, .nw-relay { list-style: none; margin: 0 16px; padding: 0; display: grid; gap: 5px; }
+.nw-checks { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+.nw-checks li, .nw-models li, .nw-relay li {
+  border: 1px solid var(--nw-line);
+  border-radius: 5px;
+  padding: 6px 8px;
+  background: linear-gradient(90deg, rgba(255,255,255,.035), rgba(255,255,255,.016));
+  display: flex;
+  justify-content: flex-start;
+  gap: 8px;
+  font-size: 10px;
+  color: #dce8ef;
+}
+.nw-checks li span { color: var(--nw-green); font-weight: 900; }
+.nw-models span { color: var(--nw-muted); }
+.nw-models li {
+  justify-content: space-between;
+}
+.nw-models strong {
+  color: #dce8ef;
+  font-size: 11px;
+  text-align: right;
+}
+.nw-relay li {
+  display: grid;
+  grid-template-columns: minmax(74px, .7fr) minmax(90px, 1fr);
+  gap: 4px 8px;
+}
+.nw-relay span { color: var(--nw-muted); font-size: 11px; }
+.nw-relay strong { font-size: 11px; color: #dce8ef; text-align: right; }
+.nw-relay em {
+  grid-column: 1 / span 2;
+  color: var(--nw-muted);
+  font-style: normal;
+  font-size: 10px;
+  line-height: 1.3;
+}
+.nw-relay-foot { margin: 9px 16px 0; display: flex; flex-wrap: wrap; gap: 6px; }
+.nw-scan { margin: 0 16px; padding: 9px; border: 1px solid var(--nw-line); border-radius: 6px; display: grid; gap: 7px; background: rgba(255,255,255,.02); }
+.nw-scan > div { display: flex; justify-content: space-between; align-items: center; gap: 8px; }
+.nw-scan span { color: var(--nw-muted); font-size: 11px; }
+.nw-scan i { display: block; height: 7px; border-radius: 7px; background: linear-gradient(90deg, var(--nw-green), rgba(38,215,130,.25)); }
+.nw-scan dl { display: grid; grid-template-columns: 90px 1fr; gap: 5px 8px; margin: 0; font-size: 10px; }
+.nw-scan dt { color: var(--nw-muted); }
+.nw-scan dd { color: #d8e1e8; margin: 0; text-align: right; }
+.nw-scan-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: grid;
+  gap: 4px;
+}
+.nw-scan-list li {
+  border: 1px solid rgba(255,255,255,.06);
+  background: rgba(255,255,255,.022);
+  border-radius: 5px;
+  padding: 5px 7px;
+  color: #d8e1e8;
+  font-size: 10px;
+  line-height: 1.3;
+}
+.nw-scan-actions li { color: var(--nw-muted); }
+.nw-bottom { grid-column: 2 / span 2; grid-row: 2; display: grid; grid-template-columns: .95fr 1.05fr; gap: 10px; }
+.nw-filter-row { display: flex; gap: 7px; padding: 9px 12px 0; overflow-x: auto; }
+.nw-filter-row span { border: 1px solid var(--nw-line); border-radius: 5px; padding: 6px 11px; color: var(--nw-muted); font-size: 11px; background: rgba(255,255,255,.018); white-space: nowrap; }
+.nw-filter-row span:first-child { color: var(--nw-red); border-color: rgba(255,54,95,.45); }
+.nw-swatches, .nw-beats { display: grid; grid-auto-flow: column; grid-auto-columns: minmax(112px, 1fr); gap: 8px; overflow-x: auto; padding: 12px; }
+.nw-beats { grid-auto-columns: minmax(128px, 1fr); }
+.nw-swatch, .nw-beat { min-height: 134px; border: 1px solid var(--nw-line); border-radius: 6px; padding: 7px; background: rgba(255,255,255,.024); display: grid; align-content: start; gap: 6px; }
+.nw-swatch.is-locked {
+  border-color: rgba(38,215,130,.34);
+  background:
+    linear-gradient(135deg, rgba(38,215,130,.08), transparent 42%),
+    rgba(255,255,255,.024);
+}
+.nw-swatch i, .nw-beat i {
+  display: block; height: 72px; border-radius: 5px;
+  border: 1px solid #303841;
+  box-shadow: inset 0 0 24px rgba(0,0,0,.4);
+}
+.nw-swatch .nw-material-0, .nw-material-0 { background: linear-gradient(135deg, #030405, #20252a 42%, #f5f5f1 44%, #0b0d10 46%, #11181e); }
+.nw-swatch .nw-material-1, .nw-material-1 { background: linear-gradient(135deg, #c8c8bd, #545750 35%, #15181b 70%, #08090a); }
+.nw-swatch .nw-material-2, .nw-material-2 { background: repeating-linear-gradient(135deg, #080a0d 0 6px, #262a2e 7px 9px, #0d1013 10px 16px); }
+.nw-swatch .nw-material-3, .nw-material-3 { background: radial-gradient(circle at 55% 48%, #ff375f 0 7px, #6b1320 8px 19px, #0a0b0d 20px), linear-gradient(135deg, #0b0b0d, #2c0e16); }
+.nw-swatch .nw-material-4, .nw-material-4 { background: linear-gradient(160deg, #060709, #111820 45%, #3b4148 46%, #090b0d 70%); }
+.nw-swatch .nw-material-5, .nw-material-5 { background: linear-gradient(135deg, #151719, #292d30 40%, #0a0c0f 60%, #1d2226); }
+.nw-story-0 { background: linear-gradient(135deg, #29211a, #0c1217 45%, #38444b); }
+.nw-story-1 { background: linear-gradient(135deg, #101922, #1a5960 42%, #711c36 70%, #090b0e); }
+.nw-story-2 { background: linear-gradient(135deg, #14191e, #363f4a 45%, #0b0d10); }
+.nw-story-3 { background: linear-gradient(135deg, #121316, #c9d1d4 50%, #1a1015 55%, #07090c); }
+.nw-story-4 { background: linear-gradient(135deg, #0f1115, #2d1a27, #050607 68%); }
+.nw-story-5 { background: linear-gradient(135deg, #111820, #333b43 45%, #0a0d11); }
+.nw-swatch strong, .nw-beat strong { font-size: 11px; color: var(--nw-text); line-height: 1.25; }
+.nw-swatch small, .nw-beat small { font-size: 10px; color: var(--nw-muted); line-height: 1.3; }
+.nw-swatch span {
+  width: fit-content;
+  border: 1px solid rgba(255,255,255,.08);
+  border-radius: 5px;
+  color: var(--nw-faint);
+  font-size: 10px;
+  padding: 2px 6px;
+}
+.nw-beat select { min-height: 24px; width: 100%; padding: 2px 5px; color: var(--nw-muted); }
+.nw-catalog { padding: 16px; }
+.nw-catalog table { width: 100%; border-collapse: collapse; font-size: 12px; }
+.nw-catalog th, .nw-catalog td { border-bottom: 1px solid var(--nw-line); padding: 9px 8px; text-align: left; vertical-align: top; }
+.nw-catalog th { color: var(--nw-muted); font-size: 11px; text-transform: uppercase; }
+#nw-inputs .form, #nw-inputs .block { background: var(--nw-panel) !important; border-color: var(--nw-line) !important; }
+#nw-inputs,
+#nw-inputs .styler,
+#nw-inputs .form,
+#nw-inputs .block,
+#nw-inputs .wrap,
+#nw-inputs .container,
+#nw-inputs .upload-container,
+#nw-inputs .file-preview,
+#nw-inputs .empty,
+#nw-inputs .input-container,
+#nw-inputs .prose,
+#nw-inputs [data-testid],
+#nw-inputs fieldset {
+  background: #080d12 !important;
+  border-color: var(--nw-line) !important;
+  color: var(--nw-text) !important;
+}
+#nw-inputs textarea, #nw-inputs input, #nw-inputs select {
+  background: #091018 !important;
+  color: var(--nw-text) !important;
+  border-color: var(--nw-line-strong) !important;
+}
+#nw-inputs label, #nw-inputs .label-wrap, #nw-inputs span, #nw-inputs p { color: var(--nw-text) !important; }
+#nw-inputs button {
+  border-radius: 5px !important;
+  border-color: var(--nw-line-strong) !important;
+  background: #101820 !important;
+  color: var(--nw-text) !important;
+  font-size: 13px !important;
+}
+#nw-inputs button.primary,
+#nw-inputs button[variant="primary"] {
+  background: linear-gradient(180deg, #ff3b62, #c51a3b) !important;
+  border-color: rgba(255,54,95,.58) !important;
+}
+.nw-control-panel {
+  margin: 8px 8px 10px 8px;
+  padding: 12px;
+  border: 1px solid var(--nw-line);
+  border-radius: 7px;
+  background:
+    linear-gradient(135deg, rgba(255,54,95,.08), transparent 28%),
+    linear-gradient(180deg, rgba(13,18,24,.98), rgba(7,11,15,.98));
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  box-shadow: 0 14px 32px rgba(0,0,0,.28), inset 0 1px 0 rgba(255,255,255,.04);
+}
+.nw-command-header {
+  display: grid;
+  grid-template-columns: minmax(260px, 1fr) auto;
+  align-items: center;
+  gap: 14px;
+  padding: 2px 2px 12px;
+  border-bottom: 1px solid rgba(255,255,255,.06);
+  margin-bottom: 12px;
+}
+.nw-command-header small {
+  color: var(--nw-red);
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0;
+}
+.nw-command-header strong {
+  display: block;
+  color: var(--nw-text);
+  font-size: 17px;
+  font-weight: 680;
+  line-height: 1.25;
+}
+.nw-command-header span {
+  display: block;
+  color: var(--nw-muted);
+  font-size: 12px;
+  line-height: 1.35;
+  margin-top: 3px;
+}
+.nw-command-pills {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 7px;
+}
+#nw-workspace {
+  padding: 0 8px;
+  gap: 8px !important;
+  align-items: stretch;
+}
+#nw-workspace > .form,
+#nw-workspace .block,
+#nw-workspace .panel,
+#nw-native-rail,
+#nw-main-column,
+#nw-side-column {
+  background: transparent !important;
+  border: 0 !important;
+  box-shadow: none !important;
+}
+#nw-native-rail,
+#nw-main-column,
+#nw-side-column {
+  gap: 8px !important;
+}
+#nw-section-nav,
+#nw-section-nav .form,
+#nw-section-nav fieldset,
+#nw-section-nav .wrap {
+  background: linear-gradient(180deg, rgba(11, 15, 20, .98), rgba(6, 9, 12, .98)) !important;
+  border-color: var(--nw-line) !important;
+  color: var(--nw-text) !important;
+  border-radius: 7px !important;
+}
+#nw-section-nav label,
+#nw-section-nav span {
+  color: var(--nw-text) !important;
+}
+#nw-section-nav .wrap {
+  display: grid !important;
+  gap: 5px !important;
+}
+#nw-section-nav input[type="radio"] {
+  accent-color: var(--nw-red);
+}
+.nw-native-rail {
+  border: 1px solid var(--nw-line);
+  background: linear-gradient(180deg, rgba(12,17,23,.97), rgba(7,10,14,.98));
+  border-radius: 7px;
+  padding: 12px;
+  display: grid;
+  gap: 8px;
+}
+.nw-native-rail strong {
+  color: var(--nw-text);
+  font-size: 13px;
+}
+.nw-native-rail span {
+  color: var(--nw-muted);
+  font-size: 11px;
+  line-height: 1.4;
+}
+#nw-workspace .nw-canvas,
+#nw-workspace .nw-inspector {
+  grid-column: auto;
+  grid-row: auto;
+}
+#nw-workspace .nw-canvas {
+  height: auto;
+  min-height: 570px;
+}
+#nw-workspace .nw-inspector {
+  height: auto;
+  min-height: 570px;
+}
+.nw-main-stack,
+.nw-side-stack {
+  display: grid;
+  gap: 8px;
+}
+.nw-artifacts {
+  overflow: hidden;
+}
+.nw-preview-stage {
+  display: grid;
+  grid-template-columns: minmax(280px, 1fr) 190px;
+  gap: 10px;
+  padding: 12px 12px 0;
+}
+.nw-preview-frame {
+  min-height: 190px;
+  border: 1px solid rgba(255,255,255,.08);
+  border-radius: 7px;
+  overflow: hidden;
+  display: grid;
+  grid-template-columns: minmax(180px, .86fr) 1fr;
+  background:
+    radial-gradient(circle at 18% 18%, rgba(255,54,95,.18), transparent 32%),
+    linear-gradient(135deg, #0a0d11, #111820 52%, #080a0d);
+}
+.nw-preview-image {
+  min-height: 190px;
+  display: block;
+  background:
+    linear-gradient(130deg, rgba(255,255,255,.16) 0 2px, transparent 3px 52%),
+    radial-gradient(circle at 42% 34%, #f5f0e8 0 4px, transparent 5px),
+    radial-gradient(circle at 44% 50%, #242930 0 30px, transparent 31px),
+    linear-gradient(155deg, #050608, #171d23 44%, #4f1020 45%, #07090c 63%);
+  border-right: 1px solid rgba(255,255,255,.08);
+}
+.nw-preview-caption {
+  display: grid;
+  align-content: end;
+  gap: 6px;
+  padding: 16px;
+}
+.nw-preview-caption small,
+.nw-preview-meta small,
+.nw-artifact-card small {
+  color: var(--nw-faint);
+  font-size: 10px;
+  font-weight: 760;
+  letter-spacing: 0;
+}
+.nw-preview-caption strong {
+  font-size: 15px;
+  color: var(--nw-text);
+  line-height: 1.25;
+}
+.nw-preview-caption span {
+  color: #cbd5dc;
+  font-size: 12px;
+  line-height: 1.45;
+}
+.nw-preview-meta {
+  display: grid;
+  gap: 8px;
+}
+.nw-preview-meta div {
+  border: 1px solid var(--nw-line);
+  border-radius: 6px;
+  background: rgba(255,255,255,.024);
+  padding: 10px;
+  display: grid;
+  align-content: center;
+  gap: 4px;
+}
+.nw-preview-meta strong {
+  color: var(--nw-text);
+  font-size: 12px;
+  line-height: 1.25;
+}
+.nw-preview-ribbon {
+  margin: 10px 12px 0;
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+}
+.nw-preview-ribbon span {
+  min-height: 34px;
+  border: 1px solid var(--nw-line);
+  border-radius: 6px;
+  background: rgba(255,255,255,.02);
+  color: #cfd8df;
+  font-size: 11px;
+  line-height: 1.3;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 7px 9px;
+  min-width: 0;
+}
+.nw-preview-ribbon .nw-icon {
+  width: 16px;
+  height: 16px;
+  flex: 0 0 auto;
+  color: var(--nw-cyan);
+}
+.nw-operations {
+  overflow: hidden;
+}
+.nw-operation-grid {
+  padding: 12px;
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+}
+.nw-operation-card {
+  min-height: 116px;
+  border: 1px solid var(--nw-line);
+  border-radius: 6px;
+  background:
+    linear-gradient(135deg, rgba(32,217,232,.07), transparent 34%),
+    rgba(255,255,255,.022);
+  padding: 11px;
+  display: grid;
+  align-content: space-between;
+  gap: 10px;
+}
+.nw-operation-card small {
+  color: var(--nw-cyan);
+  font-size: 10px;
+  font-weight: 760;
+  letter-spacing: 0;
+}
+.nw-operation-card strong {
+  color: #dce8ef;
+  font-size: 12px;
+  line-height: 1.4;
+  font-weight: 560;
+}
+.nw-operation-card i {
+  display: block;
+  height: 5px;
+  border-radius: 6px;
+  background:
+    linear-gradient(90deg, var(--nw-cyan), rgba(32,217,232,.18) 68%, rgba(255,255,255,.06));
+  box-shadow: 0 0 14px rgba(32,217,232,.14);
+}
+.nw-artifact-grid {
+  padding: 12px;
+  display: grid;
+  grid-template-columns: repeat(4, minmax(120px, 1fr));
+  gap: 8px;
+}
+.nw-artifact-card,
+.nw-provider-card {
+  border: 1px solid var(--nw-line);
+  border-radius: 6px;
+  background: linear-gradient(180deg, rgba(255,255,255,.035), rgba(255,255,255,.014));
+  padding: 8px;
+  display: grid;
+  gap: 6px;
+  min-width: 0;
+}
+.nw-artifact-card > small {
+  justify-self: end;
+}
+.nw-artifact-card i {
+  display: block;
+  height: 86px;
+  border-radius: 5px;
+  border: 1px solid #303841;
+  box-shadow: inset 0 0 24px rgba(0,0,0,.42);
+}
+.nw-artifact-card strong,
+.nw-provider-card strong {
+  color: var(--nw-text);
+  font-size: 12px;
+  line-height: 1.25;
+  overflow-wrap: anywhere;
+}
+.nw-artifact-card span,
+.nw-provider-card span,
+.nw-provider-card small {
+  color: var(--nw-muted);
+  font-size: 11px;
+  line-height: 1.3;
+}
+.nw-providers {
+  overflow: hidden;
+}
+.nw-provider-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+  padding: 12px;
+}
+.nw-provider-card {
+  min-height: 112px;
+}
+.nw-provider-meter {
+  height: 6px;
+  border-radius: 8px;
+  background:
+    linear-gradient(90deg, var(--nw-green) 0 calc(var(--health) * 1%), #252d35 calc(var(--health) * 1%) 100%);
+  box-shadow: inset 0 0 0 1px rgba(255,255,255,.05);
+}
+.nw-provider-card div {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+.nw-statusbar {
+  height: 54px;
+  margin: 8px;
+  display: grid !important;
+  grid-template-columns: 110px 120px 160px 200px 140px 150px 1fr 160px;
+  align-items: stretch;
+  border: 1px solid var(--nw-line);
+  border-radius: 7px;
+  overflow: hidden;
+  background: rgba(7, 10, 14, .98);
+}
+.nw-metric, .nw-autosave {
+  border-right: 1px solid var(--nw-line);
+  padding: 8px 18px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+.nw-metric small, .nw-autosave small { color: var(--nw-muted); font-size: 11px; }
+.nw-metric strong, .nw-autosave strong { color: var(--nw-text); font-size: 13px; font-weight: 560; }
+.nw-metric-bar::after {
+  content: "";
+  height: 6px;
+  flex: 1;
+  border-radius: 8px;
+  background: linear-gradient(90deg, var(--nw-green) 0 46%, #232a31 47% 100%);
+}
+.nw-autosave { justify-content: flex-end; }
+.nw-stop {
+  margin: 8px;
+  border: 1px solid rgba(255,54,95,.55);
+  background: linear-gradient(180deg, #f32d56, #bd1739);
+  color: white;
+  border-radius: 6px;
+  font-weight: 650;
+  font-size: 13px;
+}
+.nw-stop-idle {
+  display: grid;
+  place-items: center;
+  border-color: var(--nw-line-strong);
+  background: rgba(255,255,255,.025);
+  color: var(--nw-muted);
+}
+@media (max-width: 1100px) {
+  .nw-topbar { grid-template-columns: 1fr; }
+  .nw-shell { grid-template-columns: 1fr; grid-template-rows: auto; }
+  .nw-rail, .nw-inspector, .nw-bottom { grid-column: 1; grid-row: auto; }
+  .nw-rail { flex-direction: row; overflow-x: auto; }
+  .nw-rail-main { display: flex; }
+  .nw-rail-foot, .nw-rail::after { display: none; }
+  .nw-bottom { grid-template-columns: 1fr; }
+  #nw-workspace { flex-direction: column; }
+  .nw-command-header, .nw-preview-stage, .nw-preview-frame { grid-template-columns: 1fr; }
+  .nw-command-pills { justify-content: flex-start; }
+  .nw-operation-grid { grid-template-columns: 1fr; }
+  .nw-weave-console, .nw-preview-ribbon { grid-template-columns: 1fr; }
+  .nw-artifact-grid, .nw-provider-grid { grid-template-columns: 1fr 1fr; }
+  .nw-graph { min-height: 430px; }
+  .nw-statusbar { grid-template-columns: 1fr 1fr; height: auto; }
+}
+@media (max-width: 720px) {
+  .nw-artifact-grid, .nw-provider-grid { grid-template-columns: 1fr; }
+  .nw-rings { grid-template-columns: repeat(2, 1fr); }
+  .nw-checks { grid-template-columns: 1fr; }
+}
+"""

src/nexus_visual_weaver/taste.py

@@ -0,0 +1,91 @@
+"""Taste profile loading and deterministic scoring."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .schema import TasteProfile, TasteRefinedPrompt
+
+DEFAULT_TASTE_PATH = Path(__file__).resolve().parents[2] / "assets" / "taste_profile.json"
+
+FEATURE_ALIASES: dict[str, tuple[str, ...]] = {
+    "patent_leather": ("patent leather", "gloss leather", "black leather", "latex-tech"),
+    "faux_fur": ("faux fur", "fur trim", "black fur", "fur collar"),
+    "chantilly_lace": ("chantilly lace", "lace", "lace mesh", "lace threads"),
+    "crimson_hardware": ("crimson hardware", "red metal", "red buckles", "crimson buckles", "red choker"),
+    "platform_boots": ("platform boots", "platform boot", "heavy boots", "tall boots"),
+    "slavic_model": ("slavic", "high cheekbones", "pale matte skin", "intense focused eyes"),
+    "nexus_sigils": ("nexus sigil", "nexus sigils", "orchestrator glyph", "node glyph"),
+    "rain_slicked_surfaces": ("rain", "rain-slicked", "wet pavement", "neon rain"),
+    "floating_code_data_streams": ("floating code", "data streams", "code streams"),
+}
+
+
+def load_taste_profile(path: Path | str = DEFAULT_TASTE_PATH) -> TasteProfile:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    rules = data.get("enforcement_rules", {})
+    return TasteProfile(
+        version=data.get("version", "unknown"),
+        locked_features=data.get("locked_features", {}),
+        must_include=rules.get("must_include", []),
+        should_include=rules.get("should_include", []),
+        forbidden=rules.get("forbidden", []),
+    )
+
+
+def _has_alias(text: str, aliases: tuple[str, ...]) -> bool:
+    lowered = text.lower()
+    return any(re.search(rf"\b{re.escape(alias)}\b", lowered) for alias in aliases)
+
+
+def score_prompt(prompt: str) -> tuple[float, list[str], list[str]]:
+    found: list[str] = []
+    missing: list[str] = []
+    for feature, aliases in FEATURE_ALIASES.items():
+        if _has_alias(prompt, aliases):
+            found.append(feature)
+        else:
+            missing.append(feature)
+
+    must = ["patent_leather", "crimson_hardware", "platform_boots", "slavic_model"]
+    must_hits = sum(1 for feature in must if feature in found)
+    optional_hits = len(found) - must_hits
+    score = min(0.98, 0.38 + must_hits * 0.11 + optional_hits * 0.045)
+    return round(score, 2), missing, found
+
+
+def refine_prompt(prompt: str, adult_mode: bool = False) -> TasteRefinedPrompt:
+    additions: list[str] = []
+    score, missing, _ = score_prompt(prompt)
+    supplement_map = {
+        "patent_leather": "rich black patent leather with visible grain and wet reflections",
+        "faux_fur": "dense black faux fur trim at collar and cuffs",
+        "chantilly_lace": "delicate Chantilly lace mesh at neckline and sleeves",
+        "crimson_hardware": "glowing crimson hardware on buckles, choker, and closures",
+        "platform_boots": "structured platform boots with polished black soles",
+        "slavic_model": "Slavic model features with high cheekbones and intense focused eyes",
+        "nexus_sigils": "subtle NEXUS sigils and orchestrator node glyphs woven into holographic streams",
+        "rain_slicked_surfaces": "rain-slicked cinematic surfaces under cyan and magenta neon",
+        "floating_code_data_streams": "floating code and iridescent data streams in the background",
+    }
+    for feature in missing:
+        if feature in supplement_map and len(additions) < 6:
+            additions.append(supplement_map[feature])
+
+    mode_clause = "adult catalog remains opt-in and partitioned" if adult_mode else "public-safe presentation"
+    refined = " ".join(
+        part.strip()
+        for part in [prompt.strip(), ", ".join(additions), mode_clause, "ultra-photorealistic FLUX.2 texture detail"]
+        if part.strip()
+    )
+    final_score, final_missing, _ = score_prompt(refined)
+    return TasteRefinedPrompt(
+        original=prompt,
+        refined=refined,
+        additions=additions,
+        score=final_score,
+        missing_features=final_missing,
+    )
+

src/nexus_visual_weaver/wardrobe.py

@@ -0,0 +1,47 @@
+"""Wardrobe slot extraction and validation."""
+
+from __future__ import annotations
+
+from .schema import OutfitGraph, WardrobeSlot
+
+SLOT_BLUEPRINTS: list[tuple[str, str, str, str, str]] = [
+    ("hair_headwear", "sleek hair or sculptural headwear", "hair / metal", "obsidian with neon edge", "identity lock"),
+    ("upper_body", "structured bodice or fitted top", "chantilly_lace", "black lace and mesh", "lace / mesh adapter"),
+    ("outerwear", "long technical coat or jacket", "patent_leather", "jet black", "FLUX.2 material texture"),
+    ("hands", "gloves with interface details", "patent_leather", "black with crimson nodes", "detail LoRA"),
+    ("lower_body", "tailored lower silhouette", "layered_garments", "dark graphite", "garment consistency"),
+    ("footwear", "strong platform boots", "polished_leather", "matte black sole", "boot detail"),
+    ("jewelry", "choker, buckles, and hard points", "crimson_hardware", "crimson metal", "hardware glow"),
+    ("props", "holographic sigils and data tools", "holographic_glass", "cyan and magenta", "NEXUS glyphs"),
+    ("background_context", "rain, code, and location atmosphere", "neon_rain", "obsidian/cyan/crimson", "environmental continuity"),
+]
+
+
+def build_outfit_graph(prompt: str, adult_mode: bool = False) -> OutfitGraph:
+    lowered = prompt.lower()
+    slots: list[WardrobeSlot] = []
+    for index, (name, description, material, palette, lora_hint) in enumerate(SLOT_BLUEPRINTS):
+        locked = any(token in lowered for token in name.split("_")) or material.replace("_", " ") in lowered
+        if name == "outerwear" and "coat" in lowered:
+            locked = True
+        if name == "footwear" and ("boot" in lowered or "platform" in lowered):
+            locked = True
+        if name == "jewelry" and ("crimson" in lowered or "hardware" in lowered):
+            locked = True
+        slots.append(
+            WardrobeSlot(
+                name=name,
+                description=description,
+                material=material,
+                palette=palette,
+                lora_hint=lora_hint,
+                locked=locked,
+                adult_only=False if not adult_mode else name in {"upper_body", "lower_body"},
+                locate_region="auto-map",
+                edit_priority=max(1, 5 - index // 2),
+            )
+        )
+    locked_count = sum(1 for slot in slots if slot.locked)
+    score = round(0.68 + min(0.24, locked_count * 0.035), 2)
+    return OutfitGraph(slots=slots, score=score)
+

src/nexus_visual_weaver/workflow.py

@@ -0,0 +1,35 @@
+"""Small deterministic workflow state model for the dashboard graph."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class WorkflowNode:
+    id: str
+    title: str
+    lane: str
+    status: str = "pending"
+    score: float | None = None
+
+
+@dataclass
+class WorkflowState:
+    nodes: list[WorkflowNode] = field(default_factory=list)
+    paused_at: str = "human_checkpoint"
+
+    @classmethod
+    def default(cls) -> "WorkflowState":
+        return cls(
+            nodes=[
+                WorkflowNode("seed", "Seed Prompt", "Creative", "complete"),
+                WorkflowNode("refine", "Refine", "Creative", "complete", 0.86),
+                WorkflowNode("judge", "Judge", "Model", "complete", 0.84),
+                WorkflowNode("locate", "Locate", "Grounding", "complete", 0.88),
+                WorkflowNode("generate", "Generate", "Model", "ready"),
+                WorkflowNode("video", "Video Path", "Output", "ready"),
+                WorkflowNode("checkpoint", "Human Checkpoint", "Guardrail", "paused"),
+            ]
+        )
+

tests/test_command_center.py

@@ -0,0 +1,174 @@
+from pathlib import Path
+
+from nexus_visual_weaver.catalog import active_stack, catalog_summary, filter_catalog, parameter_budget
+from nexus_visual_weaver.grounding import inspect_outfit
+from nexus_visual_weaver.model_relay import WeaverModelRelay
+from nexus_visual_weaver.planner import build_command_center_run
+from nexus_visual_weaver.render import render_command_header, render_dashboard_regions, render_operations_panel
+from nexus_visual_weaver.security import scan_file
+from nexus_visual_weaver.taste import refine_prompt, score_prompt
+from nexus_visual_weaver.wardrobe import build_outfit_graph
+
+
+def test_taste_refinement_adds_locked_features() -> None:
+    refined = refine_prompt("Cyberpunk woman in neon rain")
+    assert refined.score >= 0.75
+    assert "patent leather" in refined.refined.lower()
+    assert "crimson hardware" in refined.refined.lower()
+
+
+def test_wardrobe_slots_have_required_structure() -> None:
+    outfit = build_outfit_graph("black patent leather coat, crimson hardware, platform boots")
+    slot_names = {slot.name for slot in outfit.slots}
+    assert {"outerwear", "upper_body", "footwear", "jewelry", "background_context"} <= slot_names
+    assert all(slot.edit_priority >= 1 for slot in outfit.slots)
+
+
+def test_locateanything_inspection_flags_drift_when_needed() -> None:
+    outfit = build_outfit_graph("minimal cyberpunk portrait")
+    report = inspect_outfit(outfit)
+    assert report.locate_model == "nvidia/LocateAnything-3B"
+    assert report.targets
+    assert "footwear requires stronger prompt lock" in report.drift_flags
+
+
+def test_adult_catalog_hidden_by_default_and_visible_when_enabled() -> None:
+    models_default, adapters_default = filter_catalog(False)
+    models_adult, adapters_adult = filter_catalog(True)
+    assert not any(model.adult_only for model in models_default)
+    assert not any(adapter.adult_only for adapter in adapters_default)
+    assert any(model.adult_only for model in models_adult)
+    assert any(adapter.adult_only for adapter in adapters_adult)
+
+
+def test_active_parameter_budget_passes_default_stack() -> None:
+    budget = parameter_budget(active_stack(False))
+    assert budget["status"] == "pass"
+    assert budget["active_b"] <= 32.0
+
+
+def test_command_center_run_is_checkpointed() -> None:
+    run = build_command_center_run(
+        "Slavic model, patent leather, faux fur, Chantilly lace, crimson hardware, platform boots, NEXUS sigils"
+    )
+    assert run.checkpoint.checkpoint_id.startswith("nw-")
+    assert run.video.checkpoint_required is True
+    assert run.inspection.targets
+    assert run.model_stack[2].repo_id == "nvidia/LocateAnything-3B"
+
+
+def test_security_scan_does_not_return_payload_excerpt() -> None:
+    sample = Path(__file__).parent / "fixtures" / "sample.png"
+    scan = scan_file(str(sample))
+    assert scan["payload_excerpt"] is None
+    assert scan["status"] in {"pass", "review"}
+    assert scan["purification_actions"]
+    assert scan["export_gate"] in {"clear", "blocked"}
+
+
+def test_security_scan_flags_extension_magic_mismatch() -> None:
+    sample = Path(__file__).parent / "fixtures" / "sample.png"
+    scan = scan_file(str(sample))
+
+    assert scan["extension"] == ".png"
+    assert scan["magic"] == "unknown"
+    assert scan["status"] == "review"
+    assert scan["export_gate"] == "blocked"
+    assert any("extension does not match" in finding for finding in scan["findings"])
+
+
+def test_dashboard_regions_expose_artifacts_and_provider_cards() -> None:
+    run = build_command_center_run("gothic couture archivist, patent leather, platform boots")
+    relay = WeaverModelRelay()
+    regions = render_dashboard_regions(
+        run=run,
+        adult_mode=False,
+        scan=scan_file(None),
+        relay_status=relay.dashboard_snapshot(public_demo=True),
+    )
+
+    assert "Artifact Preview Lane" in regions["artifacts"]
+    assert "nw-preview-stage" in regions["artifacts"]
+    assert "nw-preview-ribbon" in regions["artifacts"]
+    assert "PRIMARY OUTPUT STAGE" in regions["artifacts"]
+    assert "JUDGE-SAFE DEMO OUTPUT" in regions["artifacts"]
+    assert "state: dry-run / configured / blocked / failed" in regions["artifacts"]
+    assert "Forge Operations" in regions["operations"]
+    assert "Provider Handoff Cards" in regions["providers"]
+    assert "nw-provider-meter" in regions["providers"]
+    assert "optional gateway" in regions["providers"]
+    assert "CHECKPOINTED" in regions["providers"]
+    assert "Selected: Forge" in regions["command_rail"]
+    assert "ST3GG Scan" in regions["inspector"]
+    assert "nw-weave-console" in regions["workflow"]
+    assert "Hackathon Signal" in regions["workflow"]
+    assert "Boots / heels" in regions["drawer"]
+    assert "checkpointed" in regions["drawer"]
+
+
+def test_dashboard_regions_render_with_empty_relay_and_default_scan() -> None:
+    regions = render_dashboard_regions(relay_status={}, scan=None, active_section="Forge")
+
+    assert "Forge Operations" in regions["operations"]
+    assert "not-started" in regions["operations"]
+    assert "snapshot pending" in regions["providers"]
+    assert "Selected: Forge" in regions["command_rail"]
+    assert "provider call remains checkpointed" in regions["artifacts"]
+
+
+def test_dashboard_operations_follow_selected_section() -> None:
+    relay = WeaverModelRelay()
+    sections = {
+        "Wardrobe": "Footwear focus",
+        "Lore": "Beat budget",
+        "Models": "Rotation mode",
+        "Security": "ST3GG state",
+        "Runs": "Ledger mode",
+    }
+
+    for section, marker in sections.items():
+        regions = render_dashboard_regions(
+            adult_mode=(section == "Models"),
+            scan=scan_file(None),
+            relay_status=relay.dashboard_snapshot(public_demo=section != "Models"),
+            active_section=section,
+        )
+        assert f"{section} Operations" in regions["operations"]
+        assert marker in regions["operations"]
+        assert f"Selected: {section}" in regions["command_rail"]
+
+
+def test_security_operations_distinguish_clean_scan_from_idle() -> None:
+    clean_scan = {"status": "pass", "export_gate": "clear", "findings": []}
+    html = render_operations_panel(active_section="Security", scan=clean_scan)
+
+    assert "No findings." in html
+    assert "No upload selected." not in html
+
+
+def test_command_header_exposes_governed_run_controls() -> None:
+    header = render_command_header()
+
+    assert "Raven Chronicle Active Weave" in header
+    assert "ST3GG ALWAYS ON" in header
+    assert "FLUX.2 PINNED" in header
+    assert "HUMAN CHECKPOINT" in header
+
+
+def test_dashboard_surfaces_hf_space_status_without_secrets(monkeypatch) -> None:
+    for name in ["FAL_KEY", "NETLIFY_AUTH_TOKEN", "NETLIFY_SITE_ID", "OPENAI_BASE_URL", "OPENAI_API_KEY", "MODAL_TOKEN_ID"]:
+        monkeypatch.delenv(name, raising=False)
+
+    regions = render_dashboard_regions(relay_status=WeaverModelRelay().dashboard_snapshot(public_demo=True))
+
+    assert "ZeroGPU" in regions["topbar"]
+    assert "no provider secrets" in regions["topbar"]
+    assert "HF Space" in regions["status"]
+
+
+def test_catalog_summary_reflects_adult_scope() -> None:
+    default_summary = catalog_summary(False)
+    adult_summary = catalog_summary(True)
+    assert default_summary["adult_catalog"] == "hidden"
+    assert adult_summary["adult_catalog"] == "enabled"
+    assert adult_summary["models_visible"] > default_summary["models_visible"]

tests/test_model_relay.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from nexus_visual_weaver.model_relay import WeaverModelRelay
+from nexus_visual_weaver.render import render_dashboard
+
+
+def test_pinned_lanes_do_not_rotate() -> None:
+    relay = WeaverModelRelay()
+    decision = relay.select_lane("image_generation", strategy="private_research")
+
+    assert decision.pinned is True
+    assert decision.rotatable is False
+    assert decision.primary is not None
+    assert decision.primary.repo_id == "black-forest-labs/FLUX.2-klein-9B"
+    assert decision.fallbacks == []
+    assert "rotation disabled" in decision.reason
+
+
+def test_public_private_taste_judge_respects_license_and_budget() -> None:
+    relay = WeaverModelRelay()
+
+    public = relay.select_lane("taste_judge", public_demo=True, strategy="quality_first")
+    private = relay.select_lane("taste_judge", budget=12.0, public_demo=False, strategy="private_research")
+
+    assert public.primary is not None
+    assert public.primary.params_b <= 5.0
+    assert public.primary.public_safe is True
+    assert "OFFELLIA" not in public.primary.repo_id
+    assert private.primary is not None
+    assert private.primary.model_id == "offellia-gemma4-12b-private"
+
+
+def test_audio_tts_excludes_higgs_and_keeps_one_active_model() -> None:
+    relay = WeaverModelRelay()
+
+    decision = relay.select_lane("audio_lore_tts", public_demo=True, strategy="license_safe_public")
+    selected_ids = [decision.primary.model_id] + [record.model_id for record in decision.fallbacks]
+
+    assert decision.primary is not None
+    assert decision.primary.params_b <= 5.0
+    assert decision.primary.model_id != "higgs-audio-v3-excluded"
+    assert "higgs-audio-v3-excluded" not in selected_ids
+    assert decision.primary.lane == "audio_lore_tts"
+
+
+def test_quota_exhaustion_enters_cooldown_and_uses_fallback() -> None:
+    relay = WeaverModelRelay()
+    exhausted = relay.records["hf-api-metadata-cache"]
+    exhausted.rpm_limit = 1
+    relay.record_success(exhausted.model_id)
+
+    decision = relay.select_lane("hf_catalog_research", public_demo=True, strategy="quota_saver")
+
+    assert exhausted.cooldown_until is not None
+    assert decision.primary is not None
+    assert decision.primary.model_id != exhausted.model_id
+    assert any("quota exhausted" in reason for reason in decision.skipped)
+
+
+def test_metadata_dedup_prevents_repeated_hf_lookup() -> None:
+    relay = WeaverModelRelay()
+    calls = {"count": 0}
+
+    def resolver() -> dict[str, int]:
+        calls["count"] += 1
+        return {"calls": calls["count"]}
+
+    first = relay.metadata_lookup("hf:black-forest-labs/FLUX.2-klein-9B", resolver)
+    second = relay.metadata_lookup("hf:black-forest-labs/FLUX.2-klein-9B", resolver)
+
+    assert first == second == {"calls": 1}
+    assert calls["count"] == 1
+    assert relay.get_rotation_status()["dedup_hits"] == 1
+
+
+def test_regressions_cost_speed_alias_and_failure_handlers() -> None:
+    relay = WeaverModelRelay()
+    record = relay.records["minicpm5-1b-router"]
+    original_cost_hint = record.cost_hint
+
+    speed_decision = relay.select_lane("router", strategy="speed")
+    fast_decision = relay.select_lane("router", strategy="fast")
+    relay.record_failure(record.model_id, "temporary provider error")
+    relay.record_success(record.model_id, latency_ms=120)
+
+    assert speed_decision.strategy == "latency_first"
+    assert fast_decision.strategy == "latency_first"
+    assert record.cost_hint == original_cost_hint
+    assert record.failure_count == 1
+    assert record.success_count == 1
+    assert record.health == "healthy"
+
+
+def test_context_packet_survives_video_repair_fallback() -> None:
+    relay = WeaverModelRelay()
+    first = relay.select_lane("video_repair", public_demo=False, strategy="private_research")
+    assert first.primary is not None
+
+    for _ in range(3):
+        relay.record_failure(first.primary.model_id, "modal batch unavailable")
+
+    fallback = relay.select_lane("video_repair", public_demo=False, strategy="private_research")
+
+    assert fallback.primary is not None
+    assert fallback.primary.model_id != first.primary.model_id
+    assert fallback.context_packet.lane == "video_repair"
+    assert fallback.context_packet.task == "video_repair"
+    assert any("health=unhealthy" in reason for reason in fallback.skipped)
+
+
+def test_dashboard_surfaces_gmr_pinned_models_and_fallbacks() -> None:
+    relay = WeaverModelRelay()
+    html = render_dashboard(relay_status=relay.dashboard_snapshot(public_demo=True))
+
+    assert "GMR ModelRelay" in html
+    assert "FLUX.2 pinned" in html
+    assert "LocateAnything pinned" in html
+    assert "fallback:" in html
+    assert "Rotation Safe" in html
+
+
+def test_optional_external_gateways_are_registered_but_excluded_by_default() -> None:
+    relay = WeaverModelRelay()
+
+    assert relay.records["netlify-ai-gateway-helper"].provider == "netlify"
+    assert relay.records["cloudflare-agent-helper"].provider == "cloudflare"
+    assert relay.records["fal-media-adapter"].provider == "fal"
+    assert relay.records["netflix-void-modal"].health == "healthy"
+    assert relay.records["netlify-ai-gateway-helper"].health == "excluded"
+    assert relay.records["fal-media-adapter"].health == "excluded"