Publish Tiny Hinglish Turn Detector development preview

release inventory sha256: eeddc0bc1ef70abf44ce9f84444751b0b2fb15e2718df215fa3f537cb2a86bfe

MODEL_CARD.md

@@ -303,7 +303,7 @@ failure aggregates, silence perturbation report, exact environment files, CPU
 benchmarks, and guarded release tooling. Per-example validation predictions and
 the text-bearing split manifest remain in the private local workspace; the
 public package contains aggregate reports and hashes, not those sensitive rows.
-The quality gate completed with Ruff 0.15.16 passing and 131/131 automated tests
+The quality gate completed with Ruff 0.15.16 passing and 136/136 automated tests
 passing via Python `unittest` discovery. The configured Hugging Face owner is
 `suvradeepp`.
 

README.md

@@ -303,7 +303,7 @@ failure aggregates, silence perturbation report, exact environment files, CPU
 benchmarks, and guarded release tooling. Per-example validation predictions and
 the text-bearing split manifest remain in the private local workspace; the
 public package contains aggregate reports and hashes, not those sensitive rows.
-The quality gate completed with Ruff 0.15.16 passing and 131/131 automated tests
+The quality gate completed with Ruff 0.15.16 passing and 136/136 automated tests
 passing via Python `unittest` discovery. The configured Hugging Face owner is
 `suvradeepp`.
 

REPORT.md

@@ -525,7 +525,7 @@ calendar days or the missing external data collection occurred.
 | 13 | Integrate controller and demo | replay, three-state controller, Gradio, Hinglish recording prompts | Preview model and synthetic controller integration complete; real sequence replay pending |
 | 14 | Freeze test, package, publish | sealed-test guard, atomic release builder, exact-mirror publisher | Development packaging path ready; official-test/final gates not satisfied |
 
-The repository quality gate passed Ruff 0.15.16 and all 131 automated tests
+The repository quality gate passed Ruff 0.15.16 and all 136 automated tests
 (131 passed via Python `unittest` discovery). That validates the implemented behavior under test; it does not fill
 the missing empirical datasets or rights review.
 

SOURCE_README.md

@@ -26,9 +26,9 @@ engineering evidence, not a production-readiness claim.
 | Domain-shift stress | Measured, confounded | Source-held-out AP 0.5500/0.5368 for TinyTCN/baseline; both near chance in ranking, with wide nine-source bootstrap intervals |
 | Runtime/export | Measured | 611 KiB FP32 ONNX; exact PyTorch/ONNX parity; ONNX p95 0.956 ms neural-only and 1.629 ms waveform-to-probability |
 | Controller integration | Synthetic only | Metadata-bound 8-checkpoint/3-turn fixture emits 3 response edges with 0 duplicates; not model or product-quality evidence |
-| Code quality gate | Passed | Ruff 0.15.16; 131/131 automated tests passed via `unittest` discovery |
+| Code quality gate | Passed | Ruff 0.15.16; 136/136 automated tests passed via `unittest` discovery |
 | Accuracy/generalization | **Not established** | No full-corpus run, collected Hinglish recordings, real conversation replay, or official-test evaluation |
-| Hugging Face publication | Not claimed here | Local guarded release/publisher path exists; verify any remote publication separately |
+| Publication tooling | Guarded | Hash-verified HF publisher plus curated Kaggle/GitHub upload builders; verify each remote runtime separately |
 
 The official test set remains deliberately sealed. The preview is real
 development evidence, but validation was reused for threshold selection,
@@ -99,20 +99,29 @@ model.
 | `data/collection/` | Deterministic 900-recording Hinglish assignment plan; no recordings are included |
 | `reports/` | Measured one-shard audit and split reports |
 | `tests/` | Unit and integration coverage across data, model, metrics, runtime, and prompts |
+| `deployment/kaggle/` | Flat, standalone ONNX inference templates for Kaggle Models |
+| `upload-ready/` | Generated Kaggle and GitHub upload folders; never a source input |
 
 ## Reproduce the pipeline
 
 Python 3.10–3.12 and [`uv`](https://docs.astral.sh/uv/) are recommended.
-These commands target a full workspace checkout. In the Hugging Face model
-package, start with the package-native quickstart in `README.md`; the copied
-`SOURCE_README.md` is retained as implementation documentation and references
-private/local experiment inputs that are intentionally not redistributed.
+These commands target a full source checkout. Raw audio, downloaded Parquet,
+processed manifests, and per-example predictions are intentionally not
+redistributed; recreate them with the pinned download/audit commands below.
 
 ```bash
 uv sync --extra all
 uv run pytest
 ```
 
+The curated public repository already includes the selected ONNX artifact, so
+the demo resolves it without an environment variable:
+
+```bash
+uv sync --extra demo
+uv run python app.py
+```
+
 Place the Hugging Face token in the ignored `.env` file; never commit it:
 
 ```bash
@@ -224,7 +233,9 @@ must not be treated as a fresh holdout result.
 Only an experiment trained with exact `run.status: final` can be frozen. The
 freeze manifest hashes the checkpoint, selected config, source tree,
 preprocessing, controller policy, split manifest, threshold, and pinned test
-identity. Only then:
+identity. `configs/final.yaml` and `artifacts/final/*` below are intentionally
+future-candidate placeholders; create them only after completing the full-data
+experiment. Only then:
 
 ```bash
 uv run python scripts/freeze_candidate.py \
@@ -350,8 +361,21 @@ uv run python scripts/publish_hf.py \
   --username suvradeepp \
   --release-dir release \
   --allow-development-release
+
+uv run python scripts/build_upload_folders.py \
+  --release-dir release \
+  --output upload-ready \
+  --allow-development-release
 ```
 
+`upload-ready/kaggle-model/` is a flat drag-and-drop ONNX bundle.
+`upload-ready/github-repository/` is a public-repository allowlist containing
+source, CI, tests, aggregate evidence, ONNX weights, and the two checkpoints
+needed to reproduce the selected warm start. It excludes credentials, caches,
+raw/processed data, per-example predictions, stale releases, and publish
+receipts. Keep the Kaggle variation private until the derived-weight rights
+review described in `NOTICE` and `MODEL_CARD.md` is resolved.
+
 Add `--execute` only after the dry validation succeeds. The publisher verifies
 the authenticated owner and every packaged hash before creating or updating the
 remote model repository and Space. Its receipt binds exact remote HEAD commits,

app.py

@@ -12,6 +12,26 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+try:
+    import spaces
+except ModuleNotFoundError as exc:
+    if exc.name != "spaces":
+        raise
+
+    class _LocalSpaces:
+        """No-op compatibility layer for local installs without ZeroGPU."""
+
+        @staticmethod
+        def GPU(*, duration: int = 60) -> Any:  # noqa: N802 - mirrors spaces.GPU
+            del duration
+
+            def decorate(function: Any) -> Any:
+                return function
+
+            return decorate
+
+    spaces = _LocalSpaces()
+
 PROJECT_ROOT = Path(__file__).resolve().parent
 SRC_ROOT = PROJECT_ROOT / "src"
 if str(SRC_ROOT) not in sys.path:
@@ -23,6 +43,8 @@ from turn_detection.runtime.predictor import load_predictor  # noqa: E402
 DEFAULT_MODEL_CANDIDATES = (
     PROJECT_ROOT / "artifacts" / "model.onnx",  # Hugging Face Space layout
     PROJECT_ROOT / "model.onnx",  # Hugging Face model-repository layout
+    # Curated GitHub/source-checkout layout.
+    PROJECT_ROOT / "artifacts" / "partial-shard-warmstart-lr3e4-5ep" / "model.onnx",
 )
 
 
@@ -85,6 +107,7 @@ def _timeline_html(probability: float, threshold: float, state: TurnState) -> st
     """
 
 
+@spaces.GPU(duration=10)
 def analyze_turn(
     audio: tuple[int, Any] | None,
     threshold: float,

deployment/kaggle/README.md

@@ -0,0 +1,65 @@
+# Tiny Hinglish Turn Detector — ONNX preview
+
+This is a flat, dependency-light Kaggle Models bundle for audio-native
+`HOLD`/`END` decisions at VAD pause checkpoints. Upload every file in this
+folder as one ONNX model variation.
+
+> **Development preview:** the model was trained on one of 83 upstream training
+> shards. The official test remains sealed, the acoustic logistic baseline is
+> stronger on the current development split, and no verified Hinglish benchmark
+> recordings have been evaluated. Do not claim production or Hinglish accuracy.
+
+## Kaggle model settings
+
+- Framework: **ONNX**
+- Suggested variation: `tiny-tcn-fp32-preview`
+- Fine-tunable: **No**
+- Visibility: **Private** until upstream-derived-weight redistribution rights
+  have been reviewed
+- License: **Other (specified in description)**. Apache-2.0 covers authored
+  code, not the upstream data or derived-weight rights.
+
+## Files needed for inference
+
+- `model.onnx`: 151,812-parameter FP32 TinyTCN
+- `model_metadata.json`: frontend, tensor names, threshold, controller policy
+- `turn_detector.py`: standalone NumPy + ONNX Runtime inference
+- `requirements.txt`: three runtime dependencies
+
+`MODEL_CARD.md`, `DATA_CARD.md`, `development_metrics.json`, and
+`benchmark.json` document the limited evidence. `SHA256SUMS` binds the payload.
+
+## Use inside a Kaggle Notebook
+
+```python
+from pathlib import Path
+import kagglehub
+
+model_dir = Path(kagglehub.model_download(
+    "YOUR_USERNAME/tiny-hinglish-turn-detector/onnx/tiny-tcn-fp32-preview"
+))
+
+import sys
+sys.path.insert(0, str(model_dir))
+from turn_detector import TurnDetector
+
+detector = TurnDetector(model_dir)
+result = detector.predict_file("/kaggle/input/your-audio/example.wav", silence_ms=300)
+print(result)
+```
+
+For a downloaded folder outside Kaggle:
+
+```bash
+python -m pip install -r requirements.txt
+python smoke_test.py
+python example_inference.py path/to/audio.wav --silence-ms 300
+```
+
+Input audio may be mono or stereo and is resampled deterministically to 16 kHz.
+The model uses the most recent four seconds. `p_end` is compared with the
+serialized threshold and bounded by the serialized minimum/maximum silence
+policy. This helper makes one stateless checkpoint decision; production callers
+should retain the stateful controller from the full GitHub repository to latch
+`END` and prevent duplicate responses.
+

deployment/kaggle/example_inference.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""Run the Kaggle model bundle on one audio file."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from turn_detector import TurnDetector
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("audio", help="WAV/FLAC/OGG audio file")
+    parser.add_argument(
+        "--model-dir",
+        default=Path(__file__).resolve().parent,
+        type=Path,
+        help="directory containing model.onnx and model_metadata.json",
+    )
+    parser.add_argument("--silence-ms", type=float, default=300.0)
+    args = parser.parse_args()
+    detector = TurnDetector(args.model_dir)
+    print(json.dumps(detector.predict_file(args.audio, silence_ms=args.silence_ms), indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

deployment/kaggle/requirements.txt

@@ -0,0 +1,4 @@
+numpy==2.3.5
+onnxruntime==1.26.0
+soundfile==0.14.0
+

deployment/kaggle/smoke_test.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""Dependency and ONNX execution smoke test using generated audio only."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+from turn_detector import TurnDetector
+
+
+def main() -> int:
+    model_dir = Path(__file__).resolve().parent
+    detector = TurnDetector(model_dir)
+    sample_rate = 16_000
+    timeline = np.arange(sample_rate * 2, dtype=np.float32) / sample_rate
+    generated_audio = 0.08 * np.sin(2.0 * np.pi * 220.0 * timeline)
+    result = detector.predict(generated_audio, sample_rate, silence_ms=300.0)
+    if result["state"] not in {"HOLD", "END"}:
+        raise SystemExit("invalid decision state")
+    if not 0.0 <= result["p_end"] <= 1.0:
+        raise SystemExit("invalid endpoint probability")
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

deployment/kaggle/turn_detector.py

@@ -0,0 +1,304 @@
+"""Standalone ONNX inference for the Kaggle model bundle.
+
+This file deliberately has no dependency on the source repository. It mirrors
+the canonical NumPy frontend used during export and reads every serving choice
+from the adjacent ``model_metadata.json`` file.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import time
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+@dataclass(frozen=True, slots=True)
+class FrontendConfig:
+    sample_rate: int = 16_000
+    max_seconds: float = 4.0
+    n_fft: int = 400
+    win_length: int = 400
+    hop_length: int = 160
+    n_mels: int = 80
+    f_min: float = 0.0
+    f_max: float = 8_000.0
+    normalization: str = "whisper"
+    pad_side: str = "left"
+
+    def __post_init__(self) -> None:
+        if self.sample_rate <= 0 or self.max_seconds <= 0:
+            raise ValueError("sample_rate and max_seconds must be positive")
+        if self.n_fft <= 0 or self.win_length <= 0 or self.hop_length <= 0:
+            raise ValueError("FFT and window sizes must be positive")
+        if self.win_length > self.n_fft:
+            raise ValueError("win_length cannot exceed n_fft")
+        if self.n_mels <= 0:
+            raise ValueError("n_mels must be positive")
+        if not 0.0 <= self.f_min < self.f_max <= self.sample_rate / 2:
+            raise ValueError("mel frequency bounds must lie inside Nyquist")
+        if self.normalization not in {"whisper", "log10", "none"}:
+            raise ValueError("unsupported normalization")
+        if self.pad_side not in {"left", "right"}:
+            raise ValueError("pad_side must be left or right")
+
+    @property
+    def max_samples(self) -> int:
+        return round(self.sample_rate * self.max_seconds)
+
+    @property
+    def target_frames(self) -> int:
+        return self.max_samples // self.hop_length
+
+
+@dataclass(frozen=True, slots=True)
+class ControllerConfig:
+    endpoint_threshold: float
+    long_pause_threshold: float
+    min_silence_ms: float
+    relax_after_ms: float
+    max_silence_ms: float
+    required_confirmations: int
+
+    def __post_init__(self) -> None:
+        if not 0.0 <= self.long_pause_threshold <= self.endpoint_threshold <= 1.0:
+            raise ValueError("controller thresholds are invalid")
+        if not self.min_silence_ms <= self.relax_after_ms <= self.max_silence_ms:
+            raise ValueError("controller silence bounds are invalid")
+        if self.required_confirmations < 1:
+            raise ValueError("required_confirmations must be positive")
+
+
+def normalize_waveform(audio: Any) -> np.ndarray:
+    """Convert mono/stereo integer/float audio to finite mono float32."""
+
+    samples = np.asarray(audio)
+    if samples.size == 0:
+        raise ValueError("audio cannot be empty")
+    original_dtype = samples.dtype
+    if samples.ndim == 2:
+        channel_axis = 1 if samples.shape[1] <= 8 else 0
+        samples = samples.astype(np.float32).mean(axis=channel_axis)
+    elif samples.ndim != 1:
+        raise ValueError(f"expected mono/stereo audio, got shape {samples.shape}")
+    if np.issubdtype(original_dtype, np.integer):
+        info = np.iinfo(original_dtype)
+        samples = samples.astype(np.float32) / float(max(abs(info.min), info.max))
+    else:
+        samples = samples.astype(np.float32, copy=False)
+    samples = np.nan_to_num(samples, nan=0.0, posinf=1.0, neginf=-1.0)
+    peak = float(np.max(np.abs(samples)))
+    if peak > 1.0:
+        samples = samples / peak
+    return np.clip(samples, -1.0, 1.0)
+
+
+def resample_waveform(audio: Any, source_rate: int, target_rate: int) -> np.ndarray:
+    """Apply the deterministic linear resampler used during training."""
+
+    if source_rate <= 0 or target_rate <= 0:
+        raise ValueError("sample rates must be positive")
+    samples = normalize_waveform(audio)
+    if source_rate == target_rate:
+        return samples
+    output_length = max(1, round(len(samples) * target_rate / source_rate))
+    old_x = np.linspace(0.0, 1.0, len(samples), endpoint=False)
+    new_x = np.linspace(0.0, 1.0, output_length, endpoint=False)
+    return np.interp(new_x, old_x, samples).astype(np.float32)
+
+
+def pad_or_trim(audio: Any, config: FrontendConfig) -> tuple[np.ndarray, int]:
+    samples = normalize_waveform(audio)
+    if len(samples) >= config.max_samples:
+        return samples[-config.max_samples :].copy(), config.max_samples
+    padding = config.max_samples - len(samples)
+    widths = (padding, 0) if config.pad_side == "left" else (0, padding)
+    return np.pad(samples, widths).astype(np.float32), len(samples)
+
+
+def _hz_to_mel(value: Any) -> np.ndarray:
+    return 2595.0 * np.log10(1.0 + np.asarray(value) / 700.0)
+
+
+def _mel_to_hz(value: Any) -> np.ndarray:
+    return 700.0 * (10.0 ** (np.asarray(value) / 2595.0) - 1.0)
+
+
+@lru_cache(maxsize=16)
+def mel_filterbank(config: FrontendConfig) -> np.ndarray:
+    mel_points = np.linspace(_hz_to_mel(config.f_min), _hz_to_mel(config.f_max), config.n_mels + 2)
+    hz_points = _mel_to_hz(mel_points)
+    fft_hz = np.linspace(0.0, config.sample_rate / 2, config.n_fft // 2 + 1)
+    filters = np.zeros((config.n_mels, len(fft_hz)), dtype=np.float32)
+    for index in range(config.n_mels):
+        left, center, right = hz_points[index : index + 3]
+        filters[index] = np.maximum(
+            0.0,
+            np.minimum(
+                (fft_hz - left) / max(center - left, 1e-12),
+                (right - fft_hz) / max(right - center, 1e-12),
+            ),
+        )
+    normalization = 2.0 / np.maximum(
+        hz_points[2 : config.n_mels + 2] - hz_points[: config.n_mels],
+        1e-12,
+    )
+    result = filters * normalization[:, None]
+    result.flags.writeable = False
+    return result
+
+
+@lru_cache(maxsize=16)
+def _hann_window(length: int) -> np.ndarray:
+    window = np.hanning(length).astype(np.float32)
+    window.flags.writeable = False
+    return window
+
+
+def log_mel_spectrogram(
+    audio: Any,
+    source_rate: int,
+    config: FrontendConfig,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return canonical ``[80, frames]`` features and valid-frame mask."""
+
+    if source_rate <= 0:
+        raise ValueError("source sample rate must be positive")
+    normalized = normalize_waveform(audio)
+    source_suffix_samples = max(1, round(config.max_seconds * source_rate))
+    normalized = normalized[-source_suffix_samples:]
+    resampled = resample_waveform(normalized, source_rate, config.sample_rate)
+    fixed, valid_samples = pad_or_trim(resampled, config)
+
+    padding = config.n_fft // 2
+    padded = np.pad(fixed, (padding, padding), mode="reflect")
+    frames = np.lib.stride_tricks.sliding_window_view(padded, config.win_length)[
+        :: config.hop_length
+    ]
+    frames = frames[: config.target_frames]
+    spectrum = np.fft.rfft(
+        frames * _hann_window(config.win_length)[None, :],
+        n=config.n_fft,
+        axis=1,
+    )
+    power = (spectrum.real**2 + spectrum.imag**2).astype(np.float32)
+    mel = np.maximum(mel_filterbank(config) @ power.T, 1e-10)
+    features = np.log10(mel)
+    if config.normalization == "whisper":
+        features = np.maximum(features, float(features.max()) - 8.0)
+        features = (features + 4.0) / 4.0
+    elif config.normalization == "none":
+        features = mel
+
+    frame_mask = np.zeros(config.target_frames, dtype=np.float32)
+    valid_frames = min(
+        config.target_frames,
+        max(1, (valid_samples + config.hop_length - 1) // config.hop_length),
+    )
+    if config.pad_side == "left":
+        frame_mask[-valid_frames:] = 1.0
+    else:
+        frame_mask[:valid_frames] = 1.0
+    return features.astype(np.float32), frame_mask
+
+
+class TurnDetector:
+    """Load the adjacent ONNX artifact and score VAD pause checkpoints."""
+
+    def __init__(self, model_directory: str | Path) -> None:
+        try:
+            import onnxruntime as ort
+        except ImportError as exc:
+            raise RuntimeError("Install requirements.txt before inference") from exc
+
+        self.model_directory = Path(model_directory).expanduser().resolve()
+        model_path = self.model_directory / "model.onnx"
+        metadata_path = self.model_directory / "model_metadata.json"
+        if not model_path.is_file() or not metadata_path.is_file():
+            raise FileNotFoundError("model.onnx and model_metadata.json must be adjacent")
+        self.metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+        self.frontend = FrontendConfig(**self.metadata["frontend"])
+        self.controller = ControllerConfig(**self.metadata["controller"])
+
+        options = ort.SessionOptions()
+        options.intra_op_num_threads = 1
+        options.inter_op_num_threads = 1
+        options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        self.session = ort.InferenceSession(
+            str(model_path),
+            sess_options=options,
+            providers=["CPUExecutionProvider"],
+        )
+        expected_inputs = {
+            self.metadata["input_features_name"],
+            self.metadata["frame_mask_name"],
+        }
+        actual_inputs = {item.name for item in self.session.get_inputs()}
+        if actual_inputs != expected_inputs:
+            raise ValueError(f"unexpected ONNX inputs: {sorted(actual_inputs)}")
+        expected_output = self.metadata["endpoint_output_name"]
+        actual_outputs = [item.name for item in self.session.get_outputs()]
+        if actual_outputs != [expected_output]:
+            raise ValueError(f"unexpected ONNX outputs: {actual_outputs}")
+
+    def threshold_for_silence(self, silence_ms: float) -> float:
+        if silence_ms <= self.controller.relax_after_ms:
+            return self.controller.endpoint_threshold
+        span = self.controller.max_silence_ms - self.controller.relax_after_ms
+        if span <= 0.0:
+            return self.controller.long_pause_threshold
+        progress = min(1.0, (silence_ms - self.controller.relax_after_ms) / span)
+        delta = self.controller.endpoint_threshold - self.controller.long_pause_threshold
+        return self.controller.endpoint_threshold - progress * delta
+
+    def predict(self, audio: Any, sample_rate: int, *, silence_ms: float = 300.0) -> dict[str, Any]:
+        """Return a stateless HOLD/END decision for one pause checkpoint."""
+
+        if silence_ms < 0.0:
+            raise ValueError("silence_ms cannot be negative")
+        started = time.perf_counter_ns()
+        features, frame_mask = log_mel_spectrogram(audio, sample_rate, self.frontend)
+        raw = self.session.run(
+            [self.metadata["endpoint_output_name"]],
+            {
+                self.metadata["input_features_name"]: features[None, :, :],
+                self.metadata["frame_mask_name"]: frame_mask[None, :],
+            },
+        )[0]
+        value = float(np.asarray(raw).reshape(-1)[0])
+        probability = (
+            1.0 / (1.0 + math.exp(-value)) if self.metadata["output_type"] == "logits" else value
+        )
+        probability = min(1.0, max(0.0, probability))
+        threshold = self.threshold_for_silence(float(silence_ms))
+        if silence_ms < self.controller.min_silence_ms:
+            state, reason = "HOLD", "minimum_silence_not_reached"
+        elif silence_ms >= self.controller.max_silence_ms:
+            state, reason = "END", "maximum_timeout"
+        elif probability >= threshold:
+            state, reason = "END", "model_endpoint"
+        else:
+            state, reason = "HOLD", "model_hold"
+        return {
+            "state": state,
+            "reason": reason,
+            "p_end": probability,
+            "threshold": threshold,
+            "silence_ms": float(silence_ms),
+            "inference_ms": (time.perf_counter_ns() - started) / 1_000_000,
+            "model_name": self.metadata["model_name"],
+            "development_only": bool(self.metadata.get("development_only", False)),
+        }
+
+    def predict_file(self, audio_path: str | Path, *, silence_ms: float = 300.0) -> dict[str, Any]:
+        try:
+            import soundfile as sf
+        except ImportError as exc:
+            raise RuntimeError("Install soundfile to load audio paths") from exc
+        samples, sample_rate = sf.read(str(audio_path), dtype="float32", always_2d=False)
+        return self.predict(samples, int(sample_rate), silence_ms=silence_ms)

export_manifest.json

@@ -81,14 +81,39 @@
   },
   "source_files": [
     {
-      "bytes": 10381,
+      "bytes": 11008,
       "path": "app.py",
-      "sha256": "b07999d898628cd967d82d527d2ae74ebc6e7d050cf48b2bd59d60c683c0699a"
+      "sha256": "e0a9ab19732dab255f20b16e4866a04414228b785e72c139c7eadb2f91be5e36"
     },
     {
-      "bytes": 2511,
+      "bytes": 2359,
+      "path": "deployment/kaggle/README.md",
+      "sha256": "d107cee49a203172ecbb5b6c531a3898e3634690422d80468693bd2f0ceb333a"
+    },
+    {
+      "bytes": 852,
+      "path": "deployment/kaggle/example_inference.py",
+      "sha256": "27d34092619a06744fbdd899906e3f3236cfe5dfe391eedcd98f145f6015687c"
+    },
+    {
+      "bytes": 52,
+      "path": "deployment/kaggle/requirements.txt",
+      "sha256": "0ce722012cff5e44e1fe70632f85689362ed34b2b5c7ef5605e403027089f927"
+    },
+    {
+      "bytes": 892,
+      "path": "deployment/kaggle/smoke_test.py",
+      "sha256": "726bc853d360d105991563e94115bd4bbdb03fe9f5b3c007d712898ff0b5795b"
+    },
+    {
+      "bytes": 12363,
+      "path": "deployment/kaggle/turn_detector.py",
+      "sha256": "83de2bea2eb31b0fa123441a28c7238e122ba4e7986aa87859a2b94bdeab4258"
+    },
+    {
+      "bytes": 2601,
       "path": "pyproject.toml",
-      "sha256": "2659b459bd0148fc3bb638058533fc1261c2bd7fd15fe0deeb9b5e8e790fcdd9"
+      "sha256": "fab1e0c093a89d5819a7109b9278332c61709e8bf61149486e31399c57a25f12"
     },
     {
       "bytes": 399,
@@ -126,9 +151,14 @@
       "sha256": "146763ebbe4d4ca0858c3fda2f56aa235aa9a4b6686b3216bcea58d148945d04"
     },
     {
-      "bytes": 40974,
+      "bytes": 43576,
       "path": "scripts/build_release.py",
-      "sha256": "f4bb9e1c5cbde4514fabeeed354fb2fcb7374c3b6abe1245a3f61f6aceb2a2c4"
+      "sha256": "6bcab53184466e3ee5870e87bf85b606db62ddcd06956cd03679502958ea589b"
+    },
+    {
+      "bytes": 17830,
+      "path": "scripts/build_upload_folders.py",
+      "sha256": "0da4af7974df001c27b6fe78d9e2a60ac1fd841a8d48e27a2e499996c58060a7"
     },
     {
       "bytes": 10147,
@@ -151,9 +181,9 @@
       "sha256": "5e97757f74414b2ac003ab5e87a0afeeed88b61eb30baa1801b10a11a57acca4"
     },
     {
-      "bytes": 17732,
+      "bytes": 17939,
       "path": "scripts/export_onnx.py",
-      "sha256": "cebb6d9ca45bf083f72750e219114d3d29ce7e3c411dec391655ffdb1b6b0575"
+      "sha256": "6b6519191096614da193ebe07d553b4a422be5dd1457f803cb11f53530e88d3b"
     },
     {
       "bytes": 5458,
@@ -196,9 +226,9 @@
       "sha256": "40569f1e553f0cb340cf81414e072839ca734a7d303c5cb5f1e46c5035590804"
     },
     {
-      "bytes": 114,
+      "bytes": 129,
       "path": "space/requirements.txt",
-      "sha256": "3e359db5a7fb0103c3cbb504cb45e195d1ea7c2bcef513b5b3a5b13132d6a69e"
+      "sha256": "e4fbc8a9d7c9d5bf0955e128a4cb1ba73c98b143daac0ebf5cc9afe79f2016f1"
     },
     {
       "bytes": 160,
@@ -371,7 +401,7 @@
       "sha256": "da0eac829fe43615f7bb149998c2f2762f148790fb0c14d4ba6db4d6b25298f4"
     }
   ],
-  "source_inventory_sha256": "231b988fbe808c67d53f9c51577b9286006937764a343077b4dc8598daf37528",
+  "source_inventory_sha256": "3a4b9eb2525f25f50d302cd657f6890e0ed82931c23fdb338e43d00b58597d78",
   "task": "audio-turn-end-detection",
   "threshold": 0.741000771522522,
   "training_data": {

pyproject.toml

@@ -51,6 +51,7 @@ export = [
 demo = [
   "gradio>=5,<7",
   "onnxruntime>=1.20,<2",
+  "spaces>=0.51,<1",
 ]
 dev = [
   "pytest>=8,<10",
@@ -69,6 +70,7 @@ all = [
   "PyYAML>=6,<7",
   "ruff>=0.9,<1",
   "scikit-learn>=1.5,<2",
+  "spaces>=0.51,<1",
   "torch>=2.4,<3",
   "torchaudio>=2.4,<3",
   "torchcodec>=0.7,<1",
@@ -77,7 +79,7 @@ all = [
 ]
 
 [project.urls]
-Repository = "https://huggingface.co/suvradeepp/tiny-hinglish-turn-detector"
+Model = "https://huggingface.co/suvradeepp/tiny-hinglish-turn-detector"
 Demo = "https://huggingface.co/spaces/suvradeepp/tiny-hinglish-turn-detector"
 
 [tool.hatch.build.targets.wheel]
@@ -95,7 +97,16 @@ markers = [
 [tool.ruff]
 target-version = "py310"
 line-length = 100
-extend-exclude = [".cache", ".venv", "artifacts", "checkpoints", "data", "release"]
+extend-exclude = [
+  ".cache",
+  ".venv",
+  "artifacts",
+  "checkpoints",
+  "data",
+  "release",
+  "upload-ready",
+  "upload-ready-*",
+]
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "B", "UP", "SIM"]

release_provenance.json

@@ -16,7 +16,7 @@
       },
       "MODEL_CARD.md": {
         "bytes": 14805,
-        "sha256": "05162a2792ee71d642605d87bef18089cf5f57b52e6a9b32e6d34cbd26789b29"
+        "sha256": "236a5a2d85be05295459fdd5fd453ed29197b74a9e320ad560f98c2454913c36"
       },
       "Makefile": {
         "bytes": 777,
@@ -28,19 +28,19 @@
       },
       "README.md": {
         "bytes": 14805,
-        "sha256": "05162a2792ee71d642605d87bef18089cf5f57b52e6a9b32e6d34cbd26789b29"
+        "sha256": "236a5a2d85be05295459fdd5fd453ed29197b74a9e320ad560f98c2454913c36"
       },
       "REPORT.md": {
         "bytes": 32272,
-        "sha256": "40284013cd8d435f624464b5e9f7a3427f41a9a6410a5ae917ef34863a9a95b1"
+        "sha256": "26daf79685188e8fcbb36c967ec8ddb51841f7263fbb35aab6242a0ea52b6bee"
       },
       "SOURCE_README.md": {
-        "bytes": 20535,
-        "sha256": "e74584ad5bc721c333d83346d9ee25e4f9a22c4c31f8efcf3ef30089dd3f8d0c"
+        "bytes": 21628,
+        "sha256": "7cd1105e43f17a658005e56904665ab18009eea9dfc0c633c740ac9aae8fe779"
       },
       "app.py": {
-        "bytes": 10381,
-        "sha256": "b07999d898628cd967d82d527d2ae74ebc6e7d050cf48b2bd59d60c683c0699a"
+        "bytes": 11008,
+        "sha256": "e0a9ab19732dab255f20b16e4866a04414228b785e72c139c7eadb2f91be5e36"
       },
       "configs/datasets.json": {
         "bytes": 635,
@@ -86,6 +86,26 @@
         "bytes": 1115,
         "sha256": "a96626ce8e93bff0a88f00f652932c5ac806377e67fc4fec3b03ae34658f9a04"
       },
+      "deployment/kaggle/README.md": {
+        "bytes": 2359,
+        "sha256": "d107cee49a203172ecbb5b6c531a3898e3634690422d80468693bd2f0ceb333a"
+      },
+      "deployment/kaggle/example_inference.py": {
+        "bytes": 852,
+        "sha256": "27d34092619a06744fbdd899906e3f3236cfe5dfe391eedcd98f145f6015687c"
+      },
+      "deployment/kaggle/requirements.txt": {
+        "bytes": 52,
+        "sha256": "0ce722012cff5e44e1fe70632f85689362ed34b2b5c7ef5605e403027089f927"
+      },
+      "deployment/kaggle/smoke_test.py": {
+        "bytes": 892,
+        "sha256": "726bc853d360d105991563e94115bd4bbdb03fe9f5b3c007d712898ff0b5795b"
+      },
+      "deployment/kaggle/turn_detector.py": {
+        "bytes": 12363,
+        "sha256": "83de2bea2eb31b0fa123441a28c7238e122ba4e7986aa87859a2b94bdeab4258"
+      },
       "development_metrics.json": {
         "bytes": 18041,
         "sha256": "ee94447afe6c6027089f0b9f091d4ae0864c22a25a809f3c9303e541d2bcf076"
@@ -107,8 +127,8 @@
         "sha256": "d57a8b0b7e11eebce8b76812548d7e12bcc63c5880ef01633fef4914c8633b02"
       },
       "export_manifest.json": {
-        "bytes": 12431,
-        "sha256": "92bc97c3913e8478dacad988285232c2c678ba906a67697e5a022d3e48a1a2c7"
+        "bytes": 13434,
+        "sha256": "be4953e55580d453992b2590fb85e26e336bbcee66b56a0f3e5198551813cf7d"
       },
       "model.onnx": {
         "bytes": 625431,
@@ -119,8 +139,8 @@
         "sha256": "43636ad5efb642138c281a4582e85f19b5aae2f4f6cca69211169341ae4399b4"
       },
       "pyproject.toml": {
-        "bytes": 2511,
-        "sha256": "2659b459bd0148fc3bb638058533fc1261c2bd7fd15fe0deeb9b5e8e790fcdd9"
+        "bytes": 2601,
+        "sha256": "fab1e0c093a89d5819a7109b9278332c61709e8bf61149486e31399c57a25f12"
       },
       "reference_models/acoustic_baseline.json": {
         "bytes": 1240,
@@ -247,8 +267,12 @@
         "sha256": "146763ebbe4d4ca0858c3fda2f56aa235aa9a4b6686b3216bcea58d148945d04"
       },
       "scripts/build_release.py": {
-        "bytes": 40974,
-        "sha256": "f4bb9e1c5cbde4514fabeeed354fb2fcb7374c3b6abe1245a3f61f6aceb2a2c4"
+        "bytes": 43576,
+        "sha256": "6bcab53184466e3ee5870e87bf85b606db62ddcd06956cd03679502958ea589b"
+      },
+      "scripts/build_upload_folders.py": {
+        "bytes": 17830,
+        "sha256": "0da4af7974df001c27b6fe78d9e2a60ac1fd841a8d48e27a2e499996c58060a7"
       },
       "scripts/compare_models.py": {
         "bytes": 10147,
@@ -267,8 +291,8 @@
         "sha256": "5e97757f74414b2ac003ab5e87a0afeeed88b61eb30baa1801b10a11a57acca4"
       },
       "scripts/export_onnx.py": {
-        "bytes": 17732,
-        "sha256": "cebb6d9ca45bf083f72750e219114d3d29ce7e3c411dec391655ffdb1b6b0575"
+        "bytes": 17939,
+        "sha256": "6b6519191096614da193ebe07d553b4a422be5dd1457f803cb11f53530e88d3b"
       },
       "scripts/freeze_candidate.py": {
         "bytes": 5458,
@@ -303,8 +327,8 @@
         "sha256": "40569f1e553f0cb340cf81414e072839ca734a7d303c5cb5f1e46c5035590804"
       },
       "space/requirements.txt": {
-        "bytes": 114,
-        "sha256": "3e359db5a7fb0103c3cbb504cb45e195d1ea7c2bcef513b5b3a5b13132d6a69e"
+        "bytes": 129,
+        "sha256": "e4fbc8a9d7c9d5bf0955e128a4cb1ba73c98b143daac0ebf5cc9afe79f2016f1"
       },
       "src/turn_detection/__init__.py": {
         "bytes": 160,
@@ -498,6 +522,10 @@
         "bytes": 2378,
         "sha256": "eda48e48a4eea66f4fe3f97b194e8a542d323a5d581ddcdcf4054fb3372bdbea"
       },
+      "tests/test_kaggle_runtime.py": {
+        "bytes": 2566,
+        "sha256": "768de85d1fc1c123e71928c250b91b60b64624a5ec7ceb5787b50b29fbe0c9eb"
+      },
       "tests/test_metrics.py": {
         "bytes": 5291,
         "sha256": "c45739a050fcc1d5611d8dd228bdcc53ff737b0ff71da2aab26490945996d55c"
@@ -531,8 +559,8 @@
         "sha256": "5af81ad7995b6bfd3816b7d97ee1226027659dc5b8a7cb4fe4376fa850dcd14e"
       },
       "tests/test_release_guardrails.py": {
-        "bytes": 19180,
-        "sha256": "452361358e93e92465f70d05bc0232bce195292a1b70bf73ce150810c7c53674"
+        "bytes": 19481,
+        "sha256": "089c87b9e98fbc9b0aab45e29245433a910952c13a854693ce077d170b3c2f2f"
       },
       "tests/test_runtime_controller.py": {
         "bytes": 3086,
@@ -553,6 +581,10 @@
       "tests/test_train_warmstart.py": {
         "bytes": 1785,
         "sha256": "afad22048c9a8a84ec0fa4418596873ddf1d1dfd43e34301bc5ea98da659279e"
+      },
+      "tests/test_upload_folders.py": {
+        "bytes": 2736,
+        "sha256": "0d14aa506b66f42e5c61c8f60b426f2ae7a294245a09627e35b477f213fd2359"
       }
     },
     "space": {
@@ -566,7 +598,7 @@
       },
       "MODEL_CARD.md": {
         "bytes": 14805,
-        "sha256": "05162a2792ee71d642605d87bef18089cf5f57b52e6a9b32e6d34cbd26789b29"
+        "sha256": "236a5a2d85be05295459fdd5fd453ed29197b74a9e320ad560f98c2454913c36"
       },
       "NOTICE": {
         "bytes": 563,
@@ -577,8 +609,8 @@
         "sha256": "a604dbde1c5d837eea5a4a924747df34c0d3af653a8c2e7a5703a9816898ca3f"
       },
       "app.py": {
-        "bytes": 10381,
-        "sha256": "b07999d898628cd967d82d527d2ae74ebc6e7d050cf48b2bd59d60c683c0699a"
+        "bytes": 11008,
+        "sha256": "e0a9ab19732dab255f20b16e4866a04414228b785e72c139c7eadb2f91be5e36"
       },
       "artifacts/model.onnx": {
         "bytes": 625431,
@@ -589,8 +621,8 @@
         "sha256": "43636ad5efb642138c281a4582e85f19b5aae2f4f6cca69211169341ae4399b4"
       },
       "requirements.txt": {
-        "bytes": 114,
-        "sha256": "3e359db5a7fb0103c3cbb504cb45e195d1ea7c2bcef513b5b3a5b13132d6a69e"
+        "bytes": 129,
+        "sha256": "e4fbc8a9d7c9d5bf0955e128a4cb1ba73c98b143daac0ebf5cc9afe79f2016f1"
       },
       "src/turn_detection/__init__.py": {
         "bytes": 160,
@@ -626,5 +658,5 @@
   "metrics_file": "development_metrics.json",
   "metrics_scope": "development",
   "model_file": "model.onnx",
-  "source_and_artifact_inventory_sha256": "f8365e3e5c27cb371be1dd2d701b0f9abc125da008b7d9b310dbcc1d3bae8f4d"
+  "source_and_artifact_inventory_sha256": "29c841cda437d73f0d1a401424a0f8401f6793f358bffae9b12edc2d0db1776a"
 }

scripts/build_release.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import argparse
+import ast
 import errno
 import hashlib
 import json
@@ -24,7 +25,12 @@ _SPACE_CARD_COLORS = frozenset(
 )
 _SPACE_SHORT_DESCRIPTION_MAX_LENGTH = 60
 _SPACE_RUNTIME_REQUIREMENTS = frozenset(
-    {"numpy==2.3.5", "onnxruntime==1.26.0", "soundfile==0.14.0"}
+    {
+        "numpy==2.3.5",
+        "onnxruntime==1.26.0",
+        "soundfile==0.14.0",
+        "spaces==0.51.1",
+    }
 )
 
 
@@ -139,6 +145,62 @@ def _validate_space_requirements(path: Path) -> None:
         )
 
 
+def _validate_space_app(path: Path) -> None:
+    """Require ZeroGPU to wrap the real Gradio inference callback."""
+
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    except (OSError, SyntaxError) as exc:
+        raise SystemExit(f"Space app is unreadable or invalid Python: {path}") from exc
+
+    imports_spaces = any(
+        isinstance(node, ast.Import)
+        and any(alias.name == "spaces" and alias.asname in {None, "spaces"} for alias in node.names)
+        for node in ast.walk(tree)
+    )
+    if not imports_spaces:
+        raise SystemExit("Space app must import spaces for ZeroGPU")
+
+    analyze_function = next(
+        (
+            node
+            for node in tree.body
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
+            and node.name == "analyze_turn"
+        ),
+        None,
+    )
+    if analyze_function is None:
+        raise SystemExit("Space app must define the analyze_turn callback")
+
+    def is_spaces_gpu(decorator: ast.expr) -> bool:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        return (
+            isinstance(target, ast.Attribute)
+            and target.attr == "GPU"
+            and isinstance(target.value, ast.Name)
+            and target.value.id == "spaces"
+        )
+
+    if not any(is_spaces_gpu(item) for item in analyze_function.decorator_list):
+        raise SystemExit("Space analyze_turn callback must use @spaces.GPU")
+
+    callback_is_bound = any(
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr == "click"
+        and any(
+            keyword.arg == "fn"
+            and isinstance(keyword.value, ast.Name)
+            and keyword.value.id == "analyze_turn"
+            for keyword in node.keywords
+        )
+        for node in ast.walk(tree)
+    )
+    if not callback_is_bound:
+        raise SystemExit("Space Analyze button must bind the decorated analyze_turn callback")
+
+
 def _copy_runtime(destination: Path) -> None:
     package_root = destination / "src" / "turn_detection"
     package_root.mkdir(parents=True, exist_ok=True)
@@ -198,6 +260,14 @@ def _copy_project_source(destination: Path, *, include_synthetic_replay: bool) -
             dirs_exist_ok=True,
             ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
         )
+    if (ROOT / "deployment").is_dir():
+        _reject_symlinks(ROOT / "deployment")
+        shutil.copytree(
+            ROOT / "deployment",
+            destination / "deployment",
+            dirs_exist_ok=True,
+            ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
+        )
     safe_reports = {
         "dataset_snapshot_status.json",
         "environment_snapshot.json",
@@ -285,6 +355,11 @@ def _deployment_source_paths() -> list[Path]:
         *sorted((ROOT / "src" / "turn_detection").rglob("*.py")),
         *sorted((ROOT / "scripts").glob("*.py")),
         *sorted((ROOT / "scripts").glob("*.sh")),
+        *(
+            path
+            for path in sorted((ROOT / "deployment").rglob("*"))
+            if path.is_file() and "__pycache__" not in path.parts and path.suffix != ".pyc"
+        ),
         ROOT / "app.py",
         ROOT / "pyproject.toml",
         ROOT / "space" / "requirements.txt",
@@ -774,6 +849,7 @@ def main() -> int:
         )
     _validate_space_card(ROOT / "space" / "README.md")
     _validate_space_requirements(ROOT / "space" / "requirements.txt")
+    _validate_space_app(ROOT / "app.py")
 
     frozen_manifest: dict | None = None
     if not metadata_is_development:

scripts/build_upload_folders.py

@@ -0,0 +1,470 @@
+#!/usr/bin/env python3
+"""Build curated, integrity-checked Kaggle and GitHub upload folders."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import shutil
+import sys
+import tempfile
+from collections import defaultdict
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from scripts.publish_hf import (  # noqa: E402
+    _validate_inventory,
+    _validate_provenance,
+    _validated_release_status,
+)
+
+_KAGGLE_TEMPLATE_FILES = (
+    "README.md",
+    "example_inference.py",
+    "requirements.txt",
+    "smoke_test.py",
+    "turn_detector.py",
+)
+_ROOT_GITHUB_FILES = (
+    ".env.example",
+    ".gitignore",
+    ".python-version",
+    "DATA_CARD.md",
+    "LICENSE",
+    "MODEL_CARD.md",
+    "Makefile",
+    "NOTICE",
+    "README.md",
+    "REPORT.md",
+    "app.py",
+    "pyproject.toml",
+    "requirements-export.txt",
+    "requirements-publish.txt",
+    "requirements-training.txt",
+)
+_GITHUB_ARTIFACTS = (
+    "artifacts/partial-baseline/model.json",
+    "artifacts/partial-shard-preview-tinytcn-4s/best.pt",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/best.pt",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/cpu_benchmark.json",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/export_manifest.json",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/history.json",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/model.onnx",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/model_metadata.json",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/onnx_benchmark.json",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/onnx_e2e_benchmark.json",
+    "artifacts/partial-shard-warmstart-lr3e4-5ep/resolved_config.json",
+)
+_COLLECTION_FILES = (
+    "assignments.jsonl",
+    "assignments.summary.json",
+    "controller_replay_fixture.jsonl",
+)
+_PUBLIC_REPORTS = (
+    "controller_replay_integration.jsonl",
+    "controller_replay_integration.summary.json",
+    "dataset_snapshot_status.json",
+    "environment_snapshot.json",
+    "partial_baseline_metrics.json",
+    "partial_iid_split.json",
+    "partial_shard_audit.json",
+    "partial_source_holdout_baseline_metrics.json",
+    "partial_source_holdout_comparison.json",
+    "partial_source_holdout_split.json",
+    "partial_source_holdout_tinytcn_metrics.json",
+    "partial_tinytcn_comparison.json",
+    "partial_tinytcn_e2e_benchmark.json",
+    "partial_tinytcn_failures.json",
+    "partial_tinytcn_metrics.json",
+    "partial_tinytcn_onnx_benchmark.json",
+    "partial_tinytcn_pytorch_benchmark.json",
+    "partial_tinytcn_silence_sensitivity.json",
+)
+_SECRET_PATTERNS = {
+    "Hugging Face token": re.compile(r"\bhf_[A-Za-z0-9]{20,}\b"),
+    "GitHub token": re.compile(r"\b(?:ghp|github_pat)_[A-Za-z0-9_]{20,}\b"),
+    "OpenAI-style token": re.compile(r"\bsk-[A-Za-z0-9_-]{20,}\b"),
+    "private key": re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),
+    "absolute macOS user path": re.compile("/" + r"Users/[^/\s]+/"),
+}
+_MARKDOWN_LINK = re.compile(r"!?\[[^\]]*\]\(([^)]+)\)")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--release-dir", default="release")
+    parser.add_argument("--output", default="upload-ready")
+    parser.add_argument(
+        "--allow-development-release",
+        action="store_true",
+        help="package the visibly labelled development preview",
+    )
+    return parser.parse_args()
+
+
+def _resolve_inside_root(value: str, *, purpose: str) -> Path:
+    unresolved = Path(value)
+    path = (unresolved if unresolved.is_absolute() else ROOT / unresolved).resolve()
+    try:
+        path.relative_to(ROOT)
+    except ValueError as exc:
+        raise SystemExit(f"{purpose} must stay inside the project directory") from exc
+    return path
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _copy_file(source: Path, destination: Path) -> None:
+    if source.is_symlink() or not source.is_file():
+        raise SystemExit(f"refusing non-regular upload source: {source}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, destination)
+
+
+def _copy_tree(source: Path, destination: Path, *, suffixes: set[str] | None = None) -> None:
+    if source.is_symlink() or not source.is_dir():
+        raise SystemExit(f"upload source directory is missing or unsafe: {source}")
+    for path in sorted(source.rglob("*")):
+        if path.is_symlink():
+            raise SystemExit(f"refusing symlink in upload source: {path}")
+        if not path.is_file():
+            continue
+        if "__pycache__" in path.parts or path.suffix == ".pyc":
+            continue
+        if suffixes is not None and path.suffix not in suffixes:
+            continue
+        _copy_file(path, destination / path.relative_to(source))
+
+
+def _load_validated_release(release_dir: Path) -> tuple[dict, bool]:
+    manifest_path = release_dir / "release_manifest.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise SystemExit("release_manifest.json is missing or invalid; rebuild release") from exc
+    if not isinstance(manifest, dict):
+        raise SystemExit("release_manifest.json must contain an object")
+    _validate_inventory(release_dir, manifest)
+    _validate_provenance(release_dir)
+    development_only = _validated_release_status(release_dir, manifest)
+    return manifest, development_only
+
+
+def _require_identical(left: Path, right: Path, label: str) -> None:
+    if left.stat().st_size != right.stat().st_size or _sha256(left) != _sha256(right):
+        raise SystemExit(f"{label} differs from the validated Hugging Face release")
+
+
+def _build_kaggle_folder(release_dir: Path, destination: Path, metrics_name: str) -> None:
+    model_release = release_dir / "model"
+    for name in _KAGGLE_TEMPLATE_FILES:
+        _copy_file(ROOT / "deployment" / "kaggle" / name, destination / name)
+    for source_name, destination_name in (
+        ("model.onnx", "model.onnx"),
+        ("model_metadata.json", "model_metadata.json"),
+        ("export_manifest.json", "export_manifest.json"),
+        (
+            metrics_name,
+            "development_metrics.json" if "development" in metrics_name else "test_metrics.json",
+        ),
+        ("MODEL_CARD.md", "MODEL_CARD.md"),
+        ("DATA_CARD.md", "DATA_CARD.md"),
+        ("LICENSE", "LICENSE"),
+        ("NOTICE", "NOTICE"),
+    ):
+        _copy_file(model_release / source_name, destination / destination_name)
+    _copy_file(
+        model_release / "run_artifacts" / "onnx_e2e_benchmark.json",
+        destination / "benchmark.json",
+    )
+
+
+def _github_gitignore() -> str:
+    base = (ROOT / ".gitignore").read_text(encoding="utf-8").rstrip()
+    by_parent: dict[Path, list[Path]] = defaultdict(list)
+    for relative in map(Path, _GITHUB_ARTIFACTS):
+        by_parent[relative.parent].append(relative)
+    lines = [
+        base,
+        "",
+        "# Exact public-preview artifacts included by build_upload_folders.py",
+        "!artifacts/",
+        "artifacts/*",
+    ]
+    for parent in sorted(by_parent, key=lambda item: item.as_posix()):
+        lines.append(f"!{parent.as_posix()}/")
+        lines.append(f"{parent.as_posix()}/*")
+        for relative in sorted(by_parent[parent], key=lambda item: item.as_posix()):
+            lines.append(f"!{relative.as_posix()}")
+    return "\n".join(lines) + "\n"
+
+
+def _build_github_folder(destination: Path) -> None:
+    for name in _ROOT_GITHUB_FILES:
+        _copy_file(ROOT / name, destination / name)
+    (destination / ".gitignore").write_text(_github_gitignore(), encoding="utf-8")
+
+    _copy_tree(ROOT / ".github", destination / ".github")
+    _copy_tree(ROOT / "src", destination / "src", suffixes={".py", ".typed"})
+    _copy_tree(ROOT / "scripts", destination / "scripts", suffixes={".py", ".sh"})
+    _copy_tree(ROOT / "configs", destination / "configs", suffixes={".json", ".yaml", ".yml"})
+    _copy_tree(ROOT / "tests", destination / "tests", suffixes={".py"})
+    _copy_tree(ROOT / "docs", destination / "docs", suffixes={".md"})
+    _copy_tree(ROOT / "deployment", destination / "deployment", suffixes={".md", ".py", ".txt"})
+
+    for name in ("README.md", "requirements.txt"):
+        _copy_file(ROOT / "space" / name, destination / "space" / name)
+    for name in _COLLECTION_FILES:
+        _copy_file(
+            ROOT / "data" / "collection" / name,
+            destination / "data" / "collection" / name,
+        )
+    for name in _PUBLIC_REPORTS:
+        _copy_file(ROOT / "reports" / name, destination / "reports" / name)
+    for relative in _GITHUB_ARTIFACTS:
+        _copy_file(ROOT / relative, destination / relative)
+    _copy_file(
+        ROOT / "artifacts/partial-baseline/model.json",
+        destination / "reference_models/acoustic_baseline.json",
+    )
+
+
+def _inventory(
+    folder: Path, *, excluded: set[str] | None = None
+) -> dict[str, dict[str, int | str]]:
+    excluded = excluded or set()
+    return {
+        path.relative_to(folder).as_posix(): {
+            "bytes": path.stat().st_size,
+            "sha256": _sha256(path),
+        }
+        for path in sorted(folder.rglob("*"))
+        if path.is_file() and path.relative_to(folder).as_posix() not in excluded
+    }
+
+
+def _write_package_evidence(
+    folder: Path,
+    *,
+    kind: str,
+    development_only: bool,
+    release_inventory_sha256: str,
+) -> None:
+    manifest_path = folder / "UPLOAD_MANIFEST.json"
+    checksums_path = folder / "SHA256SUMS"
+    payload = {
+        "format_version": 1,
+        "package_kind": kind,
+        "development_only": development_only,
+        "source_release_inventory_sha256": release_inventory_sha256,
+        "files": _inventory(folder),
+    }
+    manifest_path.write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    checksums = _inventory(folder, excluded={checksums_path.name})
+    checksums_path.write_text(
+        "".join(f"{evidence['sha256']}  {relative}\n" for relative, evidence in checksums.items()),
+        encoding="utf-8",
+    )
+
+
+def _secret_findings(folder: Path) -> list[str]:
+    findings: list[str] = []
+    for path in sorted(folder.rglob("*")):
+        if path.is_symlink():
+            findings.append(f"symlink: {path.relative_to(folder)}")
+            continue
+        if not path.is_file() or path.suffix in {".onnx", ".pt"}:
+            continue
+        if path.name == ".env" or path.name == "hf_publish_receipt.json":
+            findings.append(f"forbidden file: {path.relative_to(folder)}")
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        for label, pattern in _SECRET_PATTERNS.items():
+            if pattern.search(text):
+                findings.append(f"{label}: {path.relative_to(folder)}")
+    return findings
+
+
+def _broken_local_markdown_links(folder: Path) -> list[str]:
+    broken: list[str] = []
+    for markdown in sorted(folder.rglob("*.md")):
+        text = markdown.read_text(encoding="utf-8")
+        for match in _MARKDOWN_LINK.finditer(text):
+            raw = match.group(1).strip().strip("<>")
+            raw = raw.split(maxsplit=1)[0].strip("\"'")
+            parsed = urlsplit(raw)
+            if parsed.scheme or parsed.netloc or not parsed.path:
+                continue
+            target = (markdown.parent / unquote(parsed.path)).resolve()
+            try:
+                target.relative_to(folder.resolve())
+            except ValueError:
+                broken.append(f"{markdown.relative_to(folder)} -> {raw}")
+                continue
+            if not target.exists():
+                broken.append(f"{markdown.relative_to(folder)} -> {raw}")
+    return broken
+
+
+def _verify_sha256sums(folder: Path) -> None:
+    path = folder / "SHA256SUMS"
+    for line in path.read_text(encoding="utf-8").splitlines():
+        expected, relative = line.split("  ", 1)
+        target = folder / relative
+        if not target.is_file() or _sha256(target) != expected:
+            raise SystemExit(f"generated checksum failed validation: {folder.name}/{relative}")
+
+
+def _validate_output(kaggle: Path, github: Path) -> None:
+    nested_kaggle = [path for path in kaggle.rglob("*") if path.is_file() and path.parent != kaggle]
+    if nested_kaggle:
+        raise SystemExit(f"Kaggle drag-and-drop package is not flat: {nested_kaggle[0]}")
+    for folder in (kaggle, github):
+        findings = _secret_findings(folder)
+        if findings:
+            raise SystemExit(f"unsafe generated upload package: {findings[0]}")
+        _verify_sha256sums(folder)
+    broken = _broken_local_markdown_links(github)
+    if broken:
+        raise SystemExit(f"generated GitHub package has a broken local link: {broken[0]}")
+    oversized = [
+        path for path in github.rglob("*") if path.is_file() and path.stat().st_size >= 100_000_000
+    ]
+    if oversized:
+        raise SystemExit(f"generated GitHub file exceeds 100 MB: {oversized[0]}")
+
+
+def _replace_directory(staged: Path, destination: Path) -> None:
+    backup: Path | None = None
+    if destination.exists():
+        backup = Path(
+            tempfile.mkdtemp(prefix=f".{destination.name}.previous-", dir=destination.parent)
+        )
+        backup.rmdir()
+        os.replace(destination, backup)
+    try:
+        os.replace(staged, destination)
+    except Exception:
+        if backup is not None and backup.exists() and not destination.exists():
+            os.replace(backup, destination)
+        raise
+    if backup is not None:
+        shutil.rmtree(backup)
+
+
+def main() -> int:
+    args = parse_args()
+    release_dir = _resolve_inside_root(args.release_dir, purpose="--release-dir")
+    destination = _resolve_inside_root(args.output, purpose="--output")
+    relative_output = destination.relative_to(ROOT)
+    valid_output_root = bool(relative_output.parts) and (
+        relative_output.parts[0] == "upload-ready"
+        or relative_output.parts[0].startswith("upload-ready-")
+    )
+    if not valid_output_root:
+        raise SystemExit("--output must be upload-ready/ or upload-ready-*/")
+    if (
+        destination == ROOT
+        or release_dir == destination
+        or destination in release_dir.parents
+        or release_dir in destination.parents
+    ):
+        raise SystemExit("upload output overlaps the project or release input")
+    if Path(args.output).is_symlink():
+        raise SystemExit("refusing a symlink upload destination")
+
+    manifest, development_only = _load_validated_release(release_dir)
+    if development_only and not args.allow_development_release:
+        raise SystemExit("development preview requires --allow-development-release")
+    model_release = release_dir / "model"
+    _require_identical(
+        ROOT / "artifacts/partial-shard-warmstart-lr3e4-5ep/model.onnx",
+        model_release / "model.onnx",
+        "ONNX artifact",
+    )
+    _require_identical(
+        ROOT / "artifacts/partial-shard-warmstart-lr3e4-5ep/model_metadata.json",
+        model_release / "model_metadata.json",
+        "model metadata",
+    )
+    _require_identical(
+        ROOT / "artifacts/partial-shard-warmstart-lr3e4-5ep/export_manifest.json",
+        model_release / "export_manifest.json",
+        "export manifest",
+    )
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    staged = Path(tempfile.mkdtemp(prefix=f".{destination.name}.staging-", dir=destination.parent))
+    kaggle = staged / "kaggle-model"
+    github = staged / "github-repository"
+    kaggle.mkdir()
+    github.mkdir()
+    metrics_name = "development_metrics.json" if development_only else "test_metrics.json"
+    _build_kaggle_folder(release_dir, kaggle, metrics_name)
+    _build_github_folder(github)
+    release_digest = str(manifest["release_inventory_sha256"])
+    _write_package_evidence(
+        kaggle,
+        kind="kaggle_model_drag_and_drop",
+        development_only=development_only,
+        release_inventory_sha256=release_digest,
+    )
+    _write_package_evidence(
+        github,
+        kind="github_repository",
+        development_only=development_only,
+        release_inventory_sha256=release_digest,
+    )
+    _validate_output(kaggle, github)
+    summary = {
+        "format_version": 1,
+        "development_only": development_only,
+        "source_release_inventory_sha256": release_digest,
+        "folders": {
+            "kaggle-model": {
+                "files": len(_inventory(kaggle)),
+                "bytes": sum(path.stat().st_size for path in kaggle.iterdir() if path.is_file()),
+            },
+            "github-repository": {
+                "files": len(_inventory(github)),
+                "bytes": sum(path.stat().st_size for path in github.rglob("*") if path.is_file()),
+            },
+        },
+    }
+    (staged / "README.md").write_text(
+        "# Upload-ready folders\n\n"
+        "- Upload the **contents** of `kaggle-model/` as one Kaggle ONNX model variation.\n"
+        "- Upload the **contents** of `github-repository/` to a new GitHub repository.\n"
+        "- Both packages are development previews; read their cards before changing visibility.\n",
+        encoding="utf-8",
+    )
+    (staged / "UPLOAD_SUMMARY.json").write_text(
+        json.dumps(summary, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    _replace_directory(staged, destination)
+    print(json.dumps(summary, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/export_onnx.py

@@ -67,6 +67,11 @@ def _deployment_source_paths() -> list[Path]:
         *sorted((REPOSITORY_ROOT / "src" / "turn_detection").rglob("*.py")),
         *sorted((REPOSITORY_ROOT / "scripts").glob("*.py")),
         *sorted((REPOSITORY_ROOT / "scripts").glob("*.sh")),
+        *(
+            path
+            for path in sorted((REPOSITORY_ROOT / "deployment").rglob("*"))
+            if path.is_file() and "__pycache__" not in path.parts and path.suffix != ".pyc"
+        ),
         REPOSITORY_ROOT / "app.py",
         REPOSITORY_ROOT / "pyproject.toml",
         REPOSITORY_ROOT / "space" / "requirements.txt",

space/requirements.txt

@@ -2,3 +2,4 @@
 numpy==2.3.5
 onnxruntime==1.26.0
 soundfile==0.14.0
+spaces==0.51.1

tests/test_kaggle_runtime.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+import unittest
+from pathlib import Path
+
+import numpy as np
+
+from turn_detection.runtime.features import (
+    FrontendConfig as CanonicalFrontendConfig,
+)
+from turn_detection.runtime.features import (
+    log_mel_spectrogram as canonical_log_mel_spectrogram,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+MODULE_PATH = ROOT / "deployment" / "kaggle" / "turn_detector.py"
+SPEC = importlib.util.spec_from_file_location("kaggle_turn_detector", MODULE_PATH)
+if SPEC is None or SPEC.loader is None:  # pragma: no cover - import machinery failure
+    raise RuntimeError(f"cannot load {MODULE_PATH}")
+KAGGLE_RUNTIME = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = KAGGLE_RUNTIME
+SPEC.loader.exec_module(KAGGLE_RUNTIME)
+
+
+class KaggleRuntimeParityTest(unittest.TestCase):
+    def test_flat_bundle_frontend_matches_canonical_runtime(self) -> None:
+        canonical_config = CanonicalFrontendConfig(max_seconds=4.0)
+        kaggle_config = KAGGLE_RUNTIME.FrontendConfig(**canonical_config.to_dict())
+        for sample_rate in (8_000, 16_000, 48_000):
+            timeline = np.arange(round(sample_rate * 1.37), dtype=np.float32) / sample_rate
+            signal = 0.13 * np.sin(2.0 * np.pi * 337.0 * timeline)
+            stereo = np.stack((signal, signal * 0.7), axis=1)
+            expected_features, expected_mask = canonical_log_mel_spectrogram(
+                stereo,
+                sample_rate,
+                canonical_config,
+            )
+            actual_features, actual_mask = KAGGLE_RUNTIME.log_mel_spectrogram(
+                stereo,
+                sample_rate,
+                kaggle_config,
+            )
+            np.testing.assert_array_equal(actual_features, expected_features)
+            np.testing.assert_array_equal(actual_mask, expected_mask)
+
+    def test_controller_threshold_relaxation_matches_serialized_policy(self) -> None:
+        detector = object.__new__(KAGGLE_RUNTIME.TurnDetector)
+        detector.controller = KAGGLE_RUNTIME.ControllerConfig(
+            endpoint_threshold=0.74,
+            long_pause_threshold=0.56,
+            min_silence_ms=200.0,
+            relax_after_ms=800.0,
+            max_silence_ms=1_800.0,
+            required_confirmations=1,
+        )
+        self.assertEqual(detector.threshold_for_silence(300.0), 0.74)
+        self.assertAlmostEqual(detector.threshold_for_silence(1_300.0), 0.65)
+        self.assertEqual(detector.threshold_for_silence(2_000.0), 0.56)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_release_guardrails.py

@@ -86,7 +86,11 @@ class ReleaseGuardrailTest(unittest.TestCase):
             self.assertFalse((destination / "old.txt").exists())
 
     def test_space_card_rejects_server_invalid_frontmatter(self) -> None:
-        from scripts.build_release import _validate_space_card, _validate_space_requirements
+        from scripts.build_release import (
+            _validate_space_app,
+            _validate_space_card,
+            _validate_space_requirements,
+        )
 
         valid = """---
 title: Test Space
@@ -123,7 +127,8 @@ short_description: Tiny endpoint detector
 
             requirements = Path(directory) / "requirements.txt"
             requirements.write_text(
-                "# ZeroGPU CPython 3.12\nnumpy==2.3.5\nonnxruntime==1.26.0\nsoundfile==0.14.0\n",
+                "# ZeroGPU CPython 3.12\nnumpy==2.3.5\nonnxruntime==1.26.0\n"
+                "soundfile==0.14.0\nspaces==0.51.1\n",
                 encoding="utf-8",
             )
             _validate_space_requirements(requirements)
@@ -131,6 +136,25 @@ short_description: Tiny endpoint detector
             with self.assertRaisesRegex(SystemExit, "CPython-3.12-compatible"):
                 _validate_space_requirements(requirements)
 
+            app = Path(directory) / "app.py"
+            valid_app = """
+try:
+    import spaces
+except ModuleNotFoundError:
+    spaces = None
+
+@spaces.GPU(duration=10)
+def analyze_turn(audio):
+    return audio
+
+analyze.click(fn=analyze_turn, inputs=[], outputs=[])
+"""
+            app.write_text(valid_app, encoding="utf-8")
+            _validate_space_app(app)
+            app.write_text(valid_app.replace("@spaces.GPU(duration=10)\n", ""), encoding="utf-8")
+            with self.assertRaisesRegex(SystemExit, "@spaces.GPU"):
+                _validate_space_app(app)
+
     def test_synthetic_replay_must_be_labelled_and_hash_bound(self) -> None:
         from scripts.build_release import _validate_synthetic_replay
 
@@ -253,6 +277,8 @@ short_description: Tiny endpoint detector
             )
 
     def test_development_metrics_are_never_labelled_as_test_metrics(self) -> None:
+        from scripts.build_release import _deployment_source_paths
+
         runtime_python = self._onnx_runtime_python()
         fixture = ROOT / "artifacts" / "smoke" / "model.onnx"
         if runtime_python is None or not fixture.is_file():
@@ -312,18 +338,7 @@ short_description: Tiny endpoint detector
                 ),
                 encoding="utf-8",
             )
-            source_files = [
-                evidence(path)
-                for path in [
-                    *sorted((ROOT / "src" / "turn_detection").rglob("*.py")),
-                    *sorted((ROOT / "scripts").glob("*.py")),
-                    *sorted((ROOT / "scripts").glob("*.sh")),
-                    ROOT / "app.py",
-                    ROOT / "pyproject.toml",
-                    ROOT / "space" / "requirements.txt",
-                    *sorted(ROOT.glob("requirements-*.txt")),
-                ]
-            ]
+            source_files = [evidence(path) for path in _deployment_source_paths()]
             source_files = sorted(source_files, key=lambda item: str(item["path"]))
             source_inventory_sha256 = hashlib.sha256(
                 json.dumps(source_files, sort_keys=True, separators=(",", ":")).encode()

tests/test_upload_folders.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from scripts.build_upload_folders import (
+    _GITHUB_ARTIFACTS,
+    _broken_local_markdown_links,
+    _github_gitignore,
+    _secret_findings,
+)
+
+
+class UploadFolderGuardrailTest(unittest.TestCase):
+    def test_secret_scanner_allows_placeholder_and_rejects_real_token_shape(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / ".env.example").write_text("HF_TOKEN=hf_replace_me\n", encoding="utf-8")
+            self.assertEqual(_secret_findings(root), [])
+            (root / "bad.txt").write_text("HF_TOKEN=hf_" + "A" * 30, encoding="utf-8")
+            self.assertIn("Hugging Face token: bad.txt", _secret_findings(root))
+
+    def test_markdown_guard_rejects_only_broken_local_links(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / "present.md").write_text("ok\n", encoding="utf-8")
+            readme = root / "README.md"
+            readme.write_text(
+                "[local](present.md) [anchor](#section) [web](https://example.com)\n",
+                encoding="utf-8",
+            )
+            self.assertEqual(_broken_local_markdown_links(root), [])
+            readme.write_text("[missing](absent.md)\n", encoding="utf-8")
+            self.assertEqual(_broken_local_markdown_links(root), ["README.md -> absent.md"])
+
+    def test_generated_gitignore_tracks_only_curated_artifacts(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / ".gitignore").write_text(_github_gitignore(), encoding="utf-8")
+            subprocess.run(["git", "init", "-q"], cwd=root, check=True)
+            for relative in _GITHUB_ARTIFACTS:
+                path = root / relative
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_bytes(b"curated")
+                completed = subprocess.run(
+                    ["git", "check-ignore", "--quiet", relative],
+                    cwd=root,
+                    check=False,
+                )
+                self.assertEqual(completed.returncode, 1, relative)
+
+            excluded = root / "artifacts" / "debug-run" / "model.pt"
+            excluded.parent.mkdir(parents=True)
+            excluded.write_bytes(b"excluded")
+            completed = subprocess.run(
+                ["git", "check-ignore", "--quiet", str(excluded.relative_to(root))],
+                cwd=root,
+                check=False,
+            )
+            self.assertEqual(completed.returncode, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()