@crvouga/dev-fleet 0.0.0-stage → 0.2.0

package/cliproxy/requirements.lock

@@ -0,0 +1,78 @@
+# Manager LaunchAgent Python dependencies (hash-locked). Regenerate with:
+#   echo pyyaml==VERSION | uv pip compile - --generate-hashes --universal --no-header
+
+pyyaml==6.0.3 \
+    --hash=sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c \
+    --hash=sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a \
+    --hash=sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3 \
+    --hash=sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956 \
+    --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \
+    --hash=sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c \
+    --hash=sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65 \
+    --hash=sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a \
+    --hash=sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0 \
+    --hash=sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b \
+    --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \
+    --hash=sha256:22ba7cfcad58ef3ecddc7ed1db3409af68d023b7f940da23c6c2a1890976eda6 \
+    --hash=sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7 \
+    --hash=sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e \
+    --hash=sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007 \
+    --hash=sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310 \
+    --hash=sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4 \
+    --hash=sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9 \
+    --hash=sha256:3ff07ec89bae51176c0549bc4c63aa6202991da2d9a6129d7aef7f1407d3f295 \
+    --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \
+    --hash=sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0 \
+    --hash=sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e \
+    --hash=sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac \
+    --hash=sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9 \
+    --hash=sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7 \
+    --hash=sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35 \
+    --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \
+    --hash=sha256:5cf4e27da7e3fbed4d6c3d8e797387aaad68102272f8f9752883bc32d61cb87b \
+    --hash=sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69 \
+    --hash=sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5 \
+    --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \
+    --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \
+    --hash=sha256:6344df0d5755a2c9a276d4473ae6b90647e216ab4757f8426893b5dd2ac3f369 \
+    --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \
+    --hash=sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824 \
+    --hash=sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198 \
+    --hash=sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065 \
+    --hash=sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c \
+    --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \
+    --hash=sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764 \
+    --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \
+    --hash=sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b \
+    --hash=sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00 \
+    --hash=sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac \
+    --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \
+    --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \
+    --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \
+    --hash=sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3 \
+    --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \
+    --hash=sha256:9c57bb8c96f6d1808c030b1687b9b5fb476abaa47f0db9c0101f5e9f394e97f4 \
+    --hash=sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b \
+    --hash=sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf \
+    --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \
+    --hash=sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702 \
+    --hash=sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8 \
+    --hash=sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788 \
+    --hash=sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da \
+    --hash=sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d \
+    --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \
+    --hash=sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c \
+    --hash=sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba \
+    --hash=sha256:c2514fceb77bc5e7a2f7adfaa1feb2fb311607c9cb518dbc378688ec73d8292f \
+    --hash=sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917 \
+    --hash=sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5 \
+    --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \
+    --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \
+    --hash=sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b \
+    --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \
+    --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \
+    --hash=sha256:efd7b85f94a6f21e4932043973a7ba2613b059c4a000551892ac9f1d11f5baf3 \
+    --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \
+    --hash=sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926 \
+    --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0
+    # via -r requirements.in

package/cliproxy/scripts/accounts.py

@@ -0,0 +1,38 @@
+"""Account routing: each signed-in provider account gets its own model prefix.
+
+The proxy's credential files are the only source of truth for accounts. A
+credential of a routed type is given the prefix `<type>-<email>`, so a client
+that asks for `<type>-<email>/<model>` is served only by that account, and the
+proxy's model list tells every client which accounts exist. Unprefixed models
+keep using the whole fill-first pool.
+"""
+import json
+import pathlib
+import re
+
+# Provider credential types that T3 offers once per account.
+ROUTED = ('claude', 'codex', 'antigravity')
+
+
+def prefix(kind, email):
+    """The model prefix for one credential, or None when it is not routed."""
+    if kind in ROUTED and isinstance(email, str) and re.fullmatch(r'[^\s@/]{1,64}@[^\s@/]{1,255}', email):
+        return kind + '-' + email
+    return None
+
+
+def pending(auths):
+    """[(credential file name, prefix)] for credentials without their prefix.
+    Reads only type, email and prefix; never a token."""
+    result = []
+    for path in sorted(pathlib.Path(auths).glob('*.json')):
+        try:
+            data = json.loads(path.read_text())
+        except (OSError, ValueError):
+            continue
+        if not isinstance(data, dict):
+            continue
+        wanted = prefix(data.get('type'), data.get('email'))
+        if wanted and data.get('prefix') != wanted:
+            result.append((path.name, wanted))
+    return result

package/cliproxy/scripts/audit.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""Require runtime code and unit links to resolve to clean, Git-tracked files."""
+
+import sys
+
+sys.dont_write_bytecode = True
+
+import pathlib as _pathlib
+
+sys.path.insert(0, str(_pathlib.Path(__file__).resolve().parent))
+import cliproxy_host
+
+import hashlib
+import json
+import os
+import pathlib
+import subprocess
+import sys
+
+
+def quiet(args):
+    try:
+        return (
+            subprocess.run(
+                args, capture_output=True, timeout=30, check=False
+            ).returncode
+            == 0
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def audit(root, check_units=True, backend=None, run=quiet):
+    """Check provenance; with check_units, also the platform's unit links (and,
+    for launchd, that the required agents are loaded in gui/$UID)."""
+    manifest = json.loads((root / "INSTALLATION.json").read_text())
+    errors = []
+    if manifest.get("schema_version") != 2:
+        return manifest, [
+            "legacy copied-code installation; reinstall from the repository"
+        ]
+    worktree = pathlib.Path(manifest["worktree"])
+    command = [
+        "git",
+        "--no-optional-locks",
+        "-c",
+        "safe.directory=" + str(worktree),
+        "-C",
+        str(worktree),
+    ]
+    revision = (
+        subprocess.check_output(command + ["rev-parse", "HEAD"], stderr=subprocess.PIPE)
+        .decode()
+        .strip()
+    )
+    tracked = set(
+        subprocess.check_output(
+            command + ["ls-files", "-z", "--", manifest["package"]],
+            stderr=subprocess.PIPE,
+        )
+        .decode()
+        .strip("\0")
+        .split("\0")
+    )
+    if revision != manifest["revision"]:
+        errors.append("deployment worktree revision")
+    if subprocess.check_output(
+        command + ["status", "--porcelain", "--", manifest["package"]],
+        stderr=subprocess.PIPE,
+    ).strip():
+        errors.append("deployment worktree has local changes")
+    # Resolve once: macOS temporary/home paths may route through symlinks.
+    source = worktree.resolve() / manifest["package"]
+    units = (backend or cliproxy_host.backend()) if check_units else None
+    for name, expected in manifest["files"].items():
+        path = root / name
+        if (
+            manifest["package"] + "/" + name not in tracked
+            or not path.is_file()
+            or path.resolve() != source / name
+            or hashlib.sha256(path.read_bytes()).hexdigest() != expected
+        ):
+            errors.append(name)
+        if units and name.startswith(units.source_directory + "/"):
+            unit = units.unit_directory / path.name
+            if not unit.is_symlink() or unit.resolve() != source / name:
+                errors.append(str(unit))
+    for name, expected in manifest["generated"].items():
+        if hashlib.sha256((root / name).read_bytes()).hexdigest() != expected:
+            errors.append(name)
+    if units and units.name == "launchd":
+        required = [units.service, *units.scheduled]
+        if not (root / "state/secrets/recovery-confirmed").exists():
+            required = [label for label in required if label not in units.recovery_gated]
+        for label in required:
+            if not units.loaded(label, run):
+                errors.append("not loaded: " + units.domain + "/" + label)
+    for folder in ["scripts", "clients", "systemd", "launchd"]:
+        for path in (root / folder).rglob("*"):
+            if (
+                (root / folder).is_dir()
+                and path.is_file()
+                and "__pycache__" not in path.parts
+                and str(path.relative_to(root)) not in manifest["files"]
+            ):
+                errors.append("unmanaged: " + str(path.relative_to(root)))
+    return manifest, errors
+
+
+if __name__ == "__main__":
+    try:
+        manifest, errors = audit(cliproxy_host.default_root())
+        if errors:
+            print("Code is not clean tracked repository source: " + ", ".join(errors))
+            sys.exit(1)
+        print(
+            "Runtime code is Git-tracked at crvouga/dev-fleet commit "
+            + manifest["revision"]
+        )
+    except (OSError, ValueError, KeyError, subprocess.CalledProcessError):
+        sys.exit(
+            "Git source unavailable or provenance invalid; reinstall from the repository."
+        )

package/cliproxy/scripts/backup

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+import sys
+
+sys.dont_write_bytecode = True
+
+import pathlib as _pathlib
+
+sys.path.insert(0, str(_pathlib.Path(__file__).resolve().parent))
+import cliproxy_host
+
+import datetime, json, os, pathlib, subprocess, sys, tempfile, fcntl, importlib.util
+import checkpoint
+import retention
+
+root = cliproxy_host.default_root().resolve()
+os.umask(0o077)
+os.environ["PATH"] = str(root / "scripts") + ":" + os.environ["PATH"]
+state = root / "state"
+status = state / "status"
+status.mkdir(parents=True, exist_ok=True)
+lock = open(status / "operation.lock", "w")
+if os.geteuid() == 0:
+    os.chown(status / "operation.lock", 1000, 1000)
+fcntl.flock(lock, fcntl.LOCK_EX)
+command = sys.argv[1] if len(sys.argv) > 1 else "backup"
+failure = status / (
+    "backup-failed"
+    if command == "backup"
+    else "backup-check-failed"
+    if command in ["check", "check-full"]
+    else "gc-failed"
+    if command == "gc"
+    else "backup-operation-failed"
+)
+
+
+def run(args, **kw):
+    return subprocess.run(args, check=True, **kw)
+
+
+def write(path, text):
+    path.write_text(text)
+    if os.geteuid() == 0:
+        os.chown(path, 1000, 1000)
+
+
+try:
+    retention.staging(root)
+    spec = importlib.util.spec_from_file_location(
+        "vault_access", root / "scripts/vault-access.py"
+    )
+    vault = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(vault)
+    vault.renew()
+    cfg = vault.credentials()
+    identity = {k: cfg[k] for k in ["S3_ENDPOINT", "S3_BUCKET", "S3_REGION"]}
+    destination = state / "repository.json"
+    if destination.exists() and json.loads(destination.read_text()) != identity:
+        sys.exit(
+            "Vault repository location changed. Review and update state/repository.json explicitly; refusing to silently switch repositories."
+        )
+    if not destination.exists() and command != "restore-cache":
+        write(destination, json.dumps(identity) + "\n")
+    if not cfg["S3_ENDPOINT"].startswith("https://"):
+        raise ValueError("Storage endpoint must use TLS")
+    env = os.environ.copy()
+    env.update(
+        AWS_ACCESS_KEY_ID=cfg["S3_ACCESS_KEY_ID"],
+        AWS_SECRET_ACCESS_KEY=cfg["S3_SECRET_ACCESS_KEY"],
+        AWS_DEFAULT_REGION=cfg["S3_REGION"],
+        RESTIC_REPOSITORY="s3:"
+        + cfg["S3_ENDPOINT"].rstrip("/")
+        + "/"
+        + cfg["S3_BUCKET"]
+        + "/cliproxy-fleet/restic",
+        RESTIC_PASSWORD_FILE=str(state / "secrets/restic-password"),
+    )
+
+    def restic(*args, **kw):
+        return run(
+            ["restic", "-o", "s3.bucket-lookup=path", *args, "--no-cache"],
+            env=env,
+            **kw,
+        )
+
+    if command == "init":
+        restic("init")
+    elif command == "check":
+        restic("check", "--read-data-subset=10%")
+    elif command == "check-full":
+        restic("check", "--read-data")
+    elif command == "gc":
+        retention.prune(restic)
+        removed = retention.revisions(root)
+        write(
+            status / "gc-success.json",
+            json.dumps(
+                {
+                    "time": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                    "retired_worktrees": removed,
+                }
+            )
+            + "\n",
+        )
+        print(
+            "Cloud garbage collected and integrity checked; retired clean worktrees removed:",
+            removed,
+        )
+    elif command == "snapshots":
+        restic("snapshots")
+    elif command == "restore":
+        if len(sys.argv) != 4:
+            sys.exit("Usage: backup restore SNAPSHOT EMPTY_DIRECTORY")
+        target = pathlib.Path(sys.argv[3]).resolve()
+        if target.exists() and any(target.iterdir()):
+            sys.exit("Restore target must be empty.")
+        target.mkdir(parents=True, exist_ok=True)
+        restic("restore", sys.argv[2], "--target", str(target), "--verify")
+    elif command == "restore-cache":
+        if sys.argv[2:] != ["--previous-node-stopped"]:
+            raise ValueError("Explicit previous-node-stopped acknowledgement required")
+        # This local check complements operator fencing of the previous machine.
+        active = subprocess.check_output(
+            [
+                "docker",
+                "compose",
+                "--profile",
+                "portable-endpoint",
+                "--profile",
+                "public-endpoint",
+                "ps",
+                "--status",
+                "running",
+                "--services",
+            ],
+            cwd=root,
+            text=True,
+        ).strip()
+        if active:
+            raise ValueError("Stop the local stack before recovery")
+        with tempfile.TemporaryDirectory(
+            prefix="restore-", dir=root / "recovery"
+        ) as temporary:
+            target = pathlib.Path(temporary)
+            restic(
+                "restore",
+                "latest",
+                "--tag",
+                "cliproxy-checkpoint-v1",
+                "--host",
+                "cliproxy-primary",
+                "--target",
+                str(target),
+                "--verify",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            payload = checkpoint.locate(target)
+            saved_destination = payload / "state/repository.json"
+            if (
+                not saved_destination.exists()
+                or json.loads(saved_destination.read_text()) != identity
+            ):
+                raise ValueError("Recovered repository identity differs from Vault")
+            checkpoint.hydrate(payload, state)
+        print(
+            "Cloud checkpoint recovered into empty cache. No services started. Run install, then health verification."
+        )
+    elif command == "backup":
+        if not (state / "secrets/recovery-confirmed").exists():
+            sys.exit(
+                "Store Restic password independently; then create state/secrets/recovery-confirmed."
+            )
+
+        recovery = root / "recovery"
+        recovery.mkdir(mode=0o700, exist_ok=True)
+        if os.geteuid() == 0:
+            os.chown(recovery, 1000, 1000)
+        with tempfile.TemporaryDirectory(
+            prefix="checkpoint-", dir=recovery
+        ) as temporary:
+            captured = pathlib.Path(temporary) / "payload"
+            # The stack keeps running: a live, verified-stable copy.
+            checkpoint.capture(root, captured)
+            result = restic(
+                "backup",
+                "--json",
+                str(captured),
+                "--tag",
+                "cliproxy-fleet",
+                "--tag",
+                "cliproxy-checkpoint-v1",
+                "--host",
+                "cliproxy-primary",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            summaries = [json.loads(line) for line in result.stdout.splitlines()]
+            summary = next(
+                item
+                for item in reversed(summaries)
+                if item.get("message_type") == "summary"
+            )
+            snapshot = summary["snapshot_id"]
+            if not isinstance(snapshot, str) or not snapshot:
+                raise ValueError("Missing snapshot acknowledgement")
+            print("Complete encrypted checkpoint saved:", snapshot)
+        retention.forget(restic)
+        write(
+            status / "backup-success.json",
+            json.dumps(
+                {
+                    "snapshot": snapshot,
+                    "time": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                    "destination": "configured R2 bucket / cliproxy-fleet/restic",
+                }
+            )
+            + "\n",
+        )
+    else:
+        sys.exit(
+            "Use init, backup, gc, snapshots, check, check-full, restore SNAPSHOT EMPTY_DIRECTORY, or restore-cache --previous-node-stopped."
+        )
+except (Exception, SystemExit):
+    write(failure, datetime.datetime.now(datetime.timezone.utc).isoformat() + "\n")
+    sys.exit(
+        "Backup operation failed. Inspect systemd unit status; credentials suppressed."
+    )
+else:
+    failure.unlink(missing_ok=True)
+
+finally:
+    lock.close()

package/cliproxy/scripts/check.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Offline syntax/config checks; no cloud access or running deployment required."""
+
+import sys
+
+sys.dont_write_bytecode = True
+
+
+import ast
+import json
+import pathlib
+import re
+import subprocess
+
+root = pathlib.Path(__file__).resolve().parent.parent
+for directory in ["scripts", "clients", "tests"]:
+    for path in (root / directory).rglob("*"):
+        if not path.is_file() or "__pycache__" in path.parts:
+            continue
+        data = path.read_text()
+        if path.suffix == ".py" or data.startswith("#!/usr/bin/env python3"):
+            ast.parse(data, filename=str(path))
+        elif data.startswith("#!/usr/bin/env bash") or data.startswith("#!/bin/bash"):
+            subprocess.run(["bash", "-n", str(path)], check=True)
+images = json.loads((root / "image.lock.json").read_text())
+assert all(
+    re.fullmatch(r"[a-z0-9/.-]+@sha256:[0-9a-f]{64}", image)
+    for image in images.values()
+)
+sys.path.insert(0, str(root / "scripts"))
+from modelhealth import config as model_config
+
+model_config.load(root / "models.json")  # declarative model-health contract
+print("Python/shell syntax, immutable image pins and models.json passed.")