# Run a hessian AI & JAIF recipe from Hugging Face

The [hessian AI & JAIF website](https://ctauchmann-hessian-recipes.static.hf.space/)
contains both the reading site and an executable source snapshot under `sources/`.
The Space uses **Protected** visibility: the website and its approved source
downloads are public, while the Hugging Face repository and Git clone remain
private. GitHub is the private collaborative source of truth; it is not required
to read the public snapshot. Share the direct App address above, rather than the
Hugging Face repository page, with visitors who do not have repository access.

During the Private deployment checked on 20 October 2026, the authenticated App
and its linked source assets worked, while HF repository resolve downloads
returned 403 because this personal account had reached its private-storage limit.
That is a historical access check; the Protected App now serves pages and source
downloads without login. A fresh authenticated HF clone has not been verified.
Use the [private GitHub checkout](https://github.com/ChTauchmann/hessian-recipes)
and its root README for collaborative execution. The clone
instructions below describe the authenticated source-snapshot route; they do not
establish that a fresh remote clone has succeeded.

## Source snapshot and private repository access

The website's source links expose individual files beneath `sources/`; the
published manifest lists their paths and checksums. That public access does not
make the Hub repository clonable. Use an authorized repository checkout for the
normal installation steps below.

For the JAIF installation, use `/pfss/mlde/workspaces/mlde_wsp_JAIF/hessian_recipes`
and load local login variables from `/pfss/mlde/workspaces/mlde_wsp_JAIF/tauchmann/.env`
as described in [operations](../../docs/operations.md). That owner-only file stays
outside the checkout; the following clone instructions are for other installations.

Use the Hugging Face authentication already configured on your machine. Do not
place an access token in a URL, shell command, recipe file or browser-side script.
If authentication is not configured, follow the official
[Hub authentication guide](https://huggingface.co/docs/huggingface_hub/guides/cli#hf-auth-login).

```bash
git clone https://huggingface.co/spaces/ctauchmann/hessian-recipes
cd hessian-recipes/sources
uv venv .venv --python python3.11
uv pip install --python .venv/bin/python -e .
.venv/bin/hessian-recipes --help
.venv/bin/hessian-recipes demo --output runs/first-demo
cat runs/first-demo/summary.json
```

This first command sequence runs authored synthetic fixtures without a model,
API key or GPU. Fixture scores establish software wiring only. Use a fresh output
directory for each run. Package installation still requires the normal package
index; optional GPU, NeMo Gym and Verifiers stacks have separate setup instructions.
The Space itself performs no model inference or training.

## Choose the next workflow

- [Evaluate a local model or pipeline](../../docs/evaluation.md).
- [Post-train or distill a reasoning model](../../docs/training.md).
- [Reproduce the German Qwen SFT pilot](../../docs/use-cases/german-reasoning.md).
- [Use native agentic RL](../../docs/use-cases/german-agent-rl.md) or
  [NeMo Gym and Verifiers](../../docs/agent-gyms.md).
- [Inspect evidence and limitations](../../docs/validation.md).

The pinned scripts/configurations, tests, dependency files, authored development
fixtures and documentation are included. Downloaded datasets, model weights,
adapters, virtual environments, caches, raw outputs and private run directories
are excluded. Hardware-specific paths in recorded pilot instructions must be
adapted to the local installation; the snapshot does not include those model/data
artifacts. The domain recipes remain sketches.

## Contribute a change

Use the [private GitHub repository](https://github.com/ChTauchmann/hessian-recipes)
for branches, pull requests, reviews and changes to recipes, code or documentation.
The [deployment workflow](README.md#publish-after-github-checks) rebuilds and
publishes a source snapshot after successful checks on the current `main` commit.
Direct edits to generated Space pages are not part of this workflow and can be
replaced by the next deployment. Running the source snapshot locally does not
publish it. CI uses short-lived OIDC credentials and explicit Protected visibility.
It verifies repository bytes, the public App manifest and representative assets
and source files, plus denial of anonymous Hub raw-file access. It needs no
App-access JWT for this public website. No personal Hugging Face token is stored
as a GitHub secret.

## Verify provenance

At the Space repository root, `hub-manifest.json` records the source history
commit, exact source file hashes, generated page hashes and any uncommitted inputs
present when it was built. The exact bytes are the hash-bound snapshot; the
history reference alone does not describe uncommitted edits. Aggregated evidence
in the documentation is included; full ignored run artifacts remain outside the
Space. No recorded model is release eligible.

## Check the published Protected App

Protected deployment checks the public App without a login or signed URL. It
still authenticates repository metadata reads to establish that the repository
remains private and that its commit and exact files match the approved bundle.
CI's Protected deployment receipt records `served_manifest_matches: true` and
`app_verified_by_ci: true` after the checks pass.

Run this read-only check after CI publication from a clean JAIF checkout of the
same deployed commit. Use the exact CI build bundle, or rebuild it from that
commit as below. The publishing environment needs the installed project and
`huggingface_hub==1.33.0`; the JAIF core environment includes that client. Choose
fresh output paths each time:

```bash
cd /pfss/mlde/workspaces/mlde_wsp_JAIF/hessian_recipes
set -a
. /pfss/mlde/workspaces/mlde_wsp_JAIF/tauchmann/.env
set +a
DEPLOY_SHA=$(git rev-parse HEAD)
.venv/bin/python -m hessian_recipes.hf_recipe_hub \
  --output runs/huggingface/my-app-check-bundle --visibility protected
.venv/bin/python -m hessian_recipes.hub_deploy verify-app \
  --expected-sha "$DEPLOY_SHA" \
  --bundle runs/huggingface/my-app-check-bundle \
  --visibility protected \
  --receipt runs/huggingface/my-app-check-receipt.json
```

This command does not upload files, start jobs or require a GitHub Actions event.
It checks the local bundle/source identity, approved Protected Space, remote bytes,
the public served manifest and representative assets/source, and denial of
anonymous Hub raw-file access. A checkout or bundle that differs from the deployed
content fails rather than passing as the requested revision. Protected mode does
not mint an App-access JWT; public App probes carry no account authorization.
Keep that receipt under ignored `runs/` alongside the CI deployment receipt.
`hub_deploy publish` defaults to strict App verification; the CI workflow
explicitly selects repository verification and Protected mode, which additionally
verifies the public App.

Private mode remains the CLI default for a separately authorized Private
deployment. Use matching `--visibility private` for its build and verification;
the commands require the existing Space to have that visibility and do not
change it. In the earlier Private deployment on 21 October 2026, the OIDC
publisher could not mint an App-access JWT (HTTP 401), so its repository-only
receipt recorded `served_manifest_matches: null` and `app_verified_by_ci: false`.
An owning account's local credential can verify a Private App through a
five-minute Space JWT; tokens and signed URLs stay out of logs and receipts.
These Private-mode findings do not describe the current public Protected App.

## Optional development checks

The optional development checks can run from the source directory:

```bash
uv pip install --python .venv/bin/python -e '.[dev]'
.venv/bin/python -m pytest -q
```

Tests requiring isolated optional upstream stacks are skipped when those stacks
are absent. Model/GPU qualification is separate from these software checks.
