update .gitignore and remove art tools

.gitignore

@@ -10,12 +10,14 @@ scratch_*/
 # Editor and operating-system files
 .idea/
 .vscode/
+.claude
+
 node_modules/
 __pycache__/
 .DS_Store
 Thumbs.db
 desktop.ini
-
+.editorconfig
 # Paradox and tooling caches
 .launcher-cache/
 shadercache/

tools/art/README.md

@@ -1,43 +0,0 @@
-# AB art generator
-
-Read the repository root `DESIGN.md` before generating an asset. The approved AB GUI reference in `design/reference/` is the default visual reference for later GUI, icon, and related asset work.
-
-## Environment
-
-```powershell
-conda env create -f tools/art/environment.yml
-```
-
-The tool reads its key exclusively from the `OPENROUTER_API_KEY` environment variable. It never writes the key into a run manifest.
-
-Requests target OpenRouter's dedicated Images API with the fixed `openai/gpt-image-2` model. The generator uses the machine's direct network path and does not inherit `HTTP_PROXY` or `HTTPS_PROXY`.
-
-Image generation uses the OpenRouter SSE stream and only saves the final `image_generation.completed` image. Reference images are supplied as OpenRouter `input_references` data URLs. The manifest records the completed event's actual usage cost.
-
-## Generate the GUI reference candidates
-
-```powershell
-conda run -n ab-art python tools/art/generate.py generate --preset gui-style-reference --count 3
-```
-
-Candidates, the contact sheet, and the full run manifest are written under `temp/art/`. The command sends paid requests immediately.
-
-## Generate another asset
-
-Write a UTF-8 prompt file, then use the current approved reference image:
-
-```powershell
-conda run -n ab-art python tools/art/generate.py generate --prompt-file temp/art/example_prompt.txt --name example --reference design/reference/ab_gui_style_reference_v1.png
-```
-
-Repeat `--reference` to send multiple PNG reference images. Omit it only when deliberately starting a new visual direction.
-
-## Promote an approved candidate
-
-Candidate indices are one-based and match `candidate_01.png`, `candidate_02.png`, and so on.
-
-```powershell
-conda run -n ab-art python tools/art/generate.py promote --run temp/art/<run-directory> --image 1 --name ab_gui_style_reference_v1
-```
-
-Promotion writes a PNG and JSON provenance record to `design/reference/`. Existing names are never overwritten.

tools/art/environment.yml

@@ -1,7 +0,0 @@
-name: ab-art
-channels:
-  - conda-forge
-dependencies:
-  - python=3.12
-  - pillow=12.1
-  - requests=2.34

tools/art/generate.py

@@ -1,376 +0,0 @@
-#!/usr/bin/env python3
-"""Generate and promote Ab Integro visual assets through OpenRouter."""
-
-from __future__ import annotations
-
-import argparse
-import base64
-import hashlib
-import io
-import json
-import math
-import os
-import re
-import shutil
-from datetime import datetime, timezone
-from decimal import Decimal
-from pathlib import Path
-
-import requests
-from PIL import Image
-
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-ART_ROOT = Path(__file__).resolve().parent
-CANDIDATE_ROOT = REPO_ROOT / "temp" / "art"
-REFERENCE_ROOT = REPO_ROOT / "design" / "reference"
-API_BASE = "https://openrouter.ai/api/v1"
-MODEL = "openai/gpt-image-2"
-API_KEY_ENV = "OPENROUTER_API_KEY"
-MODEL_TIMEOUT = 30
-IMAGE_TIMEOUT = 600
-SLUG = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
-SIZE = re.compile(r"^(\d+)x(\d+)$")
-
-
-def read_api_key() -> str:
-    return os.environ[API_KEY_ENV]
-
-
-def sha256_file(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as source:
-        for chunk in iter(lambda: source.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def write_json(path: Path, value: dict) -> None:
-    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-
-
-def auth_headers(api_key: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {api_key}"}
-
-
-def create_session() -> requests.Session:
-    session = requests.Session()
-    session.trust_env = False
-    return session
-
-
-def fetch_model_pricing(session: requests.Session, api_key: str) -> list[dict]:
-    response = session.get(
-        f"{API_BASE}/images/models/{MODEL}/endpoints",
-        headers=auth_headers(api_key),
-        timeout=MODEL_TIMEOUT,
-    )
-    response.raise_for_status()
-    endpoint = response.json()["endpoints"][0]
-    return endpoint["pricing"]
-
-
-def load_preset(name: str, art_root: Path = ART_ROOT) -> dict:
-    path = art_root / "presets" / f"{name}.json"
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def parse_size(value: str) -> tuple[int, int]:
-    match = SIZE.fullmatch(value)
-    if match is None:
-        raise ValueError(f"invalid image size: {value}")
-    return int(match.group(1)), int(match.group(2))
-
-
-def validate_slug(value: str) -> str:
-    if SLUG.fullmatch(value) is None:
-        raise ValueError(f"invalid name: {value}")
-    return value
-
-
-def validate_image(encoded: str, expected_size: tuple[int, int]) -> bytes:
-    image_bytes = base64.b64decode(encoded, validate=True)
-    with Image.open(io.BytesIO(image_bytes)) as image:
-        image.load()
-        if image.format != "PNG":
-            raise ValueError(f"provider returned {image.format}, expected PNG")
-        if image.size != expected_size:
-            raise ValueError(f"provider returned {image.size}, expected {expected_size}")
-    return image_bytes
-
-
-def decode_stream_image(response: requests.Response, expected_size: tuple[int, int]) -> tuple[bytes, dict]:
-    completed: dict | None = None
-    for line in response.iter_lines(decode_unicode=True):
-        if not line.startswith("data: "):
-            continue
-        data = line.removeprefix("data: ")
-        if data == "[DONE]":
-            continue
-        event = json.loads(data)
-        if event["type"] in ("image_generation.completed", "image_edit.completed"):
-            completed = event
-    if completed is None:
-        raise ValueError("image stream ended without a completed event")
-    return validate_image(completed["b64_json"], expected_size), completed
-
-
-def input_references(references: list[Path]) -> list[dict]:
-    return [
-        {
-            "type": "image_url",
-            "image_url": {
-                "url": "data:image/png;base64," + base64.b64encode(path.read_bytes()).decode("ascii"),
-            },
-        }
-        for path in references
-    ]
-
-
-def request_image(
-    session: requests.Session,
-    api_key: str,
-    prompt: str,
-    size: str,
-    quality: str,
-    output_format: str,
-    references: list[Path],
-) -> tuple[bytes, str | None, str, dict]:
-    expected_size = parse_size(size)
-    fields = {
-        "model": MODEL,
-        "prompt": prompt,
-        "size": size,
-        "quality": quality,
-        "output_format": output_format,
-        "n": 1,
-    }
-    width, height = expected_size
-    endpoint = f"{API_BASE}/images"
-    payload = {
-        **fields,
-        "aspect_ratio": f"{width // math.gcd(width, height)}:{height // math.gcd(width, height)}",
-        "background": "opaque",
-        "input_references": input_references(references),
-        "stream": True,
-    }
-    response = session.post(
-        endpoint,
-        headers={**auth_headers(api_key), "Content-Type": "application/json"},
-        json=payload,
-        timeout=IMAGE_TIMEOUT,
-        stream=True,
-    )
-    response.raise_for_status()
-    image_bytes, completed = decode_stream_image(response, expected_size)
-    return image_bytes, response.headers.get("x-request-id"), endpoint, completed["usage"]
-
-
-def create_contact_sheet(images: list[Path], destination: Path) -> None:
-    cell_width = 512
-    cell_height = 341
-    columns = min(3, len(images))
-    rows = math.ceil(len(images) / columns)
-    sheet = Image.new("RGB", (columns * cell_width, rows * cell_height), "white")
-    for index, path in enumerate(images):
-        with Image.open(path) as source:
-            thumbnail = source.convert("RGB")
-            thumbnail.thumbnail((cell_width, cell_height), Image.Resampling.LANCZOS)
-            x = (index % columns) * cell_width + (cell_width - thumbnail.width) // 2
-            y = (index // columns) * cell_height + (cell_height - thumbnail.height) // 2
-            sheet.paste(thumbnail, (x, y))
-    sheet.save(destination, format="PNG")
-
-
-def run_timestamp(now: datetime | None = None) -> str:
-    instant = now or datetime.now(timezone.utc)
-    return instant.astimezone(timezone.utc).strftime("%Y%m%dT%H%M%S.%fZ")
-
-
-def generate_run(
-    *,
-    session: requests.Session,
-    api_key: str,
-    prompt: str,
-    name: str,
-    count: int,
-    size: str,
-    quality: str,
-    output_format: str,
-    references: list[Path],
-    output_root: Path = CANDIDATE_ROOT,
-    now: datetime | None = None,
-) -> Path:
-    validate_slug(name)
-    if count < 1:
-        raise ValueError("count must be at least 1")
-    parse_size(size)
-    endpoint_pricing = fetch_model_pricing(session, api_key)
-    run_dir = output_root / f"{run_timestamp(now)}_{name}"
-    run_dir.mkdir(parents=True)
-    reference_records = [
-        {"path": str(path.resolve()), "sha256": sha256_file(path)} for path in references
-    ]
-    manifest = {
-        "schema_version": 1,
-        "name": name,
-        "created_at": datetime.now(timezone.utc).isoformat(),
-        "provider": "OpenRouter",
-        "model": MODEL,
-        "prompt": prompt,
-        "parameters": {
-            "size": size,
-            "quality": quality,
-            "output_format": output_format,
-            "count": count,
-        },
-        "pricing": {"currency": "USD", "endpoint_pricing": endpoint_pricing, "actual_total": "0"},
-        "references": reference_records,
-        "outputs": [],
-    }
-    manifest_path = run_dir / "manifest.json"
-    write_json(manifest_path, manifest)
-
-    output_paths: list[Path] = []
-    for index in range(1, count + 1):
-        image_bytes, request_id, endpoint, usage = request_image(
-            session,
-            api_key,
-            prompt,
-            size,
-            quality,
-            output_format,
-            references,
-        )
-        output_path = run_dir / f"candidate_{index:02d}.png"
-        output_path.write_bytes(image_bytes)
-        output_paths.append(output_path)
-        manifest["outputs"].append(
-            {
-                "index": index,
-                "file": output_path.name,
-                "sha256": sha256_file(output_path),
-                "endpoint": endpoint,
-                "request_id": request_id,
-                "usage": usage,
-            }
-        )
-        manifest["pricing"]["actual_total"] = str(
-            sum(Decimal(str(item["usage"]["cost"])) for item in manifest["outputs"])
-        )
-        write_json(manifest_path, manifest)
-        print(f"generated {index}/{count}: {output_path}")
-
-    contact_sheet = run_dir / "contact_sheet.png"
-    create_contact_sheet(output_paths, contact_sheet)
-    manifest["contact_sheet"] = {
-        "file": contact_sheet.name,
-        "sha256": sha256_file(contact_sheet),
-    }
-    write_json(manifest_path, manifest)
-    print(f"manifest: {manifest_path}")
-    print(f"actual cost: USD {manifest['pricing']['actual_total']}")
-    return run_dir
-
-
-def promote(run_dir: Path, image_index: int, name: str, reference_root: Path = REFERENCE_ROOT) -> tuple[Path, Path]:
-    validate_slug(name)
-    manifest_path = run_dir / "manifest.json"
-    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-    output = next(item for item in manifest["outputs"] if item["index"] == image_index)
-    source_image = run_dir / output["file"]
-    target_image = reference_root / f"{name}.png"
-    target_manifest = reference_root / f"{name}.json"
-    if target_image.exists() or target_manifest.exists():
-        raise FileExistsError(f"reference already exists: {name}")
-    reference_root.mkdir(parents=True, exist_ok=True)
-    shutil.copy2(source_image, target_image)
-    promoted = {
-        "schema_version": 1,
-        "name": name,
-        "approved_at": datetime.now(timezone.utc).isoformat(),
-        "source_run": str(run_dir.resolve()),
-        "source_manifest_sha256": sha256_file(manifest_path),
-        "source_index": image_index,
-        "provider": manifest["provider"],
-        "model": manifest["model"],
-        "prompt": manifest["prompt"],
-        "parameters": manifest["parameters"],
-        "pricing": manifest["pricing"],
-        "references": manifest["references"],
-        "request_id": output["request_id"],
-        "sha256": sha256_file(target_image),
-    }
-    write_json(target_manifest, promoted)
-    return target_image, target_manifest
-
-
-def resolve_generate_args(args: argparse.Namespace) -> dict:
-    if args.preset:
-        preset = load_preset(args.preset)
-        prompt_path = ART_ROOT / preset["prompt_file"]
-        name = args.name or preset["name"]
-        count = args.count if args.count is not None else preset["default_count"]
-        size = args.size or preset["size"]
-        quality = args.quality or preset["quality"]
-        output_format = preset["output_format"]
-    else:
-        if args.name is None:
-            raise ValueError("--name is required with --prompt-file")
-        prompt_path = args.prompt_file
-        name = args.name
-        count = args.count if args.count is not None else 1
-        size = args.size or "1536x1024"
-        quality = args.quality or "high"
-        output_format = "png"
-    return {
-        "prompt": prompt_path.read_text(encoding="utf-8").strip(),
-        "name": name,
-        "count": count,
-        "size": size,
-        "quality": quality,
-        "output_format": output_format,
-        "references": args.reference,
-    }
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description=__doc__)
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    generate = subparsers.add_parser("generate", help="generate candidate images")
-    source = generate.add_mutually_exclusive_group(required=True)
-    source.add_argument("--preset")
-    source.add_argument("--prompt-file", type=Path)
-    generate.add_argument("--name")
-    generate.add_argument("--reference", type=Path, action="append", default=[])
-    generate.add_argument("--count", type=int)
-    generate.add_argument("--size")
-    generate.add_argument("--quality", choices=("low", "medium", "high"))
-
-    promote_parser = subparsers.add_parser("promote", help="promote one candidate into design/reference")
-    promote_parser.add_argument("--run", type=Path, required=True)
-    promote_parser.add_argument("--image", type=int, required=True)
-    promote_parser.add_argument("--name", required=True)
-    return parser
-
-
-def main() -> None:
-    args = build_parser().parse_args()
-    if args.command == "generate":
-        values = resolve_generate_args(args)
-        with create_session() as session:
-            run_dir = generate_run(
-                session=session,
-                api_key=read_api_key(),
-                **values,
-            )
-        print(f"run: {run_dir}")
-    else:
-        image, metadata = promote(args.run, args.image, args.name)
-        print(f"promoted: {image}")
-        print(f"metadata: {metadata}")
-
-
-if __name__ == "__main__":
-    main()

tools/art/presets/gui-style-reference.json

@@ -1,8 +0,0 @@
-{
-  "name": "gui-style-reference",
-  "prompt_file": "prompts/gui_style_reference.txt",
-  "size": "1536x1024",
-  "quality": "high",
-  "output_format": "png",
-  "default_count": 3
-}

tools/art/prompts/gui_style_reference.txt

@@ -1,13 +0,0 @@
-Create a polished visual style reference sheet for the historical grand strategy game mod Ab Integro.
-
-The image is an orthographic product-design board on a clean neutral white background. Arrange a coherent family of UI parts with generous separation and no overlap: one complete early-modern event dialog as the main object, one detached title plaque, three compact button states, several straight border segments, two corner ornaments, one circular seal, four material samples, and ten plain color swatches.
-
-The central concept is a global early-modern archive assembled by navigators, clerks, merchants, scholars, and imperial administrators. The UI must feel like a precise archival instrument used for centuries, not a European palace frame and not a theatrical prop.
-
-Use these exact material colors as the controlling palette: near-black indigo #101820 for the main lacquered or dyed-leather surfaces; charcoal brown-black #181817 for recessed content areas; aged brass #9A7441 for narrow structural lines and nodes; dark copper #6E4938 for metal shadows and wear; warm paper #D8C7A2; warm off-white #E3DDD0 for primary typography placeholders; secondary gray #AFA99E; restrained cinnabar #883431 for sovereignty, warning, and seals; malachite #31584B for economic accents; ultramarine #36556E for diplomatic and scholarly accents.
-
-Use narrow double-line aged-brass frames, precise engraved linework, subtle map latitude arcs and copperplate hatching, four-way rosette or compass-star corner nodes, deep indigo lacquer and embossed leather, restrained paper fibers, an impressed seal, and believable small metal fasteners. Ornament must be globally legible through abstract shared geometry rather than a collage of culture-specific motifs.
-
-The complete event dialog must have a thin outer frame, a dark indigo title plaque fixed by small brass studs, a recessed charcoal content field, a framed image placeholder, orderly typographic placeholder lines, and a stable bottom action area. Use placeholder bars and lines only. Do not render readable interface copy, captions, annotations, component names, arrows, measurements, legends, logos, watermarks, or explanatory text anywhere on the sheet.
-
-The result must look production-ready for Europa Universalis IV: dense but readable, materially rich but restrained, historically grounded between the fifteenth and eighteenth centuries, globally oriented, and distinct from vanilla EU4. Avoid thick bright-gold rococo frames, oversized curled foliage, gemstones, fantasy runes, steampunk machinery, modern flat UI, glassmorphism, neon light, glowing edges, blue-purple gradients, excessive distressing, burned paper, and decorative clutter.

tools/art/test/test_generate.py

@@ -1,206 +0,0 @@
-from __future__ import annotations
-
-import base64
-import io
-import json
-import os
-import sys
-import tempfile
-import unittest
-from datetime import datetime, timezone
-from pathlib import Path
-from unittest.mock import patch
-
-import requests
-from PIL import Image
-
-
-ART_ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ART_ROOT))
-
-import generate
-
-
-def png_bytes(size: tuple[int, int] = (64, 64), color: str = "#101820") -> bytes:
-    buffer = io.BytesIO()
-    Image.new("RGB", size, color).save(buffer, format="PNG")
-    return buffer.getvalue()
-
-
-class FakeResponse:
-    def __init__(self, payload: dict, status: int = 200, request_id: str = "req_test") -> None:
-        self.payload = payload
-        self.status = status
-        self.headers = {"x-request-id": request_id}
-
-    def json(self) -> dict:
-        return self.payload
-
-    def raise_for_status(self) -> None:
-        if self.status >= 400:
-            raise requests.HTTPError(f"HTTP {self.status}")
-
-    def iter_lines(self, decode_unicode: bool = False):
-        encoded = self.payload["data"][0]["b64_json"]
-        yield "event: image_generation.completed"
-        yield "data: " + json.dumps(
-            {
-                "type": "image_generation.completed",
-                "b64_json": encoded,
-                "usage": self.payload["usage"],
-            }
-        )
-
-
-class FakeSession:
-    def __init__(self, image_responses: list[FakeResponse] | None = None, model_status: int = 200) -> None:
-        self.image_responses = list(image_responses or [])
-        self.model_status = model_status
-        self.get_calls: list[dict] = []
-        self.post_calls: list[dict] = []
-
-    def get(self, url: str, **kwargs) -> FakeResponse:
-        self.get_calls.append({"url": url, **kwargs})
-        return FakeResponse(
-            {
-                "endpoints": [
-                    {"pricing": [{"billable": "output_image", "unit": "token", "cost_usd": 0.00003}]}
-                ]
-            },
-            status=self.model_status,
-        )
-
-    def post(self, url: str, **kwargs) -> FakeResponse:
-        call = {"url": url, **kwargs}
-        if "files" in call:
-            call["file_snapshots"] = [
-                (field, spec[0], spec[1].read(), spec[2]) for field, spec in call["files"]
-            ]
-        self.post_calls.append(call)
-        return self.image_responses.pop(0)
-
-
-def image_response(size: tuple[int, int] = (64, 64), request_id: str = "req_test") -> FakeResponse:
-    encoded = base64.b64encode(png_bytes(size)).decode("ascii")
-    return FakeResponse(
-        {"data": [{"b64_json": encoded}], "usage": {"cost": 0.13}},
-        request_id=request_id,
-    )
-
-
-class GeneratorTests(unittest.TestCase):
-    def test_session_does_not_inherit_proxy_environment(self) -> None:
-        with generate.create_session() as session:
-            self.assertFalse(session.trust_env)
-
-    def test_generation_writes_candidates_contact_sheet_and_secret_free_manifest(self) -> None:
-        with tempfile.TemporaryDirectory() as temp:
-            root = Path(temp)
-            session = FakeSession([image_response(request_id="req_1"), image_response(request_id="req_2")])
-            run_dir = generate.generate_run(
-                session=session,
-                api_key="secret-test-key",
-                prompt="test prompt",
-                name="test-run",
-                count=2,
-                size="64x64",
-                quality="high",
-                output_format="png",
-                references=[],
-                output_root=root,
-                now=datetime(2026, 8, 1, tzinfo=timezone.utc),
-            )
-
-            self.assertTrue((run_dir / "candidate_01.png").is_file())
-            self.assertTrue((run_dir / "candidate_02.png").is_file())
-            self.assertTrue((run_dir / "contact_sheet.png").is_file())
-            manifest_text = (run_dir / "manifest.json").read_text(encoding="utf-8")
-            self.assertNotIn("secret-test-key", manifest_text)
-            manifest = json.loads(manifest_text)
-            self.assertEqual(manifest["pricing"]["actual_total"], "0.26")
-            self.assertEqual([item["request_id"] for item in manifest["outputs"]], ["req_1", "req_2"])
-            self.assertEqual(session.post_calls[0]["json"]["model"], generate.MODEL)
-            self.assertTrue(session.post_calls[0]["json"]["stream"])
-            self.assertEqual(session.post_calls[0]["json"]["aspect_ratio"], "1:1")
-            self.assertEqual(session.post_calls[0]["headers"]["Authorization"], "Bearer secret-test-key")
-
-    def test_reference_image_uses_openrouter_input_references(self) -> None:
-        with tempfile.TemporaryDirectory() as temp:
-            reference = Path(temp) / "reference.png"
-            reference.write_bytes(png_bytes())
-            session = FakeSession([image_response()])
-            result, request_id, endpoint, usage = generate.request_image(
-                session,
-                "secret",
-                "edit prompt",
-                "64x64",
-                "high",
-                "png",
-                [reference],
-            )
-            call = session.post_calls[0]
-            self.assertEqual(result, png_bytes())
-            self.assertEqual(request_id, "req_test")
-            self.assertEqual(usage["cost"], 0.13)
-            self.assertTrue(endpoint.endswith("/images"))
-            self.assertEqual(call["json"]["model"], generate.MODEL)
-            self.assertEqual(call["json"]["input_references"][0]["type"], "image_url")
-            self.assertTrue(call["json"]["input_references"][0]["image_url"]["url"].startswith("data:image/png;base64,"))
-
-    def test_invalid_preset_fails(self) -> None:
-        with tempfile.TemporaryDirectory() as temp:
-            with self.assertRaises(FileNotFoundError):
-                generate.load_preset("missing", Path(temp))
-
-    def test_missing_environment_key_fails(self) -> None:
-        with patch.dict(os.environ, {}, clear=True):
-            with self.assertRaises(KeyError):
-                generate.read_api_key()
-
-    def test_http_error_fails(self) -> None:
-        session = FakeSession(model_status=500)
-        with self.assertRaises(requests.HTTPError):
-            generate.fetch_model_pricing(session, "secret")
-
-    def test_missing_base64_fails(self) -> None:
-        response = FakeResponse({"data": [{}], "usage": {"cost": 0.13}})
-        response.iter_lines = lambda decode_unicode=False: iter(
-            ("data: " + json.dumps({"type": "image_generation.completed"}),)
-        )
-        with self.assertRaises(KeyError):
-            generate.decode_stream_image(response, (64, 64))
-
-    def test_stream_without_completed_event_fails(self) -> None:
-        response = FakeResponse({"data": [{"b64_json": base64.b64encode(png_bytes()).decode("ascii")}]})
-        response.iter_lines = lambda decode_unicode=False: iter(("data: [DONE]",))
-        with self.assertRaises(ValueError):
-            generate.decode_stream_image(response, (64, 64))
-
-    def test_promote_records_provenance_and_refuses_overwrite(self) -> None:
-        with tempfile.TemporaryDirectory() as temp:
-            root = Path(temp)
-            run_dir = root / "run"
-            reference_root = root / "references"
-            run_dir.mkdir()
-            image = run_dir / "candidate_01.png"
-            image.write_bytes(png_bytes())
-            manifest = {
-                "provider": "OpenRouter",
-                "model": generate.MODEL,
-                "prompt": "prompt",
-                "parameters": {"size": "64x64", "quality": "high", "output_format": "png", "count": 1},
-                "pricing": {"currency": "USD", "endpoint_pricing": [], "actual_total": "0"},
-                "references": [],
-                "outputs": [{"index": 1, "file": image.name, "request_id": "req_1"}],
-            }
-            generate.write_json(run_dir / "manifest.json", manifest)
-
-            target, metadata = generate.promote(run_dir, 1, "reference_v1", reference_root)
-            self.assertTrue(target.is_file())
-            self.assertEqual(json.loads(metadata.read_text(encoding="utf-8"))["sha256"], generate.sha256_file(target))
-            with self.assertRaises(FileExistsError):
-                generate.promote(run_dir, 1, "reference_v1", reference_root)
-
-
-if __name__ == "__main__":
-    unittest.main()