CI: per-push job is a fast compile-and-generate smoke, not the full suite

The full suite on a 2-core runner takes ~an hour — not viable per
push.  The `test` job becomes `smoke` (scripts/ci_smoke.py: compile
binary_increment, generate through a transformers pipeline, assert
the output — the whole stack in about a minute).  The full CPU
suite moves to full-tests.yml, weekly + workflow_dispatch.  The
require-ci ruleset now requires lint + smoke.

Test Suite Status: 1615 passed, 0 failed, 0 skipped (--device cpu).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: physicsrob

.github/workflows/ci.yml

@@ -30,13 +30,19 @@ jobs:
       - name: Lint
         run: make lint
 
-  test:
+  # Fast end-to-end signal on every push: compile an example on CPU,
+  # generate, assert the output.  The full suite is far too slow for
+  # per-push CI (~1h on a 2-core runner) — it runs on Modal during
+  # development (make test) and weekly via full-tests.yml.
+  smoke:
     runs-on: ubuntu-latest
-    timeout-minutes: 60
+    timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
-      - name: Test (CPU)
-        run: make test-ci
+      - name: Sync dev environment
+        run: uv sync
+      - name: Compile-and-generate smoke
+        run: uv run --no-sync python -m scripts.ci_smoke

.github/workflows/full-tests.yml

@@ -0,0 +1,26 @@
+name: Full tests
+
+# The full suite on a CPU runner takes on the order of an hour — far too
+# slow for per-push CI (that's the smoke job in ci.yml).  This runs it
+# weekly as a drift backstop, and on demand.
+
+on:
+  schedule:
+    - cron: "17 6 * * 1"  # Mondays 06:17 UTC
+  workflow_dispatch:
+
+env:
+  UV_PYTHON: "3.12"
+  UV_LOCKED: "1"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 180
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+      - name: Test (CPU, full suite)
+        run: make test-ci

Makefile

@@ -60,7 +60,7 @@ test: check-modal-lock
 test-logs:
 	@tail -f /tmp/torchwright-test.log
 
-# CI entry point (.github/workflows/ci.yml): full suite on the runner's CPU,
+# CI entry point (.github/workflows/full-tests.yml): full suite on the runner's CPU,
 # synced from the standalone lock like the Modal image.  Guarded to CI because
 # inside the umbrella workspace `uv sync` operates on the shared venv instead
 # (dropping opt-in packages like torchwright_doom's onnxruntime-gpu), and a

scripts/ci_smoke.py

@@ -0,0 +1,40 @@
+"""End-to-end CI smoke: compile an example, generate, check the output.
+
+Compiles ``examples/binary_increment.py`` to a Hugging Face bundle and
+verifies that a ``transformers`` pipeline loaded from it increments a
+binary string.  This exercises the full stack — graph construction,
+scheduling, weight writing, bundle export, tokenizer, generation —
+in about a minute on a CPU runner, standing in for the full suite on
+every push (the full suite runs on Modal locally and on the weekly
+full-tests workflow).
+"""
+
+import sys
+import tempfile
+from pathlib import Path
+
+
+def main() -> int:
+    from examples.binary_increment import D_HEAD, D_MODEL, create_network_parts
+    from torchwright import compile_hf_bundle
+
+    output_node, embedding = create_network_parts()
+    with tempfile.TemporaryDirectory() as tmp:
+        bundle = Path(tmp) / "binary_increment_hf_bundle"
+        compile_hf_bundle(output_node, embedding, str(bundle), d=D_MODEL, d_head=D_HEAD)
+
+        from transformers import pipeline
+
+        generate = pipeline("text-generation", model=str(bundle))
+        out = generate("1011\n", return_full_text=False)[0]["generated_text"]
+
+    print(f"generated: {out!r}")
+    if out.strip() != "1100":
+        print("FAIL: expected '1100'", file=sys.stderr)
+        return 1
+    print("smoke OK")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())