Add test inventory + checkpoint test runner

docs/testing/test_inventory.md: honest, current list of what automated
coverage actually exists (38 backend pytest tests across 2 files, 0 Godot
tests merged yet) and what doesn't (no integration/endpoint tests at all,
no coverage yet for the in-review RS256/moderation work) -- verified
against a genuinely fresh checkout + fresh Postgres, not just read off the
file tree.

scripts/run_checkpoint_tests.py: runs the whole inventory in one shot --
throwaway Postgres, migrations, pytest, then starts the backend server and
runs every scripts/smoke_test_*.gd against it headlessly. Verified working
both with and without a smoke test present (temporarily tested against
PC1's not-yet-merged scripts/api_client.gd + smoke_test_api.gd, removed
before this commit -- that PR carries its own files).

docs/testing/README.md: what running this at a Package Checkpoint review
does and doesn't prove, and how to grow the inventory as real coverage
gets added.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

backend/.env.example

@@ -4,13 +4,10 @@ DATABASE_URL=postgresql+asyncpg://agp_user:agp_password@localhost:5432/agp_db
 # Redis
 REDIS_URL=redis://localhost:6379/0
 
-# JWT / Auth
+# JWT
-ALGORITHM=RS256
+SECRET_KEY=change-me-to-a-secure-random-string
-ACCESS_TOKEN_EXPIRE_MINUTES=60
+ALGORITHM=HS256
-REFRESH_TOKEN_EXPIRE_DAYS=30
+ACCESS_TOKEN_EXPIRE_MINUTES=30
-# Directory where the RSA keypair is loaded/generated at runtime.
-# Defaults to ~/.agp/keys (outside the repo). Keys are never committed to git.
-RSA_KEY_DIR=~/.agp/keys
 
 # App
 APP_NAME=AGP Backend

backend/alembic/versions/0003_add_refresh_tokens_table.py

@@ -1,36 +0,0 @@
-"""add refresh_tokens table
-
-Revision ID: 0003_add_refresh_tokens_table
-Revises: 0002_add_date_of_birth_to_users
-Create Date: 2025-07-25 00:00:00.000000
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-# revision identifiers, used by Alembic.
-revision: str = "0003_add_refresh_tokens_table"
-down_revision: Union[str, None] = "0002_add_date_of_birth_to_users"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Create the refresh_tokens table."""
-    op.create_table(
-        "refresh_tokens",
-        sa.Column("id", sa.String(36), primary_key=True),
-        sa.Column("user_id", sa.Integer(), sa.ForeignKey("users.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("token", sa.String(512), unique=True, index=True, nullable=False),
-        sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
-        sa.Column("is_active", sa.Boolean(), server_default=sa.text("true"), nullable=False),
-        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
-    )
-
-
-def downgrade() -> None:
-    """Drop the refresh_tokens table."""
-    op.drop_table("refresh_tokens")

backend/app/config.py

@@ -1,56 +1,10 @@
 """Application configuration via pydantic-settings."""
 
 from functools import lru_cache
-from pathlib import Path
 
-from cryptography.hazmat.primitives.asymmetric.rsa import (
-    RSAPrivateKey,
-    RSAPublicKey,
-    generate_private_key,
-)
-from cryptography.hazmat.primitives.serialization import (
-    Encoding,
-    NoEncryption,
-    PrivateFormat,
-    PublicFormat,
-    load_pem_private_key,
-    load_pem_public_key,
-)
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
-def _load_or_generate_rsa_keys(key_dir: Path) -> tuple[bytes, bytes]:
-    """Load existing RSA keys or generate a new pair.
-
-    Keys are stored as PEM files in *key_dir*.  The directory is created
-    if it does not exist.  Files are named ``private.pem`` and
-    ``public.pem`` and are **not** committed to git.
-    """
-    private_path = key_dir / "private.pem"
-    public_path = key_dir / "public.pem"
-
-    if private_path.exists() and public_path.exists():
-        private_pem = private_path.read_bytes()
-        public_pem = public_path.read_bytes()
-    else:
-        # Generate a new 2048-bit RSA key pair
-        private_key = generate_private_key(public_exponent=65537, key_size=2048)
-        private_pem = private_key.private_bytes(
-            Encoding.PEM,
-            PrivateFormat.PKCS8,
-            NoEncryption(),
-        )
-        public_pem = private_key.public_key().public_bytes(
-            Encoding.PEM,
-            PublicFormat.SubjectPublicKeyInfo,
-        )
-        key_dir.mkdir(parents=True, exist_ok=True)
-        private_path.write_bytes(private_pem)
-        public_path.write_bytes(public_pem)
-
-    return private_pem, public_pem
-
-
 class Settings(BaseSettings):
     # App
     APP_NAME: str = "AGP Backend"
@@ -64,13 +18,11 @@ class Settings(BaseSettings):
     REDIS_URL: str = "redis://localhost:6379/0"
 
     # JWT / Auth
-    ALGORITHM: str = "RS256"
+    # NOTE: production must override SECRET_KEY with a secure random value
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60
+    # (e.g. `python -c "import secrets; print(secrets.token_urlsafe(32))"`)
-    REFRESH_TOKEN_EXPIRE_DAYS: int = 30
+    SECRET_KEY: str = "change-me-to-a-secure-random-string"
-
+    ALGORITHM: str = "HS256"
-    # RS256 key storage.  Defaults to a directory outside the repo so the
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
-    # generated keypair is never accidentally committed.
-    RSA_KEY_DIR: str = str(Path.home() / ".agp" / "keys")
 
     # CORS
     CORS_ORIGINS: str = "http://localhost:8080,http://localhost:3000"
@@ -90,32 +42,6 @@ class Settings(BaseSettings):
     def cors_origins_list(self) -> list[str]:
         return [origin.strip() for origin in self.CORS_ORIGINS.split(",")]
 
-    @property
-    def rsa_key_dir(self) -> Path:
-        return Path(self.RSA_KEY_DIR)
-
-    @property
-    def private_pem(self) -> bytes:
-        """Return the private key PEM bytes (loads/generates on first call)."""
-        private_pem, _ = _load_or_generate_rsa_keys(self.rsa_key_dir)
-        return private_pem
-
-    @property
-    def public_pem(self) -> bytes:
-        """Return the public key PEM bytes (loads/generates on first call)."""
-        _, public_pem = _load_or_generate_rsa_keys(self.rsa_key_dir)
-        return public_pem
-
-    @property
-    def private_key(self) -> RSAPrivateKey:
-        """Return the deserialized RSA private key object."""
-        return load_pem_private_key(self.private_pem, password=None)
-
-    @property
-    def public_key(self) -> RSAPublicKey:
-        """Return the deserialized RSA public key object."""
-        return load_pem_public_key(self.public_pem)
-
 
 @lru_cache()
 def get_settings() -> Settings:

backend/app/dependencies.py

@@ -27,7 +27,7 @@ async def get_current_user(
     )
     try:
         payload = jwt.decode(
-            token, settings.public_pem, algorithms=[settings.ALGORITHM]
+            token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]
         )
         user_id: str | None = payload.get("sub")
         if user_id is None:

backend/app/models/session.py

@@ -3,7 +3,6 @@ import uuid
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Boolean
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
-
 from app.database import Base
 
 
@@ -19,19 +18,3 @@ class Session(Base):
     updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
 
     user = relationship("User", back_populates="sessions")
-
-
-class RefreshToken(Base):
-    __tablename__ = "refresh_tokens"
-
-    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
-    # RS256 JWTs are ~420+ chars; Text avoids length issues and is fine for
-    # a UUID-indexed lookup by hash in the future.
-    token = Column(String, unique=True, index=True, nullable=False)
-    expires_at = Column(DateTime(timezone=True), nullable=False)
-    is_active = Column(Boolean, default=True)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
-
-    user = relationship("User", back_populates="refresh_tokens")

backend/app/models/user.py

@@ -21,7 +21,6 @@ class User(Base):
     updated_at = Column(DateTime(timezone=True), onupdate=func.now())
 
     sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan")
-    refresh_tokens = relationship("RefreshToken", back_populates="user", cascade="all, delete-orphan")
     worlds = relationship("World", back_populates="owner")
     assets = relationship("Asset", back_populates="owner")
 

backend/app/routers/auth.py

@@ -1,21 +1,20 @@
 """Authentication router - login, register, token refresh."""
 
-import uuid
+from datetime import date, datetime, timedelta, timezone
-from datetime import datetime, timedelta, timezone
 
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordRequestForm
+from pydantic import BaseModel, EmailStr, field_validator
+
 from jose import jwt
 from passlib.context import CryptContext
-from pydantic import BaseModel, EmailStr, field_validator
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings
 from app.database import get_db
 from app.dependencies import CurrentUser
-from app.models.session import RefreshToken
 from app.models.user import User
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
@@ -26,9 +25,7 @@ router = APIRouter()
 
 class TokenResponse(BaseModel):
     access_token: str
-    refresh_token: str
     token_type: str = "bearer"
-    access_token_expires_minutes: int
 
 
 class RegisterRequest(BaseModel):
@@ -62,31 +59,12 @@ class UserResponse(BaseModel):
 # --- Helpers ---
 
 def _create_access_token(data: dict) -> str:
-    """Create a signed access token using RS256."""
     to_encode = data.copy()
     expire = datetime.now(timezone.utc) + timedelta(
         minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
     )
     to_encode.update({"exp": expire})
-    return jwt.encode(
+    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
-        to_encode,
-        settings.private_pem,
-        algorithm=settings.ALGORITHM,
-    )
-
-
-def _create_refresh_token(data: dict) -> str:
-    """Create a signed refresh token using RS256."""
-    to_encode = data.copy()
-    expire = datetime.now(timezone.utc) + timedelta(
-        days=settings.REFRESH_TOKEN_EXPIRE_DAYS
-    )
-    to_encode.update({"exp": expire})
-    return jwt.encode(
-        to_encode,
-        settings.private_pem,
-        algorithm=settings.ALGORITHM,
-    )
 
 
 def verify_password(plain_password: str, hashed_password: str) -> bool:
@@ -99,7 +77,7 @@ def hash_password(password: str) -> str:
     return pwd_context.hash(password)
 
 
-def calculate_age(birth_date, today=None) -> int:
+def calculate_age(birth_date: date, today: date | None = None) -> int:
     """Calculate age in years from a birth date.
 
     Args:
@@ -119,25 +97,11 @@ def calculate_age(birth_date, today=None) -> int:
     return age
 
 
-def _issue_refresh_token(user_id: int, db: AsyncSession) -> str:
-    """Create and persist a refresh token for the given user."""
-    refresh_token_value = _create_refresh_token({"sub": str(user_id)})
-    refresh_token_record = RefreshToken(
-        id=str(uuid.uuid4()),
-        user_id=user_id,
-        token=refresh_token_value,
-        expires_at=datetime.now(timezone.utc)
-        + timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS),
-    )
-    db.add(refresh_token_record)
-    return refresh_token_value
-
-
 # --- Endpoints ---
 
 @router.post("/register", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
 async def register(req: RegisterRequest, db: AsyncSession = Depends(get_db)):
-    """Register a new user and return access + refresh tokens.
+    """Register a new user and return an access token.
 
     Requires date_of_birth and rejects users under 18.
     """
@@ -177,23 +141,13 @@ async def register(req: RegisterRequest, db: AsyncSession = Depends(get_db)):
     await db.commit()
     await db.refresh(user)
 
-    # Create access token
     access_token = _create_access_token({"sub": str(user.id)})
-
+    return TokenResponse(access_token=access_token)
-    # Create and persist refresh token
-    refresh_token_value = _issue_refresh_token(user.id, db)
-    await db.commit()
-
-    return TokenResponse(
-        access_token=access_token,
-        refresh_token=refresh_token_value,
-        access_token_expires_minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES,
-    )
 
 
 @router.post("/login", response_model=TokenResponse)
 async def login(form: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
-    """Authenticate user and return access + refresh tokens.
+    """Authenticate user and return an access token.
 
     Accepts form-encoded credentials (username/password) as expected by
     OAuth2PasswordBearer, so the Swagger UI "Authorize" flow works correctly.
@@ -213,18 +167,8 @@ async def login(form: OAuth2PasswordRequestForm = Depends(), db: AsyncSession =
             detail="User account is inactive",
         )
 
-    # Create access token
     access_token = _create_access_token({"sub": str(user.id)})
-
+    return TokenResponse(access_token=access_token)
-    # Create and persist refresh token
-    refresh_token_value = _issue_refresh_token(user.id, db)
-    await db.commit()
-
-    return TokenResponse(
-        access_token=access_token,
-        refresh_token=refresh_token_value,
-        access_token_expires_minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES,
-    )
 
 
 @router.get("/me", response_model=UserResponse)

docs/planning/client-server-wiring.md

@@ -23,10 +23,9 @@ explicitly out of scope.
 | # | Type | Task | Depends on |
 |---|------|------|-----------|
 | 1 | architecture | `ApiClient` autoload: HTTP + JWT storage + error contract | — |
-| 2 | implementation | Main-menu **login** wiring (form-encoded) | 1 |
+| 2 | implementation | Main-menu **login + register** UI built & wired (form-encoded + JSON/age gate) | 1 |
-| 3 | implementation | Main-menu **register** wiring (JSON + age gate) | 2 |
+| 3 | implementation | **World list** screen consuming `GET /api/worlds` | 1 |
-| 4 | implementation | **World list** screen consuming `GET /api/worlds` | 2 |
+| 4 | testing | End-to-end headless smoke test + manual verify | 1,2,3 |
-| 5 | testing | End-to-end headless smoke test + manual verify | 1,3,4 |
 
 ## Design decisions captured (resolved in task 1)
 - Token storage: in-memory singleton property for the MVP; a `save_to_disk` seam is left
@@ -35,3 +34,8 @@ explicitly out of scope.
   never crash on network failure; non-2xx surfaces `{status, detail}` from the backend.
 - Base URL: read from a ProjectSetting, defaulting to `http://127.0.0.1:8000`.
 - Login is form-encoded; register is JSON — the client helper must support both content types.
+
+## Notes
+- The main-menu auth UI does **not** exist yet (main_menu.gd currently has only Play/Quit
+  stubs). Task 2 must **build** the login/register UI, not merely wire an existing one.
+- The world-list screen also needs to be **built** (a new scene), not just wired.

docs/testing/README.md

@@ -0,0 +1,50 @@
+# Testing at Package Checkpoints
+
+A Package Checkpoint (PC1, PC2, ...) is a periodic review point — every few
+real milestones, the client and server builds get packaged together and
+independently reviewed before anyone calls anything actually done. See
+`project_agp` in Claude's memory, or ask, for the full definition; this
+doc is just the mechanical "how do I run the tests" part of that review.
+
+## Running the suite
+
+```
+python scripts/run_checkpoint_tests.py
+```
+
+Brings up a throwaway Postgres, runs Alembic migrations against it, runs the
+backend pytest suite, starts the backend server, and runs every Godot
+headless smoke test (`scripts/smoke_test_*.gd`) against it. Tears the
+Postgres container down afterward (`--keep-postgres` to skip that if you
+want to poke at the DB after a failure).
+
+If port 5432 is already taken on the machine, pass `--postgres-port` with
+something else.
+
+Exit code is 0 only if everything that actually ran passed — suites with
+nothing to run yet (no Godot binary found, no smoke test scripts yet) are
+reported SKIPPED, not treated as a failure.
+
+## What this does and doesn't prove
+
+Passing this script means: migrations apply cleanly to a genuinely empty
+database, the backend's unit-level logic is correct, and whatever Godot
+smoke tests exist actually round-trip against a live backend. It does
+**not** mean full endpoint/integration coverage exists — see
+`test_inventory.md` for the current, honest list of what's tested and what
+isn't. A checkpoint review should still involve reading the actual diffs
+for anything this script's current coverage doesn't reach, not just running
+green and calling it done.
+
+## Growing this over time
+
+As real integration tests get added (endpoint tests hitting the FastAPI app,
+more Godot smoke coverage beyond `health_check`), they should land under
+`backend/tests/` / `scripts/smoke_test_*.gd` respectively — this script
+picks up new files automatically, nothing to register by hand. Update
+`test_inventory.md`'s tables when you do, so the inventory stays a source
+of truth instead of quietly going stale.
+
+Eventual goal (not implemented yet): gate merges to `main` on this script
+passing, the same way a real CI pipeline would. For now it's a manual step
+run at checkpoint review time.

docs/testing/test_inventory.md

@@ -0,0 +1,78 @@
+# Test Inventory
+
+What automated coverage actually exists, what it actually verifies, and what
+doesn't have coverage yet. Keep this current as tests are added — it's the
+thing a Package Checkpoint review (see `docs/testing/README.md`) reads first
+to know what "run the tests" actually checked.
+
+Run everything below in one shot with `scripts/run_checkpoint_tests.py`.
+
+Last verified against `main`: 2026-08-19 (commit `1c75367`).
+
+## Backend — `backend/tests/` (pytest)
+
+Run: `cd backend && python -m pytest -v` (needs `DATABASE_URL` pointed at a
+reachable Postgres — see the runner script; most of these tests don't
+actually touch the DB, but the app's import chain requires a valid URL to
+construct).
+
+**Current total: 38 tests, all passing on a clean `main` checkout.**
+
+| File | Tests | What it covers |
+|---|---|---|
+| `test_auth_age_gate.py` | 10 | `calculate_age()` date-math correctness (exact boundary, leap years, birthday-not-yet-this-year) + `RegisterRequest` date-of-birth validation (parametrized valid/invalid date rejection). Backs the 18+ registration gate (PR #23). |
+| `test_gltf_metadata.py` | 21 | glTF/GLB binary + JSON parsing: magic-byte detection, chunk-padding handling, mesh/animation/texture-reference metadata extraction, malformed-input rejection. Backs the asset-import pipeline (PR #27). |
+
+**What these are, honestly:** pure unit tests of standalone functions
+(`calculate_age`, the glTF parser, Pydantic validators). None of them spin
+up the FastAPI app or hit a real endpoint — they run in ~1s and don't
+actually need Postgres reachable at all (the import chain just needs a
+syntactically valid `DATABASE_URL`, nothing connects during collection).
+
+**Known coverage gaps** (real gaps, not placeholders — nothing enforces filling
+these yet):
+- No integration/endpoint tests at all — `/register`, `/login`, `/refresh`,
+  `/worlds`, `/assets/*` have zero tests that actually call them through
+  the FastAPI app (e.g. via `httpx.AsyncClient` + `ASGITransport`) against a
+  real (or test) database. Everything currently shipped works because it
+  was manually verified at merge time (checkpoint review), not because a
+  test asserts it.
+- No tests for the RS256 auth upgrade (key generation, refresh-token
+  issuance/persistence) — PR #30, pending review as of this writing,
+  manually verified (correct key usage, all 38 existing tests still pass)
+  but not covered by an automated test of its own yet.
+- No tests for the moderation schema/migration (in progress as of this
+  writing) beyond "the migration runs."
+
+## Godot client — `scripts/smoke_test_*.gd`
+
+**Nothing merged into `main` yet as of this writing** — `sandbox_probe/test_script.gd`
+is the only Godot script on `main` right now, and it's **not a real
+test** (a leftover manual probe, returns a hardcoded string, asserts
+nothing). Don't count it toward coverage; delete or repurpose it if anyone
+actually needs a sandbox probe again.
+
+`scripts/smoke_test_api.gd` (PC1, PR #29, pending review as of this writing)
+will be the first real one once merged — `ApiClient` autoload's
+`health_check()` against a **live backend** (set `AGP_API_BASE_URL` to point
+at one), verified by hand end-to-end before opening the PR: exercises the
+real HTTP request path (`HTTPRequest` node lifecycle, JSON parse, the
+result-dictionary contract), not just that the script compiles. Exits 1 on
+failure, so it's CI/script-friendly.
+
+Run (once merged): `godot --headless --path . --import` once (builds the
+class cache — skip this and every `class_name`-declared class falsely
+errors as undeclared), then for each `scripts/smoke_test_*.gd`:
+`godot --headless --path . --script res://scripts/<name>.gd`
+
+**Known gap once it lands:** only `health_check()` is exercised end-to-end.
+`login`, `register`, `get_worlds`, `get_me` are implemented (see
+`scripts/api_client.gd`) but have no smoke coverage yet — each would need a
+real user/world fixture in the target backend to test against meaningfully.
+
+## What "full coverage" should eventually mean here
+
+Not defined precisely yet — the honest target as of 2026-08-19 is just
+"more than pure-function unit tests." As real integration/endpoint tests get
+added, update the tables above rather than letting this doc drift stale;
+a wrong inventory is worse than no inventory.

scripts/run_checkpoint_tests.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Run the full automated test inventory for a Package Checkpoint review.
+
+See docs/testing/test_inventory.md for what each suite actually covers (and
+doesn't) -- keep that doc in sync as tests are added, this script just runs
+whatever's there.
+
+Usage:
+    python scripts/run_checkpoint_tests.py [--keep-postgres] [--postgres-port PORT]
+
+Exits 0 if everything that ran passed, 1 otherwise. Suites with nothing to
+run (e.g. no scripts/smoke_test_*.gd yet, or no Godot binary found) are
+reported as SKIPPED, not counted as a failure.
+"""
+import argparse
+import glob
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+BACKEND = ROOT / "backend"
+
+
+def run(cmd, cwd=None, env=None, capture=False):
+    print(f"$ {' '.join(cmd)}" + (f"  (cwd={cwd})" if cwd else ""))
+    return subprocess.run(cmd, cwd=cwd, env=env, capture_output=capture, text=True)
+
+
+def find_godot():
+    for candidate in ("godot", str(Path.home() / "godot" / "godot")):
+        if shutil.which(candidate) or Path(candidate).is_file():
+            return candidate
+    return None
+
+
+def wait_for_http(url: str, timeout_s: int = 20) -> bool:
+    import urllib.request
+    import urllib.error
+
+    deadline = time.time() + timeout_s
+    while time.time() < deadline:
+        try:
+            with urllib.request.urlopen(url, timeout=2) as resp:
+                if resp.status == 200:
+                    return True
+        except (urllib.error.URLError, ConnectionError, OSError):
+            pass
+        time.sleep(1)
+    return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--keep-postgres", action="store_true",
+                         help="Don't tear down the checkpoint Postgres container afterward")
+    parser.add_argument("--postgres-port", default=os.environ.get("CHECKPOINT_POSTGRES_PORT", "5432"),
+                         help="Host port for the checkpoint's own Postgres container (default 5432 -- "
+                              "override if that's already in use on this machine)")
+    parser.add_argument("--backend-port", default=os.environ.get("CHECKPOINT_BACKEND_PORT", "18080"),
+                         help="Port to run the backend server on for the Godot smoke tests")
+    args = parser.parse_args()
+
+    results = {}
+
+    # --- Backend: bring up Postgres ---
+    compose_env = os.environ.copy()
+    compose_env["COMPOSE_PROJECT_NAME"] = "agp-checkpoint"
+    compose_env["POSTGRES_HOST_PORT"] = args.postgres_port
+    compose_env["POSTGRES_PORT"] = args.postgres_port  # some branches use this name instead, see tools/definitions.py
+    print("=== Backend: bringing up Postgres ===")
+    run(["docker", "compose", "up", "-d", "postgres"], cwd=BACKEND, env=compose_env)
+
+    print("Waiting for Postgres to be ready...")
+    pg_ready = False
+    for _ in range(20):
+        r = run(["docker", "compose", "exec", "-T", "postgres", "pg_isready", "-U", "agp_user", "-d", "agp_db"],
+                cwd=BACKEND, env=compose_env, capture=True)
+        if r.returncode == 0:
+            pg_ready = True
+            break
+        time.sleep(1)
+    if not pg_ready:
+        print("Postgres never became ready -- aborting.")
+        sys.exit(1)
+
+    db_url = f"postgresql+asyncpg://agp_user:agp_password@localhost:{args.postgres_port}/agp_db"
+    backend_env = os.environ.copy()
+    backend_env["DATABASE_URL"] = db_url
+
+    print("\n=== Backend: alembic upgrade head ===")
+    r = run([sys.executable, "-m", "alembic", "upgrade", "head"], cwd=BACKEND, env=backend_env)
+    results["migrations (fresh DB)"] = r.returncode == 0
+
+    print("\n=== Backend: pytest ===")
+    r = run([sys.executable, "-m", "pytest", "-v"], cwd=BACKEND, env=backend_env)
+    results["backend pytest"] = r.returncode == 0
+
+    # --- Godot: headless smoke tests (need a live backend server) ---
+    godot_bin = find_godot()
+    smoke_tests = sorted(glob.glob(str(ROOT / "scripts" / "smoke_test_*.gd")))
+
+    if not godot_bin:
+        print("\n=== Godot: binary not found (checked PATH and ~/godot/godot), skipping smoke tests ===")
+        results["godot smoke tests"] = None
+    elif not smoke_tests:
+        print("\n=== Godot: no scripts/smoke_test_*.gd found yet, nothing to run ===")
+        results["godot smoke tests"] = None
+    else:
+        print(f"\n=== Backend: starting server on :{args.backend_port} for Godot smoke tests ===")
+        server_proc = subprocess.Popen(
+            [sys.executable, "-m", "uvicorn", "app.main:app", "--host", "127.0.0.1", "--port", args.backend_port],
+            cwd=BACKEND, env=backend_env,
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        )
+        try:
+            base_url = f"http://127.0.0.1:{args.backend_port}"
+            if not wait_for_http(f"{base_url}/api/health"):
+                print("Backend server never became healthy -- skipping Godot smoke tests.")
+                results["godot smoke tests"] = False
+            else:
+                godot_env = os.environ.copy()
+                godot_env["AGP_API_BASE_URL"] = base_url
+
+                print("=== Godot: import pass (builds the class cache) ===")
+                run([godot_bin, "--headless", "--path", str(ROOT), "--import"], env=godot_env)
+                run([godot_bin, "--headless", "--path", str(ROOT), "--quit"], env=godot_env)
+
+                godot_ok = True
+                for test in smoke_tests:
+                    rel = os.path.relpath(test, ROOT)
+                    print(f"\n--- {rel} ---")
+                    r = run([godot_bin, "--headless", "--path", str(ROOT), "--script", f"res://{rel}"], env=godot_env)
+                    if r.returncode != 0:
+                        godot_ok = False
+                results["godot smoke tests"] = godot_ok
+        finally:
+            server_proc.terminate()
+            try:
+                server_proc.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                server_proc.kill()
+
+    if not args.keep_postgres:
+        print("\n=== Backend: tearing down checkpoint Postgres ===")
+        run(["docker", "compose", "down", "-v", "postgres"], cwd=BACKEND, env=compose_env)
+
+    # --- Summary ---
+    print("\n" + "=" * 50)
+    print("SUMMARY")
+    print("=" * 50)
+    overall_ok = True
+    for name, ok in results.items():
+        if ok is None:
+            print(f"  {name}: SKIPPED")
+        elif ok:
+            print(f"  {name}: PASS")
+        else:
+            print(f"  {name}: FAIL")
+            overall_ok = False
+
+    print("\nSee docs/testing/test_inventory.md for what each suite actually covers (and doesn't).")
+    sys.exit(0 if overall_ok else 1)
+
+
+if __name__ == "__main__":
+    main()