Configure single-repository Xet asset storage

.gitattributes

@@ -0,0 +1,4 @@
+# Source, scripts, modern shaders and documentation stay ordinary Git text.
+* text=auto eol=lf filter=urt-code
+# Every asset, including original textual shaders/configs, is an LFS pointer.
+assets/** filter=lfs diff=lfs merge=lfs -text !eol

.githooks/pre-commit

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -eu
+exec python3 scripts/storage_policy.py check --require-setup

.githooks/pre-push

@@ -0,0 +1,8 @@
+#!/bin/sh
+set -eu
+updates=$(mktemp)
+trap 'rm -f "$updates"' EXIT HUP INT TERM
+cat > "$updates"
+python3 scripts/storage_policy.py check --require-setup
+python3 scripts/storage_policy.py push --require-setup < "$updates"
+git lfs pre-push "$@" < "$updates"

.gitignore

@@ -1 +1,9 @@
 /.cache/
+/target/
+/.work/
+/.direnv/
+__pycache__/
+*.pyc
+.DS_Store
+.env
+.env.*

assets/README.md

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f2d302ee6bed775d99b82459dbe4e9558c6d86621f1031ce4d8f901fcc2f460
+size 544

docs/README.md

@@ -2,7 +2,7 @@
 
 Planning snapshot: **2026-10-10**. Reference installation: `.cache/UrbanTerror43/`.
 
-The objective is to reverse engineer and document the supplied game, then rewrite its client and dedicated server in Rust with Bevy and Solari, running on macOS and Linux. This change contains documentation and static inventory evidence only. It does not implement the game, converters, or research tools, and the original binaries have not been launched.
+The objective is to reverse engineer and document the supplied game, then rewrite its client and dedicated server in Rust with Bevy and Solari, running on macOS and Linux. The planning pass produced documentation and static inventory evidence. Repository storage setup now also includes Git/LFS/Xet filters and commit/push guards, described in [STORAGE.md](STORAGE.md). The game, converters, and research tools remain TODO; the original game binaries have not been launched.
 
 ## Reading order
 
@@ -15,6 +15,7 @@ The objective is to reverse engineer and document the supplied game, then rewrit
 7. [Research ledger](RESEARCH_LEDGER.md): evidence conventions and templates for documenting subsequent discoveries.
 8. [Inventory evidence](inventory/README.md): machine-readable manifests, hashes, formats, maps, overrides, and case collisions.
 9. [Every installation file checklist](FILE_COVERAGE_TODO.md): explicit coverage of all 39 files, including every archive-member variant beneath the PK3 entries.
+10. [Git/Xet storage setup](STORAGE.md): one Hugging Face repository, ordinary Git code, Xet assets, and pointer/history validation.
 
 ## How to use the checklist
 

docs/STORAGE.md

@@ -0,0 +1,76 @@
+# Ordinary Git code and Xet assets in one repository
+
+The project uses one Hugging Face repository: [nmarshall/urt-rs](https://huggingface.co/nmarshall/urt-rs), SSH remote `hf` at `git@hf.co:nmarshall/urt-rs`. Source and documentation are ordinary Git text; every file beneath `assets/` is represented by a canonical Git LFS pointer, with payload transfers handled by Git Xet. A single commit identifies both code and assets. There is no separate dataset, nested asset repository, submodule, or asset revision lock.
+
+## Layout
+
+```text
+urban-terror-rs/
+  .gitattributes              # Ordinary text by default; assets/** uses LFS
+  .githooks/                  # Index/history guards and LFS upload hook
+  scripts/                    # Setup and storage-policy code, ordinary Git
+  docs/                       # Findings, plans and text inventories, ordinary Git
+  assets/
+    README.md                 # Also an LFS pointer in Git
+    original/UrbanTerror43/    # All 39 byte-identical installation files
+    extracted/                # Future per-archive content and variants
+    converted/                # Future Bevy/Solari runtime content
+    captures/                 # Future media, traces and reference fixtures
+  .cache/                     # Ignored originals, caches and scratch work
+```
+
+The initial installation copies are verified against `docs/inventory/snapshot.json`. The original `.cache/UrbanTerror43/` remains intact, preserving the evidence paths used in the research documents. Empty future output directories become tracked when the pipeline writes content. The retired, unpublished nested checkout's Git metadata is preserved under ignored `.cache/retired-assets-checkout/`; it is no longer an active repository or dependency.
+
+## Routing and enforcement
+
+The committed attributes are:
+
+```gitattributes
+* text=auto eol=lf filter=urt-code
+assets/** filter=lfs diff=lfs merge=lfs -text !eol
+```
+
+`urt-code` is a required validation/pass-through clean filter. Source, scripts, modern WGSL shader source, documentation and readable inventory manifests remain literal UTF-8 Git blobs. The filter rejects known game/media/archive/binary extensions, asset/build/cache directories, NUL bytes, non-UTF-8 content, LFS pointers outside `assets/`, and ordinary Git files larger than 2 MiB. Original shaders/configs, archives, maps, models, textures, sounds, executables and libraries belong under `assets/`, including small textual assets. Content classification uses paths, known formats and encoding; newly discovered asset formats must extend the policy before ingestion.
+
+**Every asset file uses LFS, with no metadata exceptions.** Git stores only the pointer's SHA-256 and size. The working tree retains the actual bytes. `filter=lfs` is the supported Git filter; `git-xet` is the locally registered custom transfer agent. Hugging Face negotiates Xet during upload/download, as described in its [Git/Xet integration documentation](https://huggingface.co/docs/hub/xet/using-xet-storage).
+
+The pre-commit guard validates staged blobs and staged attributes, rejecting raw asset bytes, incorrect routing, unresolved entries, symlinks and nested Git repositories. It also requires local LFS/Xet/filter configuration. The pre-push hook first checks the index and every newly reachable commit, including payloads deleted by later commits, then invokes `git lfs pre-push` with the original ref updates. Payloads are uploaded before Git references are updated. Existing inherited documentation commits are checked for content; current staged attributes are enforced for future commits.
+
+Hooks and local drivers are installed by setup; Git clones do not install these automatically. Anyone deliberately disabling hooks/configuration can bypass local protections. The committed filters and tests provide the normal workflow's enforcement; run the same checks in future CI/server protections when available. No global Git settings are modified.
+
+## Clone and configure
+
+Requirements: Git, Python 3, Git LFS, `git-xet`, and Hugging Face SSH access for remote operations.
+
+```sh
+GIT_LFS_SKIP_SMUDGE=1 git clone git@hf.co:nmarshall/urt-rs
+cd urt-rs
+python3 scripts/setup-repository.py
+git lfs pull
+git lfs fsck
+python3 scripts/storage_policy.py check --require-setup
+```
+
+A clone calls the remote `origin`; this existing checkout calls it `hf`. Substitute the configured remote in push commands. Setup is repeatable and installs repository-local filters, Xet transfer configuration and the committed hooks. It refuses to replace an unrelated existing hooks directory.
+
+## Change, verify and publish
+
+```sh
+python3 scripts/setup-repository.py
+python3 scripts/test_storage_policy.py
+# Write source under src/scripts/docs, and game content under assets/.
+git add .
+python3 scripts/storage_policy.py check --require-setup
+git lfs ls-files
+git commit -m "Describe the change"
+git lfs fsck
+git push hf main
+```
+
+The normal push hook uploads through LFS/Xet. `git show HEAD:assets/path/to/file` must show a small `version https://git-lfs.github.com/spec/v1` pointer, while opening that file in the working tree shows its actual content. Source files must show their source text directly in Git. Neither `.cache/` nor raw asset payloads belong in ordinary Git history.
+
+If an asset was staged without LFS, restore setup/attributes, run `git add --renormalize assets`, and validate again before committing. If raw payloads have already been committed in unpublished history, repair those commits before pushing; merely removing the file in a later commit will still fail the history guard. Preserve the published history when correcting an existing remote.
+
+## Planning scope
+
+This storage setup does not implement the game or conversion pipeline. The exhaustive research, unpacking, recoding, conversion, rendering and Rust/Bevy/Solari rewrite tasks remain in the planning documents. Future evidence media and converted assets use this same `assets/` policy; future code and textual findings remain ordinary Git.

scripts/setup-repository.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Install the committed storage policy in this checkout's local Git config."""
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    if not (ROOT / ".git").exists():
+        raise SystemExit("Run setup in a Git checkout, not a Nix store source copy.")
+    def git(*args):
+        return subprocess.check_output(["git", "-C", str(ROOT), *args], text=True).strip()
+    existing = subprocess.run(["git", "-C", str(ROOT), "config", "--local", "--get", "core.hooksPath"],
+                              text=True, capture_output=True).stdout.strip()
+    if existing and existing != ".githooks":
+        raise SystemExit(f"Existing hooksPath {existing!r}: integrate it before replacing hooks.")
+    git("lfs", "version")
+    git("xet", "--version")
+    git("lfs", "install", "--local", "--skip-repo")
+    git("xet", "install", "--local")
+    git("config", "--local", "lfs.basictransfersonly", "false")
+    python = shlex.quote(sys.executable)
+    script = shlex.quote(str(ROOT / "scripts/storage_policy.py"))
+    # Git shell-quotes its %f substitution. Keep it as a distinct argument.
+    git("config", "--local", "filter.urt-code.clean", f"{python} {script} clean -- %f")
+    git("config", "--local", "filter.urt-code.smudge", "cat")
+    git("config", "--local", "filter.urt-code.required", "true")
+    git("config", "--local", "core.hooksPath", ".githooks")
+    for name in ("pre-commit", "pre-push"):
+        path = ROOT / ".githooks" / name
+        path.chmod(path.stat().st_mode | 0o111)
+    print("Installed local code/LFS filters, Xet transfers and commit/push guards.")
+
+
+if __name__ == "__main__":
+    main()

scripts/storage_policy.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Fail-closed checks for code Git objects and asset LFS pointers."""
+import argparse
+import os
+from pathlib import PurePosixPath
+import re
+import subprocess
+import sys
+
+MAX_CODE_BYTES = 2 * 1024 * 1024
+PAYLOAD_SUFFIXES = frozenset(
+    ".png .jpg .jpeg .webp .gif .bmp .tga .tif .tiff .exr .hdr .svg .ico "
+    ".dds .ktx .ktx2 .texture .glb .gltf .obj .fbx .blend .mesh "
+    ".wav .ogg .mp3 .flac .bank .mp4 .webm .mov .ttf .otf .woff .woff2 "
+    ".exe .dll .pdb .so .dylib .a .lib .bin .spv .snapshot .cube "
+    ".zip .7z .rar .tar .gz .xz .zst .pdf .doc .docx .pptx .xlsx "
+    ".pk3 .bsp .aas .md3 .md4 .mdc .mds .md5mesh .md5anim .iqm .ase "
+    ".qvm .roq .icns .dat .map .prt .srf .rad .skin .shader .arena .bot .voice .crosshair".split()
+)
+PAYLOAD_DIRS = frozenset({"assets", "assets-src", "compiled-assets", "compiled-shaders",
+                          ".cache", ".work", "target", "captures"})
+POINTER = re.compile(rb"version https://git-lfs.github.com/spec/v1\noid sha256:[0-9a-f]{64}\nsize [0-9]+\n")
+
+
+def git(*args, input=None):
+    return subprocess.check_output(["git", *args], input=input)
+
+
+def check_code(path, data):
+    name = PurePosixPath(path)
+    if any(part.lower() in PAYLOAD_DIRS for part in name.parts):
+        raise ValueError(f"{path}: asset/build/cache directory is not allowed in code Git")
+    if name.suffix.lower() in PAYLOAD_SUFFIXES or ".so." in name.name.lower():
+        raise ValueError(f"{path}: asset or binary extension belongs under assets/")
+    if len(data) > MAX_CODE_BYTES:
+        raise ValueError(f"{path}: exceeds the {MAX_CODE_BYTES}-byte code limit")
+    if b"\0" in data:
+        raise ValueError(f"{path}: binary data belongs under assets/")
+    try:
+        data.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise ValueError(f"{path}: code/documentation must be UTF-8 text") from exc
+    if data.startswith(b"version https://git-lfs.github.com/spec/v1\n"):
+        raise ValueError(f"{path}: LFS pointers belong under assets/")
+
+
+def check_asset(path, data):
+    if not POINTER.fullmatch(data):
+        raise ValueError(f"{path}: asset Git object is not a canonical LFS pointer; run setup and git add --renormalize")
+
+
+def is_asset(path):
+    return PurePosixPath(path).parts[0] == "assets"
+
+
+def validate_blob(path, oid):
+    size = int(git("cat-file", "-s", oid))
+    limit = 256 if is_asset(path) else MAX_CODE_BYTES
+    if size > limit:
+        raise ValueError(f"{path}: Git blob is {size} bytes; limit is {limit}")
+    data = git("cat-file", "blob", oid)
+    (check_asset if is_asset(path) else check_code)(path, data)
+
+
+def check_index():
+    paths = []
+    for entry in git("ls-files", "--stage", "-z").split(b"\0"):
+        if not entry:
+            continue
+        header, path_bytes = entry.split(b"\t", 1)
+        permissions, oid, stage = header.decode().split()
+        path = os.fsdecode(path_bytes)
+        if stage != "0" or permissions not in {"100644", "100755"}:
+            raise ValueError(f"{path}: unresolved, symlink or nested repository entry is not allowed")
+        validate_blob(path, oid)
+        paths.append(path)
+    if paths:
+        raw = git("check-attr", "--cached", "-z", "--stdin", "filter",
+                  input=b"\0".join(os.fsencode(p) for p in paths) + b"\0").split(b"\0")
+        for i in range(0, len(raw) - 1, 3):
+            path, _, value = raw[i:i + 3]
+            path = os.fsdecode(path)
+            expected = b"lfs" if is_asset(path) else b"urt-code"
+            if value != expected:
+                raise ValueError(f"{path}: expected filter={expected.decode()}, found {value.decode()}")
+        asset_paths = [p for p in paths if is_asset(p)]
+        if asset_paths:
+            raw = git("check-attr", "--cached", "-z", "--stdin", "text", "diff", "merge",
+                      input=b"\0".join(os.fsencode(p) for p in asset_paths) + b"\0").split(b"\0")
+            for i in range(0, len(raw) - 1, 3):
+                path, attr, value = raw[i:i + 3]
+                expected = b"unset" if attr == b"text" else b"lfs"
+                if value != expected:
+                    raise ValueError(f"{os.fsdecode(path)}: incorrect asset {attr.decode()} attribute")
+
+
+def check_push():
+    # Validate all newly reachable commits, including files deleted later.
+    # A new remote branch checks its entire reachable history.
+    seen = set()
+    for line in sys.stdin:
+        _, local_oid, _, remote_oid = line.split()
+        if set(local_oid) == {"0"}:
+            continue
+        revisions = [local_oid]
+        if set(remote_oid) != {"0"}:
+            exists = subprocess.run(["git", "cat-file", "-e", remote_oid],
+                                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            if exists.returncode == 0:
+                revisions.append("^" + remote_oid)
+        for commit in git("rev-list", *revisions).decode().splitlines():
+            for entry in git("ls-tree", "-rz", commit).split(b"\0"):
+                if not entry:
+                    continue
+                header, path = entry.split(b"\t", 1)
+                permissions, kind, oid = header.decode().split()
+                if permissions not in {"100644", "100755"} or kind != "blob":
+                    raise ValueError(f"{os.fsdecode(path)}: unsupported Git tree entry")
+                key = (os.fsdecode(path), oid)
+                if key not in seen:
+                    validate_blob(*key)
+                    seen.add(key)
+
+
+def check_setup():
+    required = {
+        "filter.urt-code.required": "true",
+        "filter.lfs.required": "true",
+        "lfs.customtransfer.xet.path": "git-xet",
+        "lfs.customtransfer.xet.args": "transfer",
+        "lfs.basictransfersonly": "false",
+        "core.hooksPath": ".githooks",
+    }
+    for key, value in required.items():
+        if git("config", "--local", "--get", key).decode().strip() != value:
+            raise ValueError(f"{key}: rerun scripts/setup-repository.py")
+    for key in ("filter.urt-code.clean", "filter.lfs.clean", "filter.lfs.process"):
+        if not git("config", "--local", "--get", key).strip():
+            raise ValueError(f"{key}: missing filter driver")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=["clean", "check", "push"])
+    parser.add_argument("--require-setup", action="store_true")
+    parser.add_argument("path", nargs="?")
+    args = parser.parse_args()
+    try:
+        if args.require_setup:
+            check_setup()
+        if args.command == "clean":
+            data = sys.stdin.buffer.read(MAX_CODE_BYTES + 1)
+            check_code(args.path or "<stdin>", data)
+            sys.stdout.buffer.write(data)
+        elif args.command == "push":
+            check_push()
+        else:
+            check_index()
+    except (ValueError, subprocess.CalledProcessError) as exc:
+        print(f"Storage policy: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/test_storage_policy.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""Storage-routing tests using disposable repositories, without network access."""
+from pathlib import Path
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+import unittest
+
+import storage_policy as policy
+
+POLICY = Path(policy.__file__).resolve()
+
+
+class ContentPolicyTests(unittest.TestCase):
+    def test_code_and_readable_shader_source(self):
+        for name in ["src/main.rs", "shaders/wall.wgsl", "docs/evidence/files.csv", "config.ron"]:
+            policy.check_code(name, "// source and metadata ✓\n".encode())
+
+    def test_payload_paths_even_for_text_assets(self):
+        for name in ["assets/mesh.json", "crates/app/assets/settings.ron", ".cache/foo.txt", "captures/frame.txt"]:
+            with self.assertRaises(ValueError, msg=name):
+                policy.check_code(name, b"{}")
+
+    def test_payload_extensions_outside_asset_directory(self):
+        for name in ["foo.PNG", "src/model.glb", "texture.texture", "docs/example.svg", "plugin.so.1",
+                     "game.pk3", "cgame.qvm", "map.bsp", "map.aas", "player.MD3",
+                     "original.shader", "library.dylib", "app.icns", "font.dat"]:
+            with self.assertRaises(ValueError, msg=name):
+                policy.check_code(name, b"innocent looking text")
+
+    def test_binary_invalid_encoding_and_oversize(self):
+        for data in [b"a\0b", b"\xff", b"x" * (policy.MAX_CODE_BYTES + 1)]:
+            with self.assertRaises(ValueError):
+                policy.check_code("src/data.rs", data)
+
+    def test_asset_pointer_is_required(self):
+        pointer = b"version https://git-lfs.github.com/spec/v1\noid sha256:" + b"a" * 64 + b"\nsize 10\n"
+        policy.check_asset("mesh.json", pointer)
+        policy.check_asset("assets/README.md", pointer)
+        for data in [b"{}", pointer + b"hidden payload", b""]:
+            with self.assertRaises(ValueError):
+                policy.check_asset("mesh.json", data)
+        with self.assertRaises(ValueError):
+            policy.check_code("data.txt", pointer)
+
+    def test_nested_asset_readme_is_not_control_metadata(self):
+        with self.assertRaises(ValueError):
+            policy.check_asset("original/README.md", b"original game text\n")
+
+
+class GitIntegrationTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name)
+        self.env = {**os.environ, "GIT_CONFIG_NOSYSTEM": "1", "GIT_CONFIG_GLOBAL": os.devnull,
+                    "GIT_AUTHOR_NAME": "Test", "GIT_AUTHOR_EMAIL": "test@example.invalid",
+                    "GIT_COMMITTER_NAME": "Test", "GIT_COMMITTER_EMAIL": "test@example.invalid"}
+        # Do not inherit a parent hook's repository/index environment.
+        for key in ("GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR"):
+            self.env.pop(key, None)
+        self.git("init", "-q")
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def run_command(self, *args, input=None, success=True):
+        result = subprocess.run(args, cwd=self.root, env=self.env, input=input,
+                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        if success:
+            self.assertEqual(result.returncode, 0, result.stderr.decode(errors="replace"))
+        else:
+            self.assertNotEqual(result.returncode, 0)
+        return result
+
+    def git(self, *args, **kwargs):
+        return self.run_command("git", *args, **kwargs)
+
+    def install_code_filter(self):
+        (self.root / ".gitattributes").write_text((POLICY.parent.parent / ".gitattributes").read_text())
+        command = f"{shlex.quote(sys.executable)} {shlex.quote(str(POLICY))} clean -- %f"
+        self.git("config", "filter.urt-code.clean", command)
+        self.git("config", "filter.urt-code.smudge", "cat")
+        self.git("config", "filter.urt-code.required", "true")
+        self.git("add", ".gitattributes")
+
+    def test_git_add_preserves_source_and_quoted_filename(self):
+        self.install_code_filter()
+        name = "space ' and dollar $.rs"
+        data = b"fn main() {}\n"
+        (self.root / name).write_bytes(data)
+        self.git("add", "--", name)
+        self.assertEqual(self.git("show", ":" + name).stdout, data)
+        self.run_command(sys.executable, str(POLICY), "check")
+
+    def test_clean_filter_rejects_asset_and_missing_driver(self):
+        self.install_code_filter()
+        (self.root / "image.png").write_bytes(b"small")
+        self.git("add", "image.png", success=False)
+        (self.root / "main.rs").write_text("fn main() {}\n")
+        self.git("config", "filter.urt-code.clean", "missing-urt-filter-command")
+        self.git("add", "main.rs", success=False)
+
+    def test_index_guard_catches_bypassed_filter_and_attribute_override(self):
+        self.install_code_filter()
+        (self.root / "data.txt").write_bytes(b"binary\0data")
+        self.git("-c", "filter.urt-code.clean=cat", "add", "data.txt")
+        self.run_command(sys.executable, str(POLICY), "check", success=False)
+        self.git("-c", "filter.urt-code.clean=cat", "rm", "--cached", "data.txt")
+        (self.root / ".gitattributes").write_text("* -filter\n")
+        self.git("add", ".gitattributes")
+        self.run_command(sys.executable, str(POLICY), "check", success=False)
+
+    def test_push_guard_catches_payload_deleted_in_later_commit(self):
+        self.install_code_filter()
+        (self.root / "data.txt").write_bytes(b"binary\0data")
+        self.git("-c", "filter.urt-code.clean=cat", "add", "data.txt")
+        self.git("-c", "filter.urt-code.clean=cat", "commit", "-qm", "payload")
+        self.git("-c", "filter.urt-code.clean=cat", "rm", "data.txt")
+        self.git("commit", "-qm", "remove payload")
+        self.run_command(sys.executable, str(POLICY), "check")
+        oid = self.git("rev-parse", "HEAD").stdout.decode().strip()
+        update = f"refs/heads/main {oid} refs/heads/main {'0' * 40}\n".encode()
+        self.run_command(sys.executable, str(POLICY), "push", input=update, success=False)
+
+    def install_mixed_filters(self):
+        self.install_code_filter()
+        self.git("lfs", "install", "--local", "--skip-repo")
+        (self.root / "assets").mkdir()
+
+    def bypass_lfs(self):
+        self.git("config", "--unset", "filter.lfs.process")
+        self.git("config", "filter.lfs.clean", "cat")
+
+    def test_lfs_stores_text_asset_as_pointer_and_keeps_working_bytes(self):
+        self.install_mixed_filters()
+        data = b'{"positions": [1, 2, 3]}\n'
+        (self.root / "assets/mesh.json").write_bytes(data)
+        self.git("add", "assets/mesh.json")
+        pointer = self.git("show", ":assets/mesh.json").stdout
+        self.assertTrue(policy.POINTER.fullmatch(pointer))
+        self.assertEqual((self.root / "assets/mesh.json").read_bytes(), data)
+        self.run_command(sys.executable, str(POLICY), "check")
+        self.bypass_lfs()
+        self.git("add", "--renormalize", "assets/mesh.json")
+        self.run_command(sys.executable, str(POLICY), "check", success=False)
+
+    def test_actual_attributes_route_all_assets_and_keep_code_literal(self):
+        self.install_mixed_filters()
+        (self.root / "README.md").write_text("# Code repository\n")
+        (self.root / "assets/original").mkdir()
+        payloads = {
+            "assets/README.md": b"asset documentation\n",
+            "assets/original/README.md": b"original attribution\n",
+            "assets/original/default.cfg": b"seta snaps 20\n",
+            "assets/original/wall.shader": b"textures/wall { { map wall.tga } }\n",
+            "assets/original/game.exe": b"MZ\0game payload",
+        }
+        for name, data in payloads.items():
+            (self.root / name).write_bytes(data)
+        self.git("add", ".")
+        self.assertEqual(self.git("show", ":README.md").stdout, b"# Code repository\n")
+        for name, data in payloads.items():
+            pointer = self.git("show", ":" + name).stdout
+            self.assertTrue(policy.POINTER.fullmatch(pointer), name)
+            self.assertEqual((self.root / name).read_bytes(), data)
+        self.run_command(sys.executable, str(POLICY), "check")
+
+    def test_asset_history_rejects_payload_even_after_deletion(self):
+        self.install_mixed_filters()
+        self.bypass_lfs()
+        (self.root / "assets/config.txt").write_text("original game asset\n")
+        self.git("add", ".")
+        self.git("commit", "-qm", "raw asset")
+        self.git("rm", "assets/config.txt")
+        self.git("commit", "-qm", "remove asset")
+        self.run_command(sys.executable, str(POLICY), "check")
+        oid = self.git("rev-parse", "HEAD").stdout.decode().strip()
+        update = f"refs/heads/main {oid} refs/heads/main {'0' * 40}\n".encode()
+        self.run_command(sys.executable, str(POLICY), "push", input=update, success=False)
+
+    def test_nested_attributes_cannot_exempt_asset_payload(self):
+        self.install_mixed_filters()
+        (self.root / "assets/.gitattributes").write_text("* -filter\n")
+        (self.root / "assets/data.txt").write_text("game data\n")
+        self.git("add", ".")
+        self.run_command(sys.executable, str(POLICY), "check", success=False)
+
+    def test_symlink_is_rejected(self):
+        self.install_mixed_filters()
+        (self.root / "link").symlink_to("README.md")
+        self.git("add", "link")
+        self.run_command(sys.executable, str(POLICY), "check", success=False)
+
+    def test_missing_local_setup_is_rejected(self):
+        self.install_mixed_filters()
+        self.run_command(sys.executable, str(POLICY), "check", "--require-setup", success=False)
+
+
+if __name__ == "__main__":
+    unittest.main()