Release NanoJev-Web browser action model

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/assets/browser-demo.png filter=lfs diff=lfs merge=lfs -text
+docs/assets/seed-43129.gif filter=lfs diff=lfs merge=lfs -text
+model/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,12 @@
+# Local runtime and browser evidence must never be uploaded.
+.local/
+.runtime/
+.venv/
+node_modules/
+__pycache__/
+*.pyc
+.env
+.env.*
+.DS_Store
+*.log
+runs/

LICENSE

@@ -0,0 +1,23 @@
+NanoJev-Web license and attribution
+
+This repository contains components under two upstream licenses:
+
+1. NanoJev-derived decision architecture, head, inference implementation and
+   NanoJev-Web runtime additions: MIT terms in licenses/NanoJev-MIT.txt.
+   The original NanoJev copyright notice is retained in that file.
+2. Qwen3-0.6B backbone weights, configuration and tokenizer: Apache License 2.0
+   in licenses/Qwen-Apache-2.0.txt.
+
+The complete model checkpoint incorporates the Qwen backbone and NanoJev-derived
+head. Retain both notices when redistributing it. Browser head parameters were
+further trained on synthetic browser decision states. Runtime and documentation
+were adapted for a browser-only distribution. These changes are described in
+README.md and docs/TRAINING.md.
+
+Upstream sources:
+https://github.com/TianyuCodings/NanoJev
+https://huggingface.co/C-Tianyu/NanoJev
+https://huggingface.co/Qwen/Qwen3-0.6B
+
+Third-party installed dependencies retain their own licenses; node_modules and
+Python packages are not bundled in the upload artifact.

MANIFEST.json

@@ -0,0 +1,227 @@
+{
+  "version": "1.0.0",
+  "documentation_revision": 7,
+  "distribution": "model-and-browser-runtime",
+  "files": {
+    ".gitattributes": {
+      "bytes": 50,
+      "sha256": "ee05350c7fda0af4da116020dd7b976d731de3beed4f5e717d5bcc95ead24550"
+    },
+    ".gitignore": {
+      "bytes": 153,
+      "sha256": "cd833291e588d262baa004f1bb00e7a97dd20c9bf09114bf7fb0176bc68d02e7"
+    },
+    "LICENSE": {
+      "bytes": 1061,
+      "sha256": "37a9c907152bf9e33adf0376fea426e4af1ff268ba8040b88cb5178b4e40dbb6"
+    },
+    "PROVENANCE.json": {
+      "bytes": 1006,
+      "sha256": "96628b16a9784ccd0c6fecdc4dcc4213afafaf411f052ecde54ceca9c8b6d408"
+    },
+    "README.md": {
+      "bytes": 8191,
+      "sha256": "2f751fbb280bd4b182f11deb3812c6b1e8df9e8975d0c2171673ac54f143623c"
+    },
+    "docs/ACTIONS.md": {
+      "bytes": 5151,
+      "sha256": "32b371bad8e5465e8173a5fd6321e5ada47c3bdfdd96a075ad8560b560210fd5"
+    },
+    "docs/INTEGRATION.md": {
+      "bytes": 7595,
+      "sha256": "155705fe56cd7d1bf7dd8c77ae2da9e6421ecac87541310d3f6f66c46668e0e5"
+    },
+    "docs/PRIVACY.md": {
+      "bytes": 3988,
+      "sha256": "bb0296e9886e19420e8da97d829f1d165cca45180af70de9b2c483d09e4699c7"
+    },
+    "docs/PUBLISHING.md": {
+      "bytes": 3736,
+      "sha256": "cb63b1ffa8801b48e900458013b26fc092987c0f2f27a77d665fe4ec1e508053"
+    },
+    "docs/SINGLE_FORM_REPORT.md": {
+      "bytes": 15900,
+      "sha256": "3141d1ad8047a90f30d7a60b644cc80d17b3dfff206fcbca6e4f1e463e2dd28f"
+    },
+    "docs/TRAINING.md": {
+      "bytes": 3651,
+      "sha256": "b41069afc8be09875ba90f8aeab00b8ea9b2de586aab43f05b6f41dc98982884"
+    },
+    "docs/assets/browser-demo.png": {
+      "bytes": 563972,
+      "sha256": "95a778e02ea9e444aba3926d3f8b03a6cc1a22e53d4eee6315f92c189a9604ca"
+    },
+    "docs/assets/seed-43129.gif": {
+      "bytes": 1147189,
+      "sha256": "4e86be028cf41f9b3cab7e62626a6b0d1965c6e7139dbc68a472f9b40e1fecd8"
+    },
+    "docs/demo/decisions.json": {
+      "bytes": 185132,
+      "sha256": "227bbef162b48b5c2887a05443b18bd8af0ab566b82a9c90abf564e128e82c78"
+    },
+    "docs/demo/measurements.json": {
+      "bytes": 2500,
+      "sha256": "1c12802129b9bd6b8dee5561131bb8dc0dc3fcabfe2bf5a859b5ac135f799c16"
+    },
+    "docs/demo/media-provenance.json": {
+      "bytes": 1285,
+      "sha256": "7140e6854691a4f31506ec5ce2657cfc4ac57eb6c5947874506a5b48a166b2c9"
+    },
+    "evals/privacy-audit.json": {
+      "bytes": 936,
+      "sha256": "84f1b751889f2539310bef2243fa2e2e4c570346f48117b2a583996050c97bef"
+    },
+    "evals/release-checks.json": {
+      "bytes": 1585,
+      "sha256": "3050d399c02f711955f6ce6a948980cccf562342f2bf1c740691f97b4c06925e"
+    },
+    "evals/tokenizer-provenance.json": {
+      "bytes": 507,
+      "sha256": "bb1ce268b91023c6c94bd0891b62566ed2041040c594ca2af0669cdea646417b"
+    },
+    "evals/training-results.json": {
+      "bytes": 3827,
+      "sha256": "eea199c88ff1d89be00798ebadedb17bc9cd4ee782cfaa7623aa4bf999780c67"
+    },
+    "evals/weight-audit.json": {
+      "bytes": 1469,
+      "sha256": "cf5d57709e7cdca7cf521c27f7a7c5655f2553fb5fcfdcfc40091478f13ba2ec"
+    },
+    "examples/browser-task.json": {
+      "bytes": 611,
+      "sha256": "4ed080a17f19d6c672fab427c931194c346649ef2aefcd5a58a2700896b0ee12"
+    },
+    "examples/choice-request.json": {
+      "bytes": 1146,
+      "sha256": "781bcc6fb1b269cd1026eb9707120005513be4b1b416fbf26bbfb07f06ca7e5a"
+    },
+    "licenses/NanoJev-MIT.txt": {
+      "bytes": 1077,
+      "sha256": "c69c1bb0b33112f68f9e8ef7e91dd38ec59066fcba3f62f70cbc8c9c83cf6a8e"
+    },
+    "licenses/Qwen-Apache-2.0.txt": {
+      "bytes": 11343,
+      "sha256": "832dd9e00a68dd83b3c3fb9f5588dad7dcf337a0db50f7d9483f310cd292e92e"
+    },
+    "model/backbone_config/config.json": {
+      "bytes": 1417,
+      "sha256": "30c011854471509747858ac07ffb8a4dab2bc6c04035b184729b69500c557c54"
+    },
+    "model/best.safetensors": {
+      "bytes": 2385039280,
+      "sha256": "0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5"
+    },
+    "model/config.json": {
+      "bytes": 293,
+      "sha256": "e7ea2cf40026a03c9318f25639b20638307118d673310678b5e0fd47f651874c"
+    },
+    "model/tokenizer/chat_template.jinja": {
+      "bytes": 4168,
+      "sha256": "a55ee1b1660128b7098723e0abcd92caa0788061051c62d51cbe87d9cf1974d8"
+    },
+    "model/tokenizer/tokenizer.json": {
+      "bytes": 11422650,
+      "sha256": "be75606093db2094d7cd20f3c2f385c212750648bd6ea4fb2bf507a6a4c55506"
+    },
+    "model/tokenizer/tokenizer_config.json": {
+      "bytes": 692,
+      "sha256": "1cc816812993bff176eb4f7495433b736f06fba9b6e7b05cac7b4a1780650c95"
+    },
+    "package-lock.json": {
+      "bytes": 797,
+      "sha256": "22f2f67a372aff46ed8f794ea5b55f8b80ba74fc13811b128545124cdd0c8c03"
+    },
+    "package.json": {
+      "bytes": 266,
+      "sha256": "b38d2461b7b71a70c248539e8b77213010ed4b10ec0720d2f4ff81f6763a1740"
+    },
+    "python/model.py": {
+      "bytes": 3265,
+      "sha256": "03c1344e68c827173c476c2fbafcc3c4b4c3b8a4d7b493fc274d02368a417f95"
+    },
+    "python/predictor.py": {
+      "bytes": 10827,
+      "sha256": "dbb4747ce4f6fbd90a0665f5ab611998713de781b275a311eadca17d7902a729"
+    },
+    "python/schema.py": {
+      "bytes": 2208,
+      "sha256": "402271d475ab2fd57d021fa9020fad1df75258f5415009557dc5b9db2e87050f"
+    },
+    "python/server.py": {
+      "bytes": 3383,
+      "sha256": "606094003088d2dd4f5fde443c2ab7632f7299c4d321857f186d0f696a1514b6"
+    },
+    "requirements-lock.txt": {
+      "bytes": 556,
+      "sha256": "da94964239d2de8c4ba55c9f2b1ef8fbbad20b0ffb41e02a9323168a3ee81f3d"
+    },
+    "run.command": {
+      "bytes": 136,
+      "sha256": "681f4a4fb3d7f4cb80b7e654b5e2e7d241120b9e6a04c4537d2c2b54bcccbfc8"
+    },
+    "runtime/agent.mjs": {
+      "bytes": 514,
+      "sha256": "645b85a90b14c7ff3ae4f36024de22ce3556103c5bb85dcd041ba90fa23d1413"
+    },
+    "runtime/browser.mjs": {
+      "bytes": 19718,
+      "sha256": "1f5fab039f68bf21206667504868a104ba542f8e113d05b2167847f6ea913ad2"
+    },
+    "scripts/check-install.py": {
+      "bytes": 1040,
+      "sha256": "8966908dd906398e5accac138eca144653ab1bdf331a529c0e81b7b159dc7811"
+    },
+    "scripts/common.sh": {
+      "bytes": 847,
+      "sha256": "e2f7a6d5ee6917a504b736b9e541c74f70b6eb0b7ebfcb3e88b70c21cc86675f"
+    },
+    "scripts/publish.py": {
+      "bytes": 1551,
+      "sha256": "4418cfa35475bb340f7604740c511b12e780c8898555cd7fdff70222d8f50842"
+    },
+    "scripts/release.py": {
+      "bytes": 2433,
+      "sha256": "6f04c7bbfb7e6e7afd6c4579ad9818a7104c8be8c6153bad8f828beba7237ba2"
+    },
+    "setup.command": {
+      "bytes": 1486,
+      "sha256": "31aa4b86c19cd7e6c80e03a98bd5b86972f83176d4e30583795df6f06a12cd3b"
+    },
+    "start.command": {
+      "bytes": 282,
+      "sha256": "45fe2204cbe6802bd08e559534fc6f55de4f118dded67bd46f6b50b0b68b8277"
+    },
+    "test.command": {
+      "bytes": 193,
+      "sha256": "db5abb97615127815d66b836af788c5810856cd016fb55960b49d450a61aefa0"
+    },
+    "tests/parity.py": {
+      "bytes": 1633,
+      "sha256": "5519e4474dbff60143e3982901292c0f2b6e88f203302ee089dd08a534550f27"
+    },
+    "tests/reference-decisions.json": {
+      "bytes": 46779,
+      "sha256": "37927cdc85bbcc7c08953ec9332775d2fddb705051b95b4d7db998b053c6441a"
+    },
+    "tests/test_contract.py": {
+      "bytes": 1628,
+      "sha256": "735743357e096ea6a7eac7522e309b71ec7da429fbb27a9aea57a83eec92d753"
+    },
+    "training-data/calibration.jsonl": {
+      "bytes": 1073763,
+      "sha256": "3245ee66ccacbc1372bc1ca8d6b9e41829b64cd8a6a1d163eefda2b6f6044d9c"
+    },
+    "training-data/dev.jsonl": {
+      "bytes": 1065438,
+      "sha256": "4f86da59b82d8c08487ec5144efc7fa84b502558387922e205cb9c5f8e89d79e"
+    },
+    "training-data/test.jsonl": {
+      "bytes": 1231173,
+      "sha256": "3097ca379e1d1c4087ae8614f4a181e1ef4761566e672283cdd5889e98d620c1"
+    },
+    "training-data/train.jsonl": {
+      "bytes": 6431793,
+      "sha256": "1f596b1dff78510693a33432d874df11b53c46a85fcd0d2488b0ca73ff8ef297"
+    }
+  }
+}

PROVENANCE.json

@@ -0,0 +1,25 @@
+{
+  "name": "NanoJev-Web",
+  "version": "1.0.0",
+  "weights_variant": "browser-head-v5",
+  "checkpoint_sha256": "0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5",
+  "upstream": {
+    "model": "C-Tianyu/NanoJev",
+    "revision": "unified-games-v1",
+    "checkpoint_sha256": "f68c47d66998231b86b7e91b4ed5e82ae23acf104c8b7cd6d165c3ac7b7ffe1b",
+    "source": "https://github.com/TianyuCodings/NanoJev",
+    "source_commit": "618cea6d906d54e128360786d12f703fff2b1245"
+  },
+  "backbone": {
+    "model": "Qwen/Qwen3-0.6B",
+    "revision": "c1899de289a04d12100db370d81485cdf75e47ca",
+    "frozen_parameters": 596049920
+  },
+  "head": {
+    "trained_parameters": 200578,
+    "set_head": "attention"
+  },
+  "storage": "FP32 safetensors",
+  "full_parameters": 596250498,
+  "release_changes": "Browser head v5 weights unchanged; model-focused distribution with local choice inference, browser executor and integration documentation. Comparison application and cloud-provider integrations excluded."
+}

README.md

@@ -0,0 +1,126 @@
+---
+language:
+- en
+license: other
+license_name: mit-and-apache-2.0
+license_link: LICENSE
+library_name: pytorch
+base_model: C-Tianyu/NanoJev
+base_model_relation: finetune
+tags:
+- browser-automation
+- agent-browser
+- action-selection
+- local-inference
+- apple-silicon
+- safetensors
+- nanojev
+- jev
+---
+
+# NanoJev-Web
+
+**Open-weight browser hands for a larger planning agent.** NanoJev-Web is a lightweight browser-action model derived from NanoJev. It runs locally and selects the next action from a host-provided set of permitted browser operations. The included **agent-browser** runtime executes the selected action and checks the resulting page state.
+
+Use it as an execution component for form filling and bounded web workflows. A larger model or your application supplies the goal, selectors, values and success conditions; NanoJev-Web handles action selection within that contract. The weights, inference code and browser runtime are available for local integration. No hosted model service or API key is required.
+
+## How it fits into an agent
+
+```text
+Planning agent / application
+    supplies the task, allowed controls, values and success conditions
+        ↓
+Host observer → abstract page state + available action candidates
+        ↓
+NanoJev-Web → selected action ID + candidate probabilities
+        ↓
+Browser executor → performs the action → observes the new page state
+        ↺
+Host verifies the outcome or handles a blocked workflow
+```
+
+The model scores supplied alternatives without generating text. Selectors and literal form values stay with the supplied executor; it sends abstract action descriptions and page-state flags to the model. Planning, page understanding and independent outcome verification belong to the host. [Integration guide and API](docs/INTEGRATION.md).
+
+## Inheritance and browser specialization
+
+NanoJev-Web inherits its decision architecture and tokenizer from [C-Tianyu/NanoJev](https://huggingface.co/C-Tianyu/NanoJev), using the **Qwen3-0.6B** backbone. All **596,049,920 backbone parameters remain frozen**. The **200,578-parameter decision head** was further trained on synthetic browser action states.
+
+The released weights are the verified `browser-head-v5` checkpoint. Packaging it as NanoJev-Web did not introduce another training run. Game interfaces, game datasets, game training commands and teacher-service integrations are excluded. Removing those components does not erase knowledge from the inherited weights. [Training details](docs/TRAINING.md) · [Provenance](PROVENANCE.json).
+
+| Property | Value |
+|---|---|
+| Total parameters | 596,250,498 |
+| Output | One supplied action ID and probabilities over the alternatives |
+| Storage | Full FP32 safetensors checkpoint; no quantization or adapter |
+| Checkpoint size | 2,385,039,280 bytes |
+| Candidate context limit | 768 tokens per separately encoded candidate path; overflows rejected |
+| Local inference | PyTorch MPS on Apple Silicon; explicit CPU option |
+| Tested hardware | MacBook Pro, Apple M2 Pro, 16 GB unified memory |
+
+## Available browser actions
+
+The supplied executor supports:
+
+- **Inputs:** `fill`, `type`, `clear`, `select`, `multiselect`, `check`, `uncheck`, `radio`, `upload`.
+- **Interactions:** `click`, `hover`, `dblclick`, `drag`, `focus`, `press`.
+- **Structured controls and navigation:** `open`, `option`, `add`, `remove`, `link`, `tab`.
+- **Visibility:** observer-generated `scroll` to reveal an allowed target.
+- **Control decisions:** `DONE`, `WAIT`, `BLOCKED`.
+
+These are executor capabilities exposed as permitted choices. The model does not invent commands. Same-origin frame targeting is available through a control's `frame` property. See the [complete action reference](docs/ACTIONS.md) for required data, semantics and boundaries.
+
+## Run locally
+
+The supplied installer targets **native Apple Silicon, macOS 14+, Node.js 24+ with npm, and uv**. It installs pinned Python 3.12.13 dependencies and agent-browser 0.37.1. Installation downloads dependencies; model inference then uses local files. Other Apple Silicon generations have not all been benchmarked.
+
+**Tested on MacBook Pro with Apple M2 Pro and 16 GB unified memory.** Successful operation was reported in a separate functional test. [Hardware specifications and test scope](docs/INTEGRATION.md#apple-m2-pro-compatibility).
+
+```bash
+cd NanoJev-Web
+chmod +x *.command
+./setup.command
+./start.command
+```
+
+The model listens on **127.0.0.1:8774**. In another terminal:
+
+```bash
+curl http://127.0.0.1:8774/api/health
+curl -H 'Content-Type: application/json' \
+  --data-binary @examples/choice-request.json \
+  http://127.0.0.1:8774/api/evaluate
+```
+
+For browser execution, adapt [examples/browser-task.json](examples/browser-task.json) to your own page, selectors and desired values, then run:
+
+```bash
+./run.command --task your-task.json
+```
+
+The runner creates an isolated agent-browser session and stores its local trace and final screenshot in `.local/runs/`. The example describes a page contract; it does not start or include a demo website. For a Python-only model setup or your own executor, see [integration](docs/INTEGRATION.md).
+
+This is a custom decision checkpoint. Load it with the supplied inference code; the repository root is not a standard `AutoModelForCausalLM` chat checkpoint or a configured Hugging Face Inference widget.
+
+## Evaluation and limits
+
+On held-out synthetic decision states, the browser head selected an acceptable action in **228/228** cases. Development scored **191/192** and calibration **189/192**. These splits share the training schema; they measure action selection within that schema, not success on arbitrary websites. Probabilities have not been certified as calibrated confidence. [Data and methodology](docs/TRAINING.md).
+
+The current model and runtime target bounded workflows with supplied controls. They do not independently discover a site's workflow, invent form values, interpret arbitrary screenshots, manage credentials or make business decisions. The host must define success and verify any required saved data; a `DONE` choice alone does not establish business correctness. Changing the observation/action schema can change model behavior and requires evaluation.
+
+## Browser demonstration
+
+The following recording illustrates the model in use. In one 15-field form attempt, NanoJev-Web completed and saved all assigned values in **19.85 seconds**, using **20 browser actions and 21 decisions** on Apple M3 Max / 36 GB. Jev and GPT-6 Astra High ran alongside it through the same browser executor for context.
+
+![Final recorded browser demonstration: Jev stopped, NanoJev-Web and GPT-6 Astra passed](docs/assets/browser-demo.png)
+
+![Browser demonstration with NanoJev-Web, Jev and GPT-6 Astra High](docs/assets/seed-43129.gif)
+
+*Recording excerpt, seed 43129 (26.51 seconds of GIF playback). The clip ends with Astra showing “Booking saved” while its final decision is still pending. Final verified outcomes and elapsed times come from the saved run logs and result screenshot; GIF playback duration is not execution time.*
+
+This is one observed demonstration with supplied selectors and values, not a general browser reliability claim. The [detailed recording report](docs/SINGLE_FORM_REPORT.md) retains the comparison, timing, token accounting and verification evidence. The comparison application and its cloud-provider integrations are separate from this model distribution; only static documentation assets are included.
+
+## Release contents and privacy
+
+The distribution contains the checkpoint, tokenizer, inference API, agent-browser executor, integration examples, synthetic browser-head data, model checks, documentation and license notices. The model's inherited **MIT and Apache-2.0** terms are described in [LICENSE](LICENSE).
+
+Private machine paths, credentials, browser profiles and raw local run files are excluded. The safetensors header has no author metadata, and head training used abstract synthetic states. This audit does not establish that inherited pretrained weights contain no personal information. [Privacy audit](docs/PRIVACY.md) · [Publishing instructions](docs/PUBLISHING.md).

docs/ACTIONS.md

@@ -0,0 +1,55 @@
+# Browser action reference
+
+The host supplies an explicit task contract: URL, allowed origins, selectors, labels, desired values, optional preconditions and success conditions. NanoJev-Web chooses an action ID. The executor re-observes the page before executing it and rejects stale observations, ambiguous targets and disallowed navigation.
+
+| Action | Executor behavior | Host-supplied data / boundary |
+|---|---|---|
+| `fill` | Replace an input or textarea value | `selector`, `value`; text, email, telephone, URL, number, date, time and datetime-local. Native temporal segments use keyboard input. |
+| `type` | Focus, move to the end and type text | `value`; provide `finalValue` when appending to existing content. |
+| `clear` | Empty the target input | Explicitly permitted target. |
+| `select` | Select one native option | Option value. |
+| `multiselect` | Select several native options | Array of option values. |
+| `check` / `uncheck` | Set a checkbox state | Explicit desired boolean state. |
+| `radio` | Click the assigned radio option | Correct option is supplied by the host. |
+| `click` | Click an allowed element | Explicit purpose and expected postcondition when needed; supports switches through `aria-checked`. |
+| `open` | Click a reveal control | Opens a supplied dropdown/dialog trigger; it does not invent a URL. |
+| `option` | Click a custom dropdown option | Supplied option selector and postcondition. |
+| `hover` | Hover over an element | Expected revealed state should be supplied. |
+| `dblclick` | Double-click an element | Explicit target and postcondition. |
+| `drag` | Drag a source to a destination | Source `selector`, `destination` selector and expected result. |
+| `focus` | Focus an allowed control | Use a `focused` success condition. |
+| `press` | Send a permitted keyboard key/chord | `key`; host controls focus. macOS Escape uses agent-browser's documented keyboard stream. |
+| `add` / `remove` | Click an allowed add/remove control | Suitable for repeatable form rows with an explicit expected count/state. These are click aliases, not DOM modifications. |
+| `link` | Click a link | Actual destination must remain in the task's `allowedOrigins`. |
+| `tab` | Open an authorized URL or return to an owned parent tab | `mode: "open"` plus `url`, or `mode: "return"`; arbitrary tab discovery is not supported. |
+| `upload` | Supply an explicitly authorized local file to a file input | `value`: one path or an array. The host is responsible for authorizing these files. |
+| `scroll` | Scroll an offscreen target into view | Generated by the observer from an allowed control; it is not a task control operation. |
+| `WAIT` | Wait for the page's visible busy state to clear | No browser action is invented. |
+| `DONE` | Finish when the host's visible success condition is met | The host must separately verify saved data and business rules where required. |
+| `BLOCKED` | Stop for host assistance | No forced click, bypass or automatic substitute model. |
+
+**Frames:** a control may specify a `frame` selector for a same-origin iframe. The executor enters it for the action and returns to the main frame. `frame` is context on a control, not a standalone action. Cross-origin frames are outside this release's observation contract.
+
+**Observations:** snapshots, read-only DOM inspection, screenshots and audit reads belong to the host. They are not extra model actions. Candidate descriptions contain operation, purpose, current value-match state, assignment state, viewport visibility, enabled state and blocking state. Supplied values and selectors remain local.
+
+**Conditions:** `visible`, `absent`, `count`, `text`, `includes`, `attribute`, `property`, `value`, `focused`, `any` and `all` express expected states. Satisfied assigned controls and non-executable offscreen actions are removed from the choice set; the corresponding scroll action can remain. Optional distractors remain available so incorrect selection can be measured.
+
+**Unsupported work:** arbitrary JavaScript or shell execution, canvas/game control, CAPTCHA bypass, downloads, general file chooser exploration, cross-origin frame reading, autonomous workflow discovery and secret entry. Password fields stop the generic runner; PINs, OTPs and other secrets must stay with a dedicated host helper. Control allowlists do not grant permission for consequential real-world actions.
+
+## Minimal task
+
+```json
+{
+  "name": "contact-test",
+  "url": "http://127.0.0.1:9000/contact",
+  "allowedOrigins": ["http://127.0.0.1:9000"],
+  "controls": [
+    {"id":"name","op":"fill","selector":"#name","label":"Name","value":"Test Contact"},
+    {"id":"agree","op":"check","selector":"#agree","label":"Use test data"},
+    {"id":"save","op":"click","purpose":"submit","selector":"#save","label":"Save"}
+  ],
+  "success":{"selector":"#status","kind":"text","value":"Saved"}
+}
+```
+
+Replace the example URL and selectors with your own authorized page. `run.command` records evidence in `.local/runs/`. Define persistence and business checks in your host application. See the [integration guide](INTEGRATION.md) and [task template](../examples/browser-task.json).

docs/INTEGRATION.md

@@ -0,0 +1,99 @@
+# Integrating NanoJev-Web
+
+NanoJev-Web chooses among supplied actions. Your application or planning model owns the workflow, page interpretation, selectors, assigned values and verification. You can use the bundled browser runner or call the local inference API from your own executor.
+
+## Use the browser runner
+
+After `setup.command`, start the local model with `start.command`. Copy [browser-task.json](../examples/browser-task.json) and replace the example URL, origins, selectors and values with those for your own authorized page. Then run:
+
+```bash
+./run.command --task your-task.json
+```
+
+The task contract has these fields:
+
+| Field | Responsibility |
+|---|---|
+| `name` | A simple run name, used for local report filenames |
+| `url` | Initial page to open |
+| `allowedOrigins` | Origins authorized for this task |
+| `controls` | Explicit targets, operations, desired values and optional conditions |
+| `success` | A condition describing the expected final page state |
+
+Each control has a unique `id`, an `op`, a `selector` and a `label`. Input actions also carry the required value or desired state. `when` makes a control conditional; `expect` can describe its postcondition. The [action reference](ACTIONS.md) lists supported operations and conditions.
+
+The observer reads the page through agent-browser, removes satisfied or non-executable candidates and offers scrolling for allowed offscreen targets. The model receives abstract state and action descriptions. The executor rechecks the observation before acting, handles permitted input mechanics, and stops on completion, blocking, action cycles or execution limits. These checks are part of the host runtime, not learned model behavior.
+
+The runner uses the local endpoint by default. An explicit alternative local port can be selected with `--endpoint http://127.0.0.1:PORT`. A JSON trace and final screenshot are written under `.local/runs/`. They may contain the task's values and must remain private for private tasks. The runner checks visible success; your application must separately verify persistence and business rules where needed.
+
+## Call the model directly
+
+`GET /api/health` reports readiness, device, precision and checkpoint identity. `POST /api/evaluate` accepts a JSON object containing `states`. Each state has a unique `id`, a `state` description and named `questions`.
+
+Every question must contain:
+
+- `type`: exactly `choice`.
+- `instructions`: a nonempty string explaining the decision.
+- `criteria`: a mapping from candidate IDs to nonempty action descriptions.
+
+Use [choice-request.json](../examples/choice-request.json) as a concrete request:
+
+```bash
+curl -H 'Content-Type: application/json' \
+  --data-binary @examples/choice-request.json \
+  http://127.0.0.1:8774/api/evaluate
+```
+
+Read the selected ID at `states[0].answers.next.choice` and the distribution at `states[0].answers.next.probabilities`. Candidate IDs are local to each request. The response also contains checkpoint identity and execution accounting. `execution.input_tokens` sums separately encoded candidate paths, including repeated context; `execution.output_tokens` is zero because there is no autoregressive decoding.
+
+The default limit is **768 tokens per complete candidate path**, including state, instructions, candidate text and formatting. Oversized paths are rejected instead of truncated. A request supports 1–32 states, 2–255 alternatives per question, at most 96 questions and at most 256 total candidate paths. The HTTP server rejects request bodies over 2,000,000 bytes. The choice schema is broader than the browser training distribution: supplying arbitrary text does not establish reliable general-purpose reasoning.
+
+For an existing agent framework, map its observed page state and permitted actions into the browser schema, call the model, execute the returned choice, then observe again. Preserve the semantics of busy/success state, unfinished fields/interactions, visibility, assignment and blocking flags. [runtime/browser.mjs](../runtime/browser.mjs) contains the reference state formatter and action descriptions. Keeping literal values and selectors in the host is a feature of this runtime; the low-level API does not itself remove private text supplied by a caller.
+
+## Apple M2 Pro compatibility
+
+**Tested on MacBook Pro with Apple M2 Pro and 16 GB unified memory.** A contributor confirmed successful local operation of NanoJev-Web on this configuration. This is a reported functional check; no detailed trace or timing measurements were supplied. The CPU/GPU core counts and macOS version were not recorded.
+
+Apple lists the following M2 Pro configurations for the 2023 MacBook Pro. These describe the hardware family, not the exact configuration of the reported test machine. [Apple technical specifications](https://support.apple.com/en-us/111340).
+
+| Component | M2 Pro specification |
+|---|---|
+| CPU / GPU | 10-core CPU with 16-core GPU, or 12-core CPU with 19-core GPU |
+| Unified memory | 16 GB or 32 GB |
+| Memory bandwidth | 200 GB/s |
+| OS requirement for this package | macOS 14+ |
+
+The supplied runtime uses the GPU through PyTorch MPS. Apple Silicon and macOS 14+ meet the documented platform requirements. The functional check covers the reported machine; it does not establish performance on every configuration. [Apple's PyTorch/MPS guidance](https://developer.apple.com/metal/pytorch/) · [PyTorch MPS documentation](https://docs.pytorch.org/docs/main/notes/mps.html).
+
+The full FP32 checkpoint occupies about 2.39 GB on disk, while inference also needs activations, temporary buffers, framework memory and browser processes. Candidate count and path length affect memory consumption. A 32 GB configuration provides more headroom than 16 GB, but no M2 Pro peak-memory measurement is available from this functional check. Running a larger planning model on the same Mac adds its own requirements.
+
+The recorded demonstration was measured on M3 Max / 36 GB; its completion times remain attributed to that machine. The M2 Pro functional result is recorded separately in [release-checks.json](../evals/release-checks.json). After installation, use the package checks and a representative page contract to verify your environment. The installer checks `torch.backends.mps.is_available()` before declaring setup complete.
+
+## Python-only inference setup
+
+If your application already supplies browser execution, the model server does not require Node.js or agent-browser. On native Apple Silicon with macOS 14+ and `uv`, from the release root:
+
+```bash
+export UV_PYTHON_INSTALL_DIR="$PWD/.runtime/python"
+export UV_CACHE_DIR="$PWD/.runtime/cache"
+uv python install 3.12.13 --no-bin
+uv venv --managed-python --python 3.12.13 .venv
+uv pip sync --python .venv/bin/python requirements-lock.txt
+./start.command
+```
+
+The server loads the included checkpoint once and binds to loopback. To use CPU explicitly, run `./start.command --device cpu`; CPU latency has not been benchmarked. No external model calls or teacher fallback are used. Installation needs network access for dependencies; inference uses local model files.
+
+## Verify the model package
+
+```bash
+./test.command
+```
+
+This runs the six request-contract tests and verifies the public file manifest. With the model server running, the frozen v5 reference decisions can also be checked:
+
+```bash
+.venv/bin/python tests/parity.py
+```
+
+Parity compares action choices and probabilities with saved reference outputs at a tolerance of `1e-4`. These are model checks; they do not contact comparison models or run a comparison website.

docs/PRIVACY.md

@@ -0,0 +1,30 @@
+# Release privacy audit
+
+The public distribution is a neutral model/tool release. It contains no personal project branding or identifying maintainer metadata. Attribution to NanoJev and Qwen remains because it describes the model's actual origin and preserves their license notices.
+
+## Checked material
+
+- All public source, configuration, documentation, examples and evaluation summaries were scanned for machine-specific home paths, private account identifiers, access-token patterns and private-key blocks.
+- All **1,863 browser head training rows** were inspected as structured data and scanned for contact details, URLs, local paths and private identifiers. The rows describe abstract operations, visibility, assignment, busy states and acceptable actions. They do not contain user form values or conversation transcripts.
+- The safetensors header contains **322 tensors** and **no `__metadata__` author field or other author metadata**.
+- The released checkpoint retains the verified v5 weight hash. The recorded tensor audit establishes that the Qwen backbone was frozen during browser head training.
+- The tokenizer vocabulary, merge rules and added-token inventory exactly match the pinned upstream Qwen tokenizer. Saved pre-tokenizer/decoder settings differ; the verified v5 tokenizer is retained as-is. [Comparison record](../evals/tokenizer-provenance.json). No private tokens were added.
+- The inference response identifies `NanoJev-Web/browser-head-v5` instead of returning an absolute checkpoint directory.
+- Published benchmark evidence contains selected numeric results, model identities, reproducibility information, synthetic assigned values and allowlisted abstract decision traces. Private raw run files, machine paths and browser sessions are excluded.
+- Archive entries use blank owner/group names, numeric ownership zero and normalized timestamps. Publication uses an explicit manifest, not the contents of an installed runtime directory.
+
+The explicitly supplied synthetic benchmark screenshot and GIF are included as public report assets. The image metadata contains resolution, dimensions, a color profile and a generic Screenshot comment; the GIF contains animation timing and loop metadata. No identifying author/location metadata was found. Both files are preserved byte-for-byte. See [media provenance](demo/media-provenance.json).
+
+The machine-specific audit denylist itself is not published, because that would reintroduce the identifiers being removed. Findings are recorded as counts in [privacy-audit.json](../evals/privacy-audit.json).
+
+## Excluded from the upload
+
+Credentials, environment files, local connection configuration, browser profiles, unreviewed recordings, private run receipts, screenshots from arbitrary sites, old workspaces, development archives, dependency installations and caches are not release files. Running the package later creates `.local/` evidence; that directory stays outside the manifest.
+
+The model and browser runtime require no hosted-model credentials. The comparison application and cloud-provider integrations are excluded from this distribution. The local model has no teacher or external model fallback. Package installation still needs network access to obtain dependencies.
+
+## Limits of the audit
+
+This is a release-file and browser-head-data audit, not proof that pretrained neural weights cannot encode personal information. The inherited backbone and multilingual tokenizer have not been retrained or semantically scrubbed. Ordinary names or words in a tokenizer vocabulary are upstream model assets, not evidence of a local user's training records; deleting them would change tokenization and invalidate the checkpoint.
+
+The model's API is deliberately narrow, but the caller can still supply text. Hosts remain responsible for using appropriate data and authorized pages. Downloaders should use the verified release manifest rather than sharing their own working directory after running private tests.

docs/PUBLISHING.md

@@ -0,0 +1,51 @@
+# Publish the prepared release on Hugging Face
+
+The repository root is already a model repository layout: an English `README.md` model card, license notices, local weights/tokenizer/configuration, source, tests and evidence. No hosted Inference API integration or Hugging Face Space is configured. This distribution contains the model and browser runtime. It does not contain a comparison application or cloud-provider integrations.
+
+## Review and dry run
+
+After setup:
+
+```bash
+./test.command
+.venv/bin/python scripts/publish.py --repo-id YOUR_NAMESPACE/NanoJev-Web
+```
+
+The default is a **dry run**: it verifies hashes and prints the exact upload file count. It makes no network writes and does not need a token. Replace `YOUR_NAMESPACE` with the intended account or organization; no personal namespace is embedded in the release.
+
+## Explicit publication
+
+Authenticate through the Hugging Face CLI or provide `HF_TOKEN` through your environment. Keep credentials outside this folder. Then:
+
+```bash
+.venv/bin/python scripts/publish.py \
+  --repo-id YOUR_NAMESPACE/NanoJev-Web --publish
+```
+
+This explicitly creates a **public** model repository and uploads only verified manifest files. If the repository already exists, the command fails unless you add `--update-existing`. That flag adds/replaces the listed files and does not delete unrelated remote files. Choose a new clean repository for a first release.
+
+The helper uses `HfApi` with an exact file allowlist. It does not upload `.local`, `.venv`, `.runtime`, `node_modules`, `.env`, browser evidence, development history, shell configuration or hidden parent directories. Do not use an unrestricted recursive upload on an installed workspace.
+
+## Portable archive
+
+```bash
+.venv/bin/python scripts/release.py --export ../NanoJev-Web-1.0.0.tar.gz
+```
+
+The archive contains the same manifest files plus the manifest. Tar ownership IDs and names are normalized, as are timestamps, so machine usernames and local filesystem metadata are not copied into the archive. Dependencies and browsers are installed on the destination machine with `setup.command`.
+
+The checkpoint's SHA-256 is recorded in `PROVENANCE.json`. `.gitattributes` marks safetensors for large-file handling. Hugging Face handles large-file transfer through its upload API.
+
+## Model-card scope
+
+The card identifies the NanoJev parent, the Qwen backbone, browser head training, mixed upstream license terms and the specialized decision interface. It does not label this custom checkpoint as a generic text-generation pipeline or claim universal browser benchmark performance.
+
+References: [Hugging Face model cards](https://huggingface.co/docs/hub/model-cards), [Hugging Face upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload).
+
+## Static demonstration assets
+
+The demonstration image is `docs/assets/browser-demo.png`, showing the final verified results. The recording is `docs/assets/seed-43129.gif`, embedded in the model card and [detailed report](SINGLE_FORM_REPORT.md). Both supplied files are preserved byte-for-byte and included as documentation assets in the release manifest and archive. They are shown in the demonstration section after the model description, integration and limitations. The executable comparison stand is not distributed.
+
+The GIF contains 26.51 seconds of playback and ends before Astra's final Passed badge. The caption distinguishes this recording excerpt from the complete run metrics, which come from the saved benchmark logs.
+
+If you later replace a media file or edit the Markdown locally, update the corresponding manifest entries before using the verified uploader and regenerate the archive. A direct edit on the Hub does not change the local archive.

docs/SINGLE_FORM_REPORT.md

@@ -0,0 +1,189 @@
+# Recorded browser demonstration: Jev, NanoJev-Web and GPT-6 Astra High
+
+This is supporting documentation for NanoJev-Web. The comparison application used to record it is separate from the model distribution and is not included here. Local model inference and browser execution do not require a comparison provider.
+
+**Observed result:** NanoJev-Web and Astra completed and saved all 15 assigned values. Jev filled four values, then alternated between two scroll targets until the harness stopped the repeated state/action cycle.
+
+This is the manually started English **Workshop booking** test on **2026-09-21**, seed **43129**, attempt `20260921T120532066-91fc95`. It is one attempt per model, not an average or a multi-seed reliability claim. No model was rerun to replace its result.
+
+## Recording
+
+![Live recording of Jev, NanoJev-Web and GPT-6 Astra High on the seed-43129 form](assets/seed-43129.gif)
+
+*Recording excerpt, seed 43129 (26.51 seconds of GIF playback). The clip ends with Astra showing “Booking saved” while its final decision is still pending. Final verified outcomes and elapsed times come from the saved run logs and the result screenshot; GIF playback duration is not benchmark execution time.*
+
+**Final verified result:**
+
+![Final state: Jev stopped, NanoJev-Web passed, and GPT-6 Astra passed](assets/browser-demo.png)
+
+## Test conditions
+
+| Item | Recorded condition |
+|---|---|
+| Hardware | Apple M3 Max, 36 GB unified memory |
+| Operating system | macOS 26.5.2 |
+| Browser execution | agent-browser 0.37.1, three isolated sessions |
+| Viewport | 1000 × 820 pixels per session |
+| Execution order | Three models run concurrently on separate copies of the same form |
+| Local inference | NanoJev-Web browser-head-v5, PyTorch MPS, FP32 |
+| Jev identity | `typesafe/jev-1.13-20260917` |
+| Astra identity | `openai/gpt-6-astra`, high reasoning |
+| Display pauses | 0 ms; no artificial action delay in this attempt |
+| Start | Manual Run click, followed by a six-second countdown |
+| Limits | 100 decisions; 300 seconds checked between steps; 60-second model-request timeout |
+| Repair policy | No scripted repair, teacher fallback, substitute model or automatic retry |
+
+All three models started with **identical decision inputs**, verified by hashes. Each model received a stateless abstract page state and the same action-description format. Candidate sets then evolved independently as their actions changed their own sessions.
+
+The host supplied selectors, assigned form values and success conditions. These remained in the executor; models did not receive the full DOM, screenshots, field labels, URLs or literal values. The field names used in this report identify the host-side targets. The decision inputs described actions using operation, purpose, current match state, assignment, viewport, enabled and blocked flags. No previous-action history was included.
+
+This evaluates the model-plus-executor system's ability to choose and perform bounded actions. It does not measure autonomous website discovery or the ability to infer form values from an open-ended request.
+
+## Results
+
+| Model | Outcome | Elapsed | Valid fields | Exact assigned values | Decisions / executed actions | Input / output tokens | API cost (USD) |
+|---|---|---:|---:|---:|---:|---:|---:|
+| Jev | `action_cycle`; not saved | 8.7733 s | 6/15 (40.0%) | 4/15 (26.7%) | 11 / 10 | 13,307 / 1,916 | $0.000558894 |
+| NanoJev-Web | `completed`; saved | 19.8501 s | 15/15 (100%) | 15/15 (100%) | 21 / 20 | 52,743 / 0 | $0 local API |
+| GPT-6 Astra High | `completed`; saved | 79.1565 s | 15/15 (100%) | 15/15 (100%) | 20 / 19 | 14,661 / 812 | $0.187210000 |
+
+All scored model requests have recorded usage; there are no unknown-usage requests in this attempt. Combined reported hosted API cost was **$0.187768894**. This excludes the coordinating assistant, preparation, hardware, electricity and earlier runs. NanoJev-Web encodes candidate paths separately, so its token count includes repeated context and is not directly comparable to provider billing. Astra's 812 output tokens include **505 reported reasoning tokens**; these are not additional tokens to add to that total.
+
+Elapsed time measures the action loop, including observation, model requests, execution and status updates. Navigation/setup, countdown and final audit/screenshots are excluded. With zero display pauses, elapsed and “without pauses” are equal. Failed-run duration is time until stopping, not time to successful completion.
+
+| Component | Jev | NanoJev-Web | Astra High |
+|---|---:|---:|---:|
+| Model HTTP request wall time | 5.1236 s | 13.0616 s | 71.8182 s |
+| Browser command wall time in the loop | 3.6104 s | 6.7261 s | 7.2716 s |
+| Other loop overhead | 0.0393 s | 0.0624 s | 0.0668 s |
+| Browser calls in the loop | 85 | 170 | 163 |
+
+HTTP time includes service/network overhead and is not a pure neural inference measurement. All sessions and live streaming shared the same machine; this was not an isolated hardware latency benchmark.
+
+## The exact Jev cycle
+
+Jev first filled **Notes → Contact name → Project website → Time** correctly. From decision 5 onward, it repeatedly chose scrolling over available input actions:
+
+| Decision | Selected action | Target location before action | Selected probability | Execution |
+|---:|---|---|---:|---|
+| 5 | `scroll` to **Status notifications** (`#notifications`) | below | 0.38 | Executed |
+| 6 | `scroll` to **I confirm these are test data** (`#consent`) | above | 0.25 | Executed |
+| 7 | `scroll` to **Status notifications** (`#notifications`) | below | 0.29 | Executed |
+| 8 | `scroll` to **I confirm these are test data** (`#consent`) | above | 0.24 | Executed |
+| 9 | `scroll` to **Status notifications** (`#notifications`) | below | 0.39 | Executed |
+| 10 | `scroll` to **I confirm these are test data** (`#consent`) | above | 0.28 | Executed |
+| 11 | `scroll` to **Status notifications** (`#notifications`) | below | 0.31 | **Rejected before execution** |
+
+The observed loop was:
+
+```text
+Upper form: consent is visible and can be checked
+    ↓ scroll to #notifications
+Lower form: notifications are visible and can be enabled
+    ↑ scroll back to #consent
+Repeat without changing either control
+```
+
+There were **six executed scroll actions**, forming **three complete down/up loops**. At decision **11**, Jev selected the fourth downward scroll to `#notifications`. The repeated-state guard rejected that action before calling the browser. Therefore the trace contains **11 model decisions but only 10 executed actions**: four fills plus six scrolls.
+
+The guard counts visits to a key formed from the fresh host state, operation, target selector, target match state and viewport position. It stops when a key is selected more than three times, including nonconsecutive repetitions. It is not a “three consecutive identical clicks” rule. The successful terminal `DONE` decisions for the other models are also not browser actions.
+
+### The useful actions were available
+
+At decisions **5, 7, 9 and 11**, the upper-page inputs and ordered candidates were exactly identical. Candidate `a2` offered `check` on the visible, enabled, unblocked consent checkbox. Jev instead selected `a0`, the scroll to the offscreen notifications switch.
+
+At decisions **6, 8 and 10**, the lower-page inputs and ordered candidates were exactly identical. Candidate `a0` offered `click` on the visible, enabled, unblocked notifications switch. Jev instead selected `a2`, the scroll back to consent above the viewport.
+
+For example, at decision 6 the returned distribution assigned **0.25** to scrolling up and **0.07** to clicking the notifications switch. The harness used the selected choice without a confidence cutoff, consistently with the common comparison policy. These reported probabilities are not calibrated estimates of task success, and action IDs such as `a0` are local to each observation.
+
+The trace establishes that scrolling changed which controls were in view, the corresponding local input actions remained available, and no additional values were completed during the loop. There was **no provider error, input-parser error, recorded keyboard error, invalid submission or permission block**. Jev did not attempt to click either loop target and fail; it kept choosing another scroll.
+
+### What caused it, and what is still uncertain
+
+The immediate observed failure was **action selection**: the returned rankings favored another offscreen target over useful controls already in view. The interface was stateless and did not provide action history, so the two identical recurring inputs did not carry an explicit reminder that this navigation had already failed to make progress. That is a plausible contributor, not a proven explanation of the model's internal reasoning. The trace does not show private model reasoning.
+
+This does not establish that Jev is unable to operate checkboxes, switches or forms in general. NanoJev-Web and Astra completed the same fixture through the same executor. A separate experiment could test action-history summaries or scroll-after-arrival constraints, but neither was added to rescue this measured attempt. The weights, prompt and action policy were not changed in response to this failure.
+
+## Field-by-field verification
+
+All values below are synthetic test data. An exact value match is stricter than HTML validity.
+
+| Field | Assigned value | Jev final value | Jev valid / exact | NanoJev-Web | Astra High |
+|---|---|---|---|---|---|
+| Project website | https://form-632.example.test | https://form-632.example.test | Yes / Yes | Exact, valid | Exact, valid |
+| I confirm these are test data | true | false | No / No | Exact, valid | Exact, valid |
+| Notes | Synthetic booking 35548. Prepare the workshop materials. | Synthetic booking 35548. Prepare the workshop materials. | Yes / Yes | Exact, valid | Exact, valid |
+| Support team | coral | (empty) | No / No | Exact, valid | Exact, valid |
+| Contact name | Test Contact Gamma / sample 185 | Test Contact Gamma / sample 185 | Yes / Yes | Exact, valid | Exact, valid |
+| Time | 18:00 | 18:00 | Yes / Yes | Exact, valid | Exact, valid |
+| Priority | low | (empty) | No / No | Exact, valid | Exact, valid |
+| Extras | recording, screen | (none selected) | No / No | Exact, valid | Exact, valid |
+| Date | 2030-11-16 | (empty) | No / No | Exact, valid | Exact, valid |
+| Receive marketing emails | false | true | Yes / No | Exact, valid | Exact, valid |
+| Email address | form.2652@example.test | (empty) | No / No | Exact, valid | Exact, valid |
+| Location | north | (empty) | No / No | Exact, valid | Exact, valid |
+| Phone number | +12025550197 | (empty) | No / No | Exact, valid | Exact, valid |
+| Status notifications | true | false | Yes / No | Exact, valid | Exact, valid |
+| Participants | 37 | (empty) | No / No | Exact, valid | Exact, valid |
+
+Jev's two additional valid fields were unchanged defaults: marketing emails remained **true** and notifications remained **false**. Both were valid boolean states, but both contradicted the assigned values. This explains **6 valid fields versus only 4 exact values**; the report does not count valid defaults as completed task data.
+
+## Persistence and workflow audit
+
+| Check | Jev | NanoJev-Web | Astra High |
+|---|---:|---:|---:|
+| Server submissions | 0 | 1 | 1 |
+| Exactly one submission with all assigned values | No | Yes | Yes |
+| Server accepted all field constraints | No submission | Yes | Yes |
+| Visible “Booking saved” success | No | Yes | Yes |
+| Optional/reset/cancel actions executed | 0 | 0 | 0 |
+| Invalid advance/review/submission attempts | 0 | 0 | 0 |
+| Recorded unidentified keyboard events | 0 | 0 | 0 |
+| Whole workflow passed | No | Yes | Yes |
+
+A model's `DONE` selection alone is not sufficient to pass. Both successful attempts passed the DOM match checks, independent server validation, exact saved-data comparison, single-submission check and workflow-event checks.
+
+The bench also recorded a **Stop request at the overall job level**. Individual attempt outcomes are preserved exactly as recorded: Jev `action_cycle`, NanoJev-Web `completed`, and Astra `completed`. The job-level flag is not treated as a new model failure or as the cause of Jev's earlier cycle.
+
+## Complete decision sequence
+
+Each cell identifies the model-selected operation and host-side target. `DONE` confirms visible success and is not an executed browser input. Jev's last selected scroll was rejected by the cycle guard.
+
+| Decision | Jev | NanoJev-Web | Astra High |
+|---:|---|---|---|
+| 1 | `fill` Notes | `fill` Notes | `fill` Notes |
+| 2 | `fill` Contact name | `open` Support team | `check` I confirm these are test data |
+| 3 | `fill` Project website | `check` I confirm these are test data | `fill` Contact name |
+| 4 | `fill` Time | `fill` Project website | `open` Support team |
+| 5 | `scroll` Status notifications | `fill` Contact name | `fill` Project website |
+| 6 | `scroll` I confirm these are test data | `fill` Time | `fill` Time |
+| 7 | `scroll` Status notifications | `option` Coral | `option` Coral |
+| 8 | `scroll` I confirm these are test data | `radio` Low | `radio` Low |
+| 9 | `scroll` Status notifications | `scroll` Extras | `scroll` Status notifications |
+| 10 | `scroll` I confirm these are test data | `multiselect` Extras | `click` Status notifications |
+| 11 | `scroll` Status notifications **(blocked by cycle guard)** | `fill` Date | `fill` Email address |
+| 12 | — | `fill` Email address | `uncheck` Receive marketing emails |
+| 13 | — | `uncheck` Receive marketing emails | `fill` Date |
+| 14 | — | `fill` Phone number | `multiselect` Extras |
+| 15 | — | `click` Status notifications | `select` Location |
+| 16 | — | `select` Location | `fill` Participants |
+| 17 | — | `scroll` Participants | `fill` Phone number |
+| 18 | — | `fill` Participants | `click` Review booking |
+| 19 | — | `click` Review booking | `click` Save booking |
+| 20 | — | `click` Save booking | `DONE` — visible success |
+| 21 | — | `DONE` — visible success | — |
+
+## Recorded protocol and evidence
+
+The recording used seed **43129**, no display pauses, three fresh browser sessions and the same initial decision inputs. The original fixture, comparison server and cloud adapters are not bundled with this model release. Repeating this exact three-model experiment requires that separate demonstration application; the release itself provides local inference and a runner for your own page contracts.
+
+Fixture SHA-256: `03e4713e07448df49bd9c5f56830ef41275e20c32299a64ed5beb9b638cb898b`. Protocol SHA-256: `6fa80a82af021e45f8446d0980636af5b619941601862b41b582e6c15e12dd6c`. Weight SHA-256: `0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5`.
+
+The two repeated Jev input hashes are:
+
+- Upper-page decisions 5/7/9/11: `805e8da7365a5b6529811bd317b36cedf7b51c2d00bdbcceceb44c27a224d4bd`.
+- Lower-page decisions 6/8/10: `0447597c79b267d77718dee96eef6b43a40ec43e516c0cddf67df33989444600`.
+
+Input hashes use UTF-8 JSON with preserved key order and compact separators, matching `JSON.stringify` for these payloads. The [detailed machine-readable report](demo/decisions.json) includes all 52 decisions, model-facing inputs, selected actions, usage and independent final audits. The [compact result](demo/measurements.json) contains the headline measurements. The repeated-state guard used for this attempt is described above; executable comparison code is excluded from this release.
+
+This release report contains only synthetic fixture data and allowlisted evidence. Local filesystem paths, credentials, browser profiles and private provider identifiers are omitted. The comparison is a single specialized action-selection test and does not establish general browser-agent superiority. Earlier comparisons are not merged into this recorded attempt.

docs/TRAINING.md

@@ -0,0 +1,39 @@
+# Model lineage and browser head training
+
+## Lineage
+
+- Decision model: [C-Tianyu/NanoJev](https://huggingface.co/C-Tianyu/NanoJev), revision `unified-games-v1`.
+- Source: [TianyuCodings/NanoJev](https://github.com/TianyuCodings/NanoJev), commit `618cea6d906d54e128360786d12f703fff2b1245`.
+- Backbone: [Qwen/Qwen3-0.6B](https://huggingface.co/Qwen/Qwen3-0.6B), revision `c1899de289a04d12100db370d81485cdf75e47ca`.
+- Original checkpoint SHA-256: `f68c47d66998231b86b7e91b4ed5e82ae23acf104c8b7cd6d165c3ac7b7ffe1b`.
+- Released browser checkpoint SHA-256: `0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5`.
+
+Each candidate path combines state, question, candidate text and a terminal EOS token. The backbone's final candidate representation is normalized and scored, with an attention-based set head mixing candidate information. Inference applies softmax across the supplied alternatives. There is no autoregressive decoding and no generated text to parse in the NanoJev-Web API.
+
+The set head uses a 1024-wide LayerNorm, a scalar projection, a 1025-to-128 set projection, four-head attention with width 128, and a final 128-to-1 projection. All **200,578 head parameters** were trainable; all **596,049,920 backbone parameters** were frozen. The frozen-backbone comparison and changed-head audit are retained in [weight-audit.json](../evals/weight-audit.json).
+
+## Synthetic browser data
+
+The shipped JSONL files contain **1,863 abstract synthetic states**, not collected user forms, browsing histories, names, email addresses, passwords or conversations. Labels define acceptable next actions in a known action schema. Some states admit more than one acceptable action.
+
+| Split | Rows | Generator seed | Correct acceptable-action choices |
+|---|---:|---:|---:|
+| Train | 1,251 | 731 | Not reported as a held-out result |
+| Development | 192 | 1709 | 191/192 (99.48%) |
+| Calibration | 192 | 2081 | 189/192 (98.44%) |
+| Test | 228 | 3253 | 228/228 (100%) |
+
+The development process included 51 feedback-derived examples and 240 small-page curriculum examples. Exact cross-split input duplicates were absent in the recorded data audit. The splits share a synthetic state grammar and action families; they do not test unfamiliar website reasoning. Development feedback influenced iteration. “Calibration” is a dataset split name; release probabilities have not been certified as calibrated confidence estimates.
+
+## Optimization recipe
+
+- Frozen backbone feature extraction; head optimization on cached representations.
+- AdamW, learning rate `0.0007`, weight decay `0.005`, batch size `24`.
+- Gradient norm clipping at `1.0`, seed `42`, `200` epochs.
+- Soft-target cross-entropy over candidate choices.
+- Best checkpoint chosen by development accuracy, then development cross-entropy; selected epoch `191`.
+- Final held-out test evaluated after checkpoint selection.
+
+The recorded **58.14 seconds** cover cached head optimization, not feature extraction, previous experiments or total development. Full numeric results are in [training-results.json](../evals/training-results.json). Training data and the inference architecture are published for inspection; this package does not include the old game trainer or its feature caches. It is a runnable inference release, not a claim of a fully reproduced upstream training environment.
+
+Distribution cleanup did not change the weights. The reference browser interface explicitly distinguishes unfinished inputs from available advance/submit actions and supplies only executable candidates. A recorded browser demonstration is documented separately from model-only synthetic accuracy.

docs/demo/measurements.json

@@ -0,0 +1,85 @@
+{
+  "kind": "user-started English single-form live comparison",
+  "date": "2026-09-21",
+  "seed": 43129,
+  "fixtureSha256": "03e4713e07448df49bd9c5f56830ef41275e20c32299a64ed5beb9b638cb898b",
+  "displayPauseMs": 0,
+  "concurrency": 3,
+  "equalInitialInputs": true,
+  "results": [
+    {
+      "model": "jev",
+      "form": "Workshop booking",
+      "passed": false,
+      "status": "action_cycle",
+      "seconds": 8.773282124999998,
+      "validFields": 6,
+      "fieldsCorrect": 4,
+      "serverValid": false,
+      "inputTokens": 13307,
+      "outputTokens": 1916,
+      "costUsd": 0.000558894,
+      "unknownRequests": 0,
+      "executionSeconds": 8.773282124999998,
+      "insertedPauseMs": 0,
+      "decisions": 11,
+      "actions": 10,
+      "error": null
+    },
+    {
+      "model": "nanojev",
+      "form": "Workshop booking",
+      "passed": true,
+      "status": "completed",
+      "seconds": 19.850137833000016,
+      "validFields": 15,
+      "fieldsCorrect": 15,
+      "serverValid": true,
+      "inputTokens": 52743,
+      "outputTokens": 0,
+      "costUsd": 0,
+      "unknownRequests": 0,
+      "executionSeconds": 19.850137833000016,
+      "insertedPauseMs": 0,
+      "decisions": 21,
+      "actions": 20,
+      "error": null
+    },
+    {
+      "model": "astra",
+      "form": "Workshop booking",
+      "passed": true,
+      "status": "completed",
+      "seconds": 79.15651054199998,
+      "validFields": 15,
+      "fieldsCorrect": 15,
+      "serverValid": true,
+      "inputTokens": 14661,
+      "outputTokens": 812,
+      "costUsd": 0.18721,
+      "unknownRequests": 0,
+      "executionSeconds": 79.15651054199998,
+      "insertedPauseMs": 0,
+      "decisions": 20,
+      "actions": 19,
+      "error": null
+    }
+  ],
+  "identities": {
+    "jev": "typesafe/jev-1.13-20260917",
+    "nanojev": "NanoJev-Web/browser-head-v5",
+    "astra": "openai/gpt-6-astra"
+  },
+  "scope": "One attempt per model. Individual model outcomes were recorded; a Stop request was also registered at the bench job level. This is not a multi-seed reliability estimate.",
+  "detailedReport": "../SINGLE_FORM_REPORT.md",
+  "detailedEvidence": "decisions.json",
+  "jevFailureSummary": {
+    "cycle": "scroll to #notifications below, then scroll to #consent above",
+    "cycleStartsAtDecision": 5,
+    "stopDecision": 11,
+    "executedScrolls": 6,
+    "completedDownUpLoops": 3,
+    "rejectedAction": "Fourth scroll to #notifications, rejected before browser execution",
+    "usefulActionsAvailable": true
+  }
+}

docs/demo/media-provenance.json

@@ -0,0 +1,32 @@
+{
+  "kind": "Supplied benchmark media, included with authorization",
+  "seed": 43129,
+  "imagesPreservedByteForByte": true,
+  "hero": {
+    "format": "PNG",
+    "width": 3116,
+    "height": 1240,
+    "sha256": "95a778e02ea9e444aba3926d3f8b03a6cc1a22e53d4eee6315f92c189a9604ca",
+    "bytes": 563972,
+    "path": "docs/assets/browser-demo.png"
+  },
+  "recording": {
+    "format": "GIF",
+    "width": 1316,
+    "height": 720,
+    "frames": 795,
+    "durationMs": 26510,
+    "loop": 0,
+    "sha256": "4e86be028cf41f9b3cab7e62626a6b0d1965c6e7139dbc68a472f9b40e1fecd8",
+    "bytes": 1147189,
+    "path": "docs/assets/seed-43129.gif"
+  },
+  "privacyReview": {
+    "heroExif": "Resolution, dimensions and generic Screenshot comment only",
+    "heroXmp": "Dimensions and generic Screenshot comment only",
+    "gifExtensions": "Animation timing and loop metadata",
+    "personalAuthorOrLocationMetadataDetected": false,
+    "visibleContent": "Synthetic local benchmark interface; no visible account identifiers, private paths or credentials found in the supplied image and reviewed recording frames"
+  },
+  "recordingScope": "The 26.51-second GIF shows the test in progress and ends before the final Astra Passed badge. Completion metrics are independently recorded in the existing run logs."
+}

evals/privacy-audit.json

@@ -0,0 +1,28 @@
+{
+  "passed": true,
+  "personalIdentifierMatches": 0,
+  "machinePathMatches": 0,
+  "credentialMatches": 0,
+  "trainingRows": {
+    "train": 1251,
+    "test": 228,
+    "dev": 192,
+    "calibration": 192
+  },
+  "safetensorsMetadata": null,
+  "tensorCount": 322,
+  "scope": "Release text and complete browser-head datasets; safetensors header. Tokenizer data treated as inherited assets, not scanned as user text. Numerical weights are not decoded for personal content.",
+  "detailedReportEvidence": {
+    "decisions": 52,
+    "syntheticFields": 15,
+    "rawPrivateRunFilesIncluded": false,
+    "publicFieldsAllowlisted": true
+  },
+  "reviewedPublicMedia": {
+    "screenshotIncluded": true,
+    "animatedGifIncluded": true,
+    "sourceFilesPreservedByteForByte": true,
+    "personalAuthorOrLocationMetadataDetected": false
+  },
+  "distributionScope": "Model, local inference and browser runtime; static demonstration documentation only"
+}

evals/release-checks.json

@@ -0,0 +1,55 @@
+{
+  "distribution": "model-and-browser-runtime",
+  "choiceContractTests": {
+    "passed": 6,
+    "total": 6
+  },
+  "frozenDecisionParity": {
+    "passed": 12,
+    "total": 12,
+    "maxProbabilityDifference": 0.0,
+    "tolerance": 0.0001
+  },
+  "standaloneBrowserSmoke": {
+    "passed": true,
+    "execution": "agent-browser 0.37.1",
+    "localModelDevice": "mps",
+    "decisions": 6,
+    "actions": [
+      "fill",
+      "scroll",
+      "select",
+      "check",
+      "click"
+    ],
+    "exactServerReceipts": 1,
+    "externalModelCalls": 0,
+    "scope": "Synthetic local contact form; execution check, not a model comparison"
+  },
+  "packaging": {
+    "comparisonApplicationIncluded": false,
+    "cloudProviderIntegrationsIncluded": false,
+    "weightsUnchanged": true,
+    "staticDemonstrationDocsRetained": true
+  },
+  "modelCardMetadataParsed": true,
+  "localMarkdownLinksValid": true,
+  "documentationPreview": {
+    "agentBrowserPagesChecked": 3,
+    "imagesLoaded": true
+  },
+  "dependencyInstallation": "Existing pinned runtime reused for verification; installer not rerun",
+  "reportedHardwareChecks": [
+    {
+      "hardware": "Apple M2 Pro",
+      "status": "passed",
+      "source": "contributor-reported functional test",
+      "unifiedMemoryGB": 16,
+      "cpuCores": null,
+      "gpuCores": null,
+      "macOSVersion": null,
+      "scope": "Successful local operation reported on Apple M2 Pro with 16 GB unified memory. CPU/GPU core counts, macOS version, detailed trace, peak memory and benchmark timing were not supplied.",
+      "computer": "MacBook Pro"
+    }
+  ]
+}

evals/tokenizer-provenance.json

@@ -0,0 +1,14 @@
+{
+  "source": "https://huggingface.co/Qwen/Qwen3-0.6B/resolve/c1899de289a04d12100db370d81485cdf75e47ca/tokenizer.json",
+  "localSha256": "be75606093db2094d7cd20f3c2f385c212750648bd6ea4fb2bf507a6a4c55506",
+  "upstreamSha256": "aeb13307a71acd8fe81861d94ad54ab689df773318809eed3cbe794b4492dae4",
+  "identical": false,
+  "parsedJsonIdentical": false,
+  "differentTopLevelKeys": [
+    "pre_tokenizer",
+    "decoder"
+  ],
+  "vocabularyIdentical": true,
+  "mergesIdentical": true,
+  "addedTokensIdentical": true
+}

evals/training-results.json

@@ -0,0 +1,260 @@
+{
+  "initial_dev": {
+    "n": 192,
+    "accuracy": 0.21354166666666666,
+    "ce": 2.8574434829254947,
+    "min_top_probability": 0.05820043385028839,
+    "by_mode": {
+      "0": [
+        4,
+        12
+      ],
+      "1": [
+        2,
+        12
+      ],
+      "2": [
+        4,
+        12
+      ],
+      "3": [
+        6,
+        12
+      ],
+      "4": [
+        7,
+        12
+      ],
+      "5": [
+        2,
+        12
+      ],
+      "6": [
+        0,
+        12
+      ],
+      "7": [
+        12,
+        12
+      ],
+      "8": [
+        0,
+        12
+      ],
+      "9": [
+        0,
+        12
+      ],
+      "10": [
+        0,
+        12
+      ],
+      "11": [
+        4,
+        12
+      ],
+      "late": [
+        0,
+        48
+      ]
+    }
+  },
+  "best_epoch": 191,
+  "dev": {
+    "n": 192,
+    "accuracy": 0.9947916666666666,
+    "ce": 0.35310630897861417,
+    "min_top_probability": 0.25886979699134827,
+    "by_mode": {
+      "0": [
+        12,
+        12
+      ],
+      "1": [
+        12,
+        12
+      ],
+      "2": [
+        12,
+        12
+      ],
+      "3": [
+        11,
+        12
+      ],
+      "4": [
+        12,
+        12
+      ],
+      "5": [
+        12,
+        12
+      ],
+      "6": [
+        12,
+        12
+      ],
+      "7": [
+        12,
+        12
+      ],
+      "8": [
+        12,
+        12
+      ],
+      "9": [
+        12,
+        12
+      ],
+      "10": [
+        12,
+        12
+      ],
+      "11": [
+        12,
+        12
+      ],
+      "late": [
+        48,
+        48
+      ]
+    }
+  },
+  "calibration": {
+    "n": 192,
+    "accuracy": 0.984375,
+    "ce": 0.33100821026738864,
+    "min_top_probability": 0.25569725036621094,
+    "by_mode": {
+      "0": [
+        12,
+        12
+      ],
+      "1": [
+        12,
+        12
+      ],
+      "2": [
+        12,
+        12
+      ],
+      "3": [
+        12,
+        12
+      ],
+      "4": [
+        11,
+        12
+      ],
+      "5": [
+        12,
+        12
+      ],
+      "6": [
+        12,
+        12
+      ],
+      "7": [
+        12,
+        12
+      ],
+      "8": [
+        12,
+        12
+      ],
+      "9": [
+        12,
+        12
+      ],
+      "10": [
+        12,
+        12
+      ],
+      "11": [
+        10,
+        12
+      ],
+      "late": [
+        48,
+        48
+      ]
+    }
+  },
+  "test": {
+    "n": 228,
+    "accuracy": 1.0,
+    "ce": 0.2591661242724497,
+    "min_top_probability": 0.21027213335037231,
+    "by_mode": {
+      "0": [
+        15,
+        15
+      ],
+      "1": [
+        15,
+        15
+      ],
+      "2": [
+        15,
+        15
+      ],
+      "3": [
+        15,
+        15
+      ],
+      "4": [
+        15,
+        15
+      ],
+      "5": [
+        15,
+        15
+      ],
+      "6": [
+        15,
+        15
+      ],
+      "7": [
+        15,
+        15
+      ],
+      "8": [
+        15,
+        15
+      ],
+      "9": [
+        15,
+        15
+      ],
+      "10": [
+        15,
+        15
+      ],
+      "11": [
+        15,
+        15
+      ],
+      "late": [
+        48,
+        48
+      ]
+    }
+  },
+  "parameter_max_deltas": {
+    "norm.weight": 0.8984187245368958,
+    "norm.bias": 0.8645385503768921,
+    "scalar.weight": 0.351028710603714,
+    "scalar.bias": 1.5365861654281616,
+    "set_project.weight": 0.6894388794898987,
+    "set_project.bias": 0.01813795045018196,
+    "set_attention.in_proj_weight": 0.4288993179798126,
+    "set_attention.in_proj_bias": 0.20365960896015167,
+    "set_attention.out_proj.weight": 0.3465597927570343,
+    "set_attention.out_proj.bias": 0.15903449058532715,
+    "set_output.weight": 0.7788041830062866,
+    "set_output.bias": 1.535990834236145
+  },
+  "seconds": 58.1388258934021,
+  "data_sha256": "b5d7f7a704da29658b9ea1542e268cc4d43f672468838efcbdf7fdfd441458df",
+  "checkpoint_sha256": "0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5"
+}

evals/weight-audit.json

@@ -0,0 +1,56 @@
+{
+  "backboneParametersExactlyUnchanged": 596049920,
+  "changedHeadElements": {
+    "norm.bias": 1024,
+    "norm.weight": 1024,
+    "scalar.bias": 1,
+    "scalar.weight": 1024,
+    "set_attention.in_proj_bias": 384,
+    "set_attention.in_proj_weight": 49152,
+    "set_attention.out_proj.bias": 128,
+    "set_attention.out_proj.weight": 16384,
+    "set_output.bias": 1,
+    "set_output.weight": 128,
+    "set_project.bias": 128,
+    "set_project.weight": 131200
+  },
+  "servedModelParityCases": [
+    {
+      "id": "dev-browser-00000",
+      "maxProbabilityDifference": 3.5762786865234375e-07,
+      "servedChoice": "a3",
+      "cachedChoice": "a3"
+    },
+    {
+      "id": "dev-browser-00001",
+      "maxProbabilityDifference": 2.384185791015625e-07,
+      "servedChoice": "a4",
+      "cachedChoice": "a4"
+    },
+    {
+      "id": "dev-browser-00002",
+      "maxProbabilityDifference": 1.1324882507324219e-06,
+      "servedChoice": "a1",
+      "cachedChoice": "a1"
+    },
+    {
+      "id": "dev-late-00000",
+      "maxProbabilityDifference": 2.6193447411060333e-09,
+      "servedChoice": "DONE",
+      "cachedChoice": "DONE"
+    },
+    {
+      "id": "dev-late-00001",
+      "maxProbabilityDifference": 1.3812950783176348e-11,
+      "servedChoice": "a16",
+      "cachedChoice": "a16"
+    },
+    {
+      "id": "dev-late-00002",
+      "maxProbabilityDifference": 1.1641532182693481e-10,
+      "servedChoice": "a3",
+      "cachedChoice": "a3"
+    }
+  ],
+  "passed": true
+}

examples/browser-task.json

@@ -0,0 +1,34 @@
+{
+  "name": "contact-form",
+  "url": "http://127.0.0.1:9000/contact",
+  "allowedOrigins": [
+    "http://127.0.0.1:9000"
+  ],
+  "controls": [
+    {
+      "id": "name",
+      "op": "fill",
+      "selector": "#name",
+      "label": "Name",
+      "value": "Test Contact"
+    },
+    {
+      "id": "agree",
+      "op": "check",
+      "selector": "#agree",
+      "label": "Use test data"
+    },
+    {
+      "id": "save",
+      "op": "click",
+      "purpose": "submit",
+      "selector": "#save",
+      "label": "Save"
+    }
+  ],
+  "success": {
+    "selector": "#status",
+    "kind": "text",
+    "value": "Saved"
+  }
+}

examples/choice-request.json

@@ -0,0 +1,20 @@
+{
+  "states": [
+    {
+      "id": "browser",
+      "state": "Task: complete the assigned browser form and confirm successful saving.\nPage busy=false; success=false; incomplete fields=false; incomplete interactions=false; blocking dialog=true; actionable pending in viewport=true.",
+      "questions": {
+        "next": {
+          "type": "choice",
+          "instructions": "Choose one allowed next browser action. Complete assigned inputs and interactions before advancing or submitting. Use scroll to reveal an offscreen target. Do not change satisfied fields or use optional reset/cancel actions. While busy wait. DONE requires visible success. If blocked and no permitted action can help choose BLOCKED.",
+          "criteria": {
+            "a0": "operation=click; purpose=dismiss; current=empty; expected=assigned; viewport=inside; enabled=true; blocked=false; target purpose=dismiss.",
+            "DONE": "Task is successfully saved; finish.",
+            "WAIT": "Page is busy; wait for a new observation.",
+            "BLOCKED": "Required progress is unavailable; stop for host assistance."
+          }
+        }
+      }
+    }
+  ]
+}

licenses/NanoJev-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenJev contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

licenses/Qwen-Apache-2.0.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

model/backbone_config/config.json

@@ -0,0 +1,63 @@
+{
+  "architectures": [
+    "Qwen3ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 151643,
+  "dtype": "float32",
+  "eos_token_id": 151645,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_types": [
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 40960,
+  "max_window_layers": 28,
+  "model_type": "qwen3",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 8,
+  "pad_token_id": null,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "rope_theta": 1000000,
+    "rope_type": "default"
+  },
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.17.0",
+  "use_cache": false,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

model/best.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5
+size 2385039280

model/config.json

@@ -0,0 +1,10 @@
+{
+  "model": "Qwen/Qwen3-0.6B",
+  "resolved_model_revision": "c1899de289a04d12100db370d81485cdf75e47ca",
+  "set_head": "attention",
+  "max_length": 768,
+  "schema_version": "nanojev-browser-v1",
+  "browser_version": "browser-head-v5",
+  "precision": "fp32",
+  "parameter_storage": "float32"
+}

model/tokenizer/chat_template.jinja

@@ -0,0 +1,89 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

model/tokenizer/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be75606093db2094d7cd20f3c2f385c212750648bd6ea4fb2bf507a6a4c55506
+size 11422650

model/tokenizer/tokenizer_config.json

@@ -0,0 +1,30 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": true,
+  "local_files_only": true,
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "nanojev-web",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "nanojev-web",
+      "version": "1.0.0",
+      "dependencies": {
+        "agent-browser": "0.37.1"
+      },
+      "engines": {
+        "node": ">=24"
+      }
+    },
+    "node_modules/agent-browser": {
+      "version": "0.37.1",
+      "resolved": "https://registry.npmjs.org/agent-browser/-/agent-browser-0.37.1.tgz",
+      "integrity": "sha512-NDojTSXrIq7zS090T0VwI1uzBryZWvewgxXvS0swj8/5GGnziBZLmyhEkfETO8n4n3DsJpZbZkq9F/MV2rIQKw==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "agent-browser": "bin/agent-browser.js"
+      },
+      "engines": {
+        "node": ">=24.0.0",
+        "pnpm": ">=11.0.0"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,13 @@
+{
+  "name": "nanojev-web",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "description": "Local browser action model and agent-browser execution runtime",
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "agent-browser": "0.37.1"
+  }
+}

python/model.py

@@ -0,0 +1,61 @@
+"""Decision network extracted from NanoJev; no trainer or game imports."""
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+class DecisionModel(nn.Module):
+    def __init__(self, backbone, set_head):
+        super().__init__()
+        self.backbone = backbone
+        hidden = backbone.config.hidden_size
+        self.norm = nn.LayerNorm(hidden)
+        self.scalar = nn.Linear(hidden, 1)  # Nonzero random initialization avoids a dead first step.
+        nn.init.normal_(self.scalar.weight, std=0.02)
+        nn.init.zeros_(self.scalar.bias)
+        self.set_head = set_head
+        if set_head == 'attention':
+            self.set_project = nn.Linear(hidden + 1, 128)
+            self.set_attention = nn.MultiheadAttention(128, 4, dropout=0.0, batch_first=True)
+            self.set_output = nn.Linear(128, 1)
+            # Only the final residual projection starts at zero; its upstream layers are nonzero.
+            nn.init.zeros_(self.set_output.weight)
+            nn.init.zeros_(self.set_output.bias)
+
+    def forward(self, examples, pad_token):
+        paths = [ids for ex in examples for ids in ex['leaf_tokens']]
+        device = self.scalar.weight.device
+        lengths = torch.tensor([len(ids) for ids in paths], device=device)
+        width = int(lengths.max())
+        tokens = torch.full((len(paths), width), pad_token, dtype=torch.long, device=device)
+        for i, ids in enumerate(paths):
+            tokens[i, :len(ids)] = torch.tensor(ids, device=device)
+        attention = torch.arange(width, device=device)[None, :] < lengths[:, None]
+        hidden = self.backbone(input_ids=tokens, attention_mask=attention,
+                               use_cache=False).last_hidden_state
+        leaves = hidden[torch.arange(len(paths), device=device), lengths-1]
+        kmax = max(len(ex['candidate_ids']) for ex in examples)
+        h = leaves.new_zeros((len(examples), kmax, leaves.shape[-1]))
+        valid = torch.zeros((len(examples), kmax), dtype=torch.bool, device=device)
+        offset = 0
+        for i, ex in enumerate(examples):
+            n = len(ex['leaf_tokens'])
+            h[i, :n] = leaves[offset:offset+n]
+            valid[i, :len(ex['candidate_ids'])] = True
+            offset += n
+        h = self.norm(h)
+        z = self.scalar(h).squeeze(-1).float()
+        choice = torch.tensor([i for i, ex in enumerate(examples) if ex['type'] == 'choice'], device=device)
+        if self.set_head == 'attention' and len(choice):
+            log_k = valid[choice].sum(-1).float().log()[:, None, None].expand(-1, kmax, 1)
+            u = self.set_project(torch.cat([h[choice], log_k.to(h.dtype)], dim=-1))
+            mixed, _ = self.set_attention(u, u, u, key_padding_mask=~valid[choice], need_weights=False)
+            delta = self.set_output(torch.tanh(u + mixed)).squeeze(-1).float()
+            z = z.index_add(0, choice, delta)
+        # Boolean has one semantic path and one scalar, representing logits [0,z].
+        out = []
+        for i, ex in enumerate(examples):
+            if ex['type'] == 'boolean':
+                out.append(F.pad(torch.stack([z[i, 0] * 0, z[i, 0]]), (0, kmax-2)))
+            else:
+                out.append(z[i])
+        return torch.stack(out).masked_fill(~valid, -1e9), valid

python/predictor.py

@@ -0,0 +1,195 @@
+"""Local browser decision inference. No downloads, teacher or game runtime."""
+from contextlib import nullcontext
+import json,math,os
+from pathlib import Path
+from schema import validate_request
+
+def unique_object(pairs):
+    obj = {}
+    for key, value in pairs:
+        if key in obj:
+            raise ValueError(f"JSON contains duplicate key: {key}")
+        obj[key] = value
+    return obj
+
+def reject_nonfinite(value):
+    raise ValueError(f"JSON disallows non-finite number: {value}")
+
+def read_json(path):
+    return json.loads(Path(path).read_text(encoding="utf-8"), object_pairs_hook=unique_object,
+                      parse_constant=reject_nonfinite)
+
+def nonempty_text(value):
+    return isinstance(value, str) and bool(value.strip())
+
+def prepare_examples(payload, tokenizer, max_length):
+    """Segment encoding, candidate text and EOS follow the upstream training tokenization exactly."""
+    states = validate_request(payload)
+    if type(max_length) is not int or max_length <= 0:
+        raise ValueError("max_length must be a positive integer")
+    if type(tokenizer.eos_token_id) is not int or tokenizer.eos_token_id < 0:
+        raise ValueError("Checkpoint tokenizer must have a valid eos_token_id")
+    examples = []
+    for row in states:
+        for qid, q in row["questions"].items():
+            typ = q["type"]
+            ids = list(q["criteria"])
+            texts = [f"{key}: {q['criteria'][key]}" for key in ids]
+            segments = [f"State:\n{row['state']}\n",
+                        f"Question type: {typ}\nQuestion:\n{q['instructions']}\n"]
+            prefix = sum([tokenizer.encode(t, add_special_tokens=False) for t in segments], [])
+            leaves = [prefix + tokenizer.encode(f"Candidate:\n{t}\nDecision:", add_special_tokens=False)
+                      + [tokenizer.eos_token_id] for t in texts]
+            largest = max(map(len, leaves))
+            if largest > max_length:
+                raise ValueError(f"{row['id']}:{qid} candidate path has {largest} tokens, exceeding max_length={max_length}; input was not truncated")
+            examples.append({"id": f"{row['id']}:{qid}", "state_id": row["id"], "qid": qid,
+                             "type": typ, "candidate_ids": ids, "candidate_texts": texts,
+                             "leaf_tokens": leaves})
+    return examples
+
+def complete_question_batches(examples, batch_questions=0):
+    if type(batch_questions) is not int or batch_questions < 0:
+        raise ValueError("batch_questions must be nonnegative; zero batches all questions together")
+    size = batch_questions or len(examples)
+    if not examples:
+        return []
+    return [examples[i:i + size] for i in range(0, len(examples), size)]
+
+def answer_from_probabilities(example, probabilities):
+    ids = example["candidate_ids"]
+    if len(probabilities) != len(ids) or not all(math.isfinite(p) and 0 <= p <= 1 for p in probabilities):
+        raise ValueError("Model produced invalid probabilities")
+    if abs(math.fsum(probabilities) - 1.0) > 1e-5:
+        raise ValueError("Model probabilities do not sum to one")
+    best = max(range(len(ids)), key=probabilities.__getitem__)
+    result = {"type": example["type"], "probabilities": dict(zip(ids, probabilities))}
+    result.update(choice=ids[best], value=ids[best])
+    return result
+
+def local_checkpoint_files(checkpoint_dir):
+    root = Path(checkpoint_dir).expanduser().resolve(strict=True)
+    if not root.is_dir():
+        raise ValueError("Checkpoint must be a local directory")
+    paths = {"run_config": root / "config.json", "body_config": root / "backbone_config",
+             "tokenizer": root / "tokenizer", "weights": root / "best.safetensors"}
+    for label, path in paths.items():
+        if not path.exists():
+            raise ValueError(f"Checkpoint missing {label}: {path.name}")
+    if not paths["run_config"].is_file() or not paths["weights"].is_file():
+        raise ValueError("config.json and best.safetensors must be files")
+    if not paths["body_config"].is_dir() or not paths["tokenizer"].is_dir():
+        raise ValueError("backbone_config and tokenizer must be directories")
+    return root, paths
+
+class DecisionPredictor:
+    """Persistent local inference: load weights once, evaluate complete candidate sets per question."""
+
+    def __init__(self, checkpoint_dir, max_length=None, device_name="mps",
+                 disable_native_triton=False, precision="fp32"):
+        if precision != "fp32":
+            raise ValueError("precision must be fp32")
+        root, paths = local_checkpoint_files(checkpoint_dir)
+        run_config = read_json(paths["run_config"])
+        if not isinstance(run_config, dict) or run_config.get("set_head") not in {"none", "attention"}:
+            raise ValueError("Checkpoint config has no valid set_head")
+    
+        # Load local checkpoint only; no environment files, Hub requests or model downloads.
+        os.environ["HF_HUB_OFFLINE"] = "1"
+        os.environ["TRANSFORMERS_OFFLINE"] = "1"
+        os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
+        import torch
+        from safetensors.torch import load_file
+        from transformers import AutoConfig, AutoModel, AutoTokenizer
+    
+        device = torch.device(device_name)
+        if device.type == "mps":
+            if not torch.backends.mps.is_available():
+                raise ValueError("MPS is unavailable; native Apple Silicon Python is required")
+        elif device.type != "cpu":
+            raise ValueError("This package supports mps and cpu")
+        if precision != "fp32":
+            raise ValueError("This package uses FP32 inference")
+
+        tokenizer = AutoTokenizer.from_pretrained(str(paths["tokenizer"]), local_files_only=True,
+                                                 trust_remote_code=False)
+        if tokenizer.pad_token_id is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        body_config = AutoConfig.from_pretrained(str(paths["body_config"]), local_files_only=True,
+                                                trust_remote_code=False)
+        body_config.use_cache = False
+        limit = run_config.get("max_length", 512) if max_length is None else max_length
+        if type(limit) is not int or limit <= 0:
+            raise ValueError("max-length must be a positive integer")
+        context_limit = getattr(body_config, "max_position_embeddings", None)
+        if isinstance(context_limit, int) and limit > context_limit:
+            raise ValueError("max-length exceeds the backbone context length")
+    
+        # Build the architecture from config; load every parameter from best.safetensors without downloading a base model.
+        body = AutoModel.from_config(body_config, attn_implementation="sdpa", trust_remote_code=False).float()
+        from model import DecisionModel
+        model = DecisionModel(body, run_config["set_head"])
+        weights = load_file(str(paths["weights"]), device="cpu")
+        model.load_state_dict(weights, strict=True)
+        del weights
+        model.to(device=device, dtype=torch.float32)
+        model.eval()
+        self.model = model
+        self.tokenizer = tokenizer
+        self.root = root
+        self.run_config = run_config
+        self.limit = limit
+        self.device = device
+        self.precision = precision
+        self.disable_native_triton = disable_native_triton
+        self.inference_calls = 0
+        self._torch = torch
+
+    def predict(self, payload, batch_questions=0, temperature=1.0):
+        states = validate_request(payload)
+        if not isinstance(temperature, (int, float)) or isinstance(temperature, bool) or not math.isfinite(temperature) or temperature <= 0:
+            raise ValueError("temperature must be finite and positive")
+        torch = self._torch
+        model, tokenizer = self.model, self.tokenizer
+        root, run_config, limit = self.root, self.run_config, self.limit
+        device, precision = self.device, self.precision
+        disable_native_triton = self.disable_native_triton
+        examples = prepare_examples(payload, tokenizer, limit)
+        batches = complete_question_batches(examples, batch_questions)
+        self.inference_calls += 1
+        model.eval()
+        outputs = {state["id"]: {"id": state["id"], "answers": {}} for state in states}
+        with torch.inference_mode():
+            for batch in batches:
+                context = nullcontext()
+                with context:
+                    logits, _ = model(batch, tokenizer.pad_token_id)
+                for example, values in zip(batch, logits):
+                    k = len(example["candidate_ids"])
+                    scores = values[:k].float()
+                    if not torch.isfinite(scores).all():
+                        raise ValueError("Model produced non-finite logits; no partial prediction returned")
+                    probabilities = (scores / temperature).softmax(-1).cpu().tolist()
+                    outputs[example["state_id"]]["answers"][example["qid"]] = answer_from_probabilities(example, probabilities)
+        return {
+            "schema_version": "nanojev-browser-inference-v1",
+            "checkpoint": {"id": "NanoJev-Web/browser-head-v5", "base_model": run_config.get("model"),
+                           "base_revision": run_config.get("resolved_model_revision"), "set_head": run_config["set_head"]},
+            "temperature": {"value": float(temperature), "fitted_by_this_command": False,
+                            "note": "Applies the supplied scalar; the default of 1 does not imply calibration."},
+            "execution": {"device": str(device), "parameter_storage": "float32", "precision": precision,
+                          "forward_autocast": "bfloat16" if precision == "bf16" else "disabled",
+                          "states": len(states), "questions": len(examples),
+                          "candidate_paths": sum(len(ex["leaf_tokens"]) for ex in examples),
+                          "input_tokens": sum(len(path) for ex in examples for path in ex["leaf_tokens"]),
+                          "padded_input_tokens": sum(
+                              max(len(path) for ex in batch for path in ex["leaf_tokens"])
+                              * sum(len(ex["leaf_tokens"]) for ex in batch) for batch in batches),
+                          "output_tokens": 0,
+                          "forward_passes": len(batches), "batch_questions_limit": batch_questions or "all",
+                          "autoregressive_decode_steps": 0, "prefix_sharing": False,
+                          "max_length": limit, "disable_native_triton": disable_native_triton,
+                          "network_model_calls": 0, "persistent_model_load_count": 1,
+                          "inference_call_index": self.inference_calls},
+            "states": list(outputs.values()),
+        }

python/schema.py

@@ -0,0 +1,36 @@
+"""Strict browser decision request contract; values and UI mechanics stay in Node."""
+def validate_request(payload):
+    if not isinstance(payload,dict) or set(payload)!={'states'}:
+        raise ValueError('Expected {"states": [...]}')
+    states=payload['states']
+    if not isinstance(states,list) or not 1<=len(states)<=32:
+        raise ValueError('Expected 1–32 states')
+    seen=set();question_count=path_count=0
+    for state in states:
+        if not isinstance(state,dict) or set(state)!={'id','state','questions'}:
+            raise ValueError('Each state requires id, state, questions')
+        sid=state['id']
+        if not isinstance(sid,str) or not sid.strip() or sid in seen:
+            raise ValueError('State IDs must be unique nonempty strings')
+        seen.add(sid)
+        if not isinstance(state['state'],(str,dict,list)) or not state['state']:
+            raise ValueError('State must be nonempty text, object or list')
+        questions=state['questions']
+        if not isinstance(questions,dict) or not questions:
+            raise ValueError('Questions must be a nonempty object')
+        for qid,q in questions.items():
+            if not isinstance(qid,str) or not qid.strip() or not isinstance(q,dict):
+                raise ValueError('Invalid question')
+            if set(q)!={'type','instructions','criteria'} or q['type']!='choice':
+                raise ValueError('Browser API supports choice questions only')
+            if not isinstance(q['instructions'],str) or not q['instructions'].strip():
+                raise ValueError('Instructions must be nonempty text')
+            criteria=q['criteria']
+            if not isinstance(criteria,dict) or not 2<=len(criteria)<=255:
+                raise ValueError('Expected 2–255 candidate actions')
+            if any(not isinstance(k,str) or not k.strip() or not isinstance(v,str) or not v.strip() for k,v in criteria.items()):
+                raise ValueError('Candidate IDs and descriptions must be nonempty text')
+            question_count+=1;path_count+=len(criteria)
+    if question_count>96 or path_count>256:
+        raise ValueError('Request exceeds 96 questions or 256 candidate paths')
+    return states

python/server.py

@@ -0,0 +1,55 @@
+"""Persistent local inference API, without a game UI, trainer or external model calls."""
+import argparse,json,time
+from http.server import HTTPServer,BaseHTTPRequestHandler
+from pathlib import Path
+from urllib.parse import urlsplit
+from predictor import DecisionPredictor,unique_object,reject_nonfinite
+from schema import validate_request
+ROOT=Path(__file__).resolve().parents[1]
+
+def make_handler(engine):
+    class Handler(BaseHTTPRequestHandler):
+        def reply(self,status,data):
+            raw=json.dumps(data,ensure_ascii=False,allow_nan=False).encode()
+            self.send_response(status);self.send_header('Content-Type','application/json; charset=utf-8')
+            self.send_header('Content-Length',str(len(raw)));self.send_header('Cache-Control','no-store')
+            self.end_headers();self.wfile.write(raw)
+        def do_GET(self):
+            if urlsplit(self.path).path in ['/', '/api/health']:
+                self.reply(200,{'service':'NanoJev-Web','version':'1.0.0-web','ready':True,'model':'browser-head-v5','device':str(engine.device),'precision':engine.precision,'provider_calls':0})
+            else:self.reply(404,{'error':'Not found'})
+        def do_POST(self):
+            if urlsplit(self.path).path!='/api/evaluate':return self.reply(404,{'error':'Not found'})
+            try:
+                n=int(self.headers.get('Content-Length',0))
+                if not 0<n<=2_000_000:raise ValueError('Expected 1–2000000 request bytes')
+                origin=self.headers.get('Origin')
+                if origin and urlsplit(origin).netloc!=self.headers.get('Host'):
+                    return self.reply(403,{'error':'Cross-origin requests are disabled'})
+                body=json.loads(self.rfile.read(n),object_pairs_hook=unique_object,parse_constant=reject_nonfinite)
+                validate_request(body);start=time.perf_counter();result=engine.predict(body,batch_questions=1)
+                result['execution']['server_evaluation_seconds']=time.perf_counter()-start
+                self.reply(200,result)
+            except (ValueError,KeyError,TypeError) as e:self.reply(400,{'error':str(e)})
+            except Exception:
+                import traceback;traceback.print_exc()
+                self.reply(500,{'error':'Local inference failed; no external fallback was used'})
+        def log_message(self,fmt,*args):print(fmt%args,flush=True)
+    return Handler
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--model',type=Path,default=ROOT/'model');p.add_argument('--port',type=int,default=8774)
+    p.add_argument('--device',choices=['mps','cpu'],default='mps');p.add_argument('--max-length',type=int,default=768)
+    a=p.parse_args()
+    if not 1024<=a.port<=65535:p.error('Use an unprivileged port from 1024 to 65535')
+    # Bind first: an occupied port fails before loading another copy of the model.
+    server=HTTPServer(('127.0.0.1',a.port),BaseHTTPRequestHandler)
+    try:
+        engine=DecisionPredictor(a.model,device_name=a.device,precision='fp32',max_length=a.max_length)
+        server.RequestHandlerClass=make_handler(engine)
+        print(json.dumps({'service':'NanoJev-Web','ready':True,'url':f'http://127.0.0.1:{a.port}','device':a.device}),flush=True)
+        server.serve_forever()
+    except KeyboardInterrupt:pass
+    finally:server.server_close()
+if __name__=='__main__':main()

requirements-lock.txt

@@ -0,0 +1,34 @@
+annotated-doc==0.0.5
+anyio==4.15.1
+certifi==2026.7.22
+click==8.5.0
+filelock==4.0.1
+fsspec==2026.9.0
+h11==0.16.0
+hf-xet==1.6.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==1.32.0
+idna==3.20
+jinja2==3.1.6
+markdown-it-py==4.2.0
+markupsafe==3.0.3
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.5.3
+packaging==26.3
+pygments==2.21.0
+pyyaml==6.0.3
+regex==2026.9.10
+rich==15.0.0
+safetensors==0.8.0
+setuptools==84.0.0
+shellingham==1.5.4
+sympy==1.14.0
+tokenizers==0.23.2
+torch==2.14.0
+tqdm==4.70.1
+transformers==5.17.0
+typer==0.27.2
+typing-extensions==4.16.0

run.command

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -euo pipefail
+source "$(dirname -- "$0")/scripts/common.sh"
+exec "$nanojev_node" "$nanojev_root/runtime/agent.mjs" "$@"

runtime/agent.mjs

@@ -0,0 +1,9 @@
+import {readFile} from 'node:fs/promises';
+import {runTask} from './browser.mjs';
+const i=process.argv.indexOf('--task');
+if(i<0)throw Error('Usage: ./run.command --task task.json [--endpoint http://127.0.0.1:8774]');
+const task=JSON.parse(await readFile(process.argv[i+1],'utf8'));
+const e=process.argv.indexOf('--endpoint');
+const {report,browser}=await runTask(task,{endpoint:e>=0?process.argv[e+1]:'http://127.0.0.1:8774'});
+await browser.command(['close']);
+if(report.status!=='completed')process.exitCode=1;

runtime/browser.mjs

@@ -0,0 +1,225 @@
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {readFile,writeFile,mkdir} from 'node:fs/promises';
+import {resolve,dirname} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createHash} from 'node:crypto';
+const exec=promisify(execFile);
+const AB=process.env.NANOJEV_AGENT_BROWSER_BIN??resolve(dirname(fileURLToPath(import.meta.url)),'../node_modules/.bin/agent-browser');
+const ROOT=resolve(dirname(fileURLToPath(import.meta.url)),'..');
+export const INSTRUCTION='Choose one allowed next browser action. Complete assigned inputs and interactions before advancing or submitting. When the current stage has no unfinished fields or interactions, choose its assigned advance action, then submit on the final review. The unfinished-input indicator does not describe availability of advance/submit actions. Use scroll to reveal an offscreen target. Do not change satisfied fields or use optional reset/cancel actions. While busy wait. DONE requires visible success. If blocked and no permitted action can help choose BLOCKED.';
+export const SPECIALS={DONE:'Task is successfully saved; finish.',WAIT:'Page is busy; wait for a new observation.',BLOCKED:'Required progress is unavailable; stop for host assistance.'};
+const INPUTS=new Set(['fill','type','clear','select','multiselect','check','uncheck','radio','upload']);
+const OPS=new Set([...INPUTS,'click','hover','dblclick','drag','focus','press','open','option','add','remove','link','tab']);
+const hash=value=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+
+export function description(a){return `operation=${a.op}; purpose=${a.purpose}; current=${a.current}; expected=${a.expected}; viewport=${a.viewport}; enabled=${a.enabled}; blocked=${a.blocked}; target purpose=${a.sourcePurpose??a.purpose}.`;}
+export function stateText(s){return `Task: complete the assigned browser form and confirm successful saving.\nPage busy=${s.busy}; success=${s.success}; incomplete fields=${Boolean(s.fields)}; incomplete interactions=${Boolean(s.interactions)}; blocking dialog=${s.modal}; unfinished input/interaction in viewport=${Boolean(s.ready)}.`;}
+
+export class Browser{
+  constructor(session,{origins}={}){this.session=session;this.calls=0;this.ms=0;this.targetId=null;this.parentTargets=[];this.flags=['--session',session,'--pin-tab','--headed','false','--idle-timeout','0'];if(origins?.length)this.flags.push('--allowed-domains',[...new Set(origins.map(x=>new URL(x).hostname))].join(','));}
+  async command(args){const start=performance.now();this.calls++;const {stdout}=await exec(AB,[...this.flags,'--json',...args],{timeout:20000,maxBuffer:8*1024*1024,encoding:'utf8'});this.ms+=performance.now()-start;const result=JSON.parse(stdout);if(!result.success)throw Error(`agent-browser: ${String(result.error).slice(0,200)}`);return result.data;}
+  async observe(task){
+    const tabs=(await this.command(['tab'])).tabs.filter(x=>x.active);if(tabs.length!==1)throw Error('Ambiguous active tab');
+    if(this.targetId&&this.targetId!==tabs[0].targetId)throw Error('Active tab changed unexpectedly');this.targetId=tabs[0].targetId;
+    const snapshot=await this.command(['snapshot']);
+    if(!task.allowedOrigins.includes(new URL(snapshot.origin).origin))throw Error('Origin outside authorized task');
+    // Pure DOM read: no mutation, no access to fixture state, answers, receipts or request APIs.
+    const expression=`JSON.stringify(((${readDom.toString()})(${JSON.stringify(task)})))`;
+    const raw=await this.command(['eval',expression]);const dom=typeof raw.result==='string'?JSON.parse(raw.result):raw.result;
+    const refs=Object.entries(snapshot.refs??{}).map(([ref,m])=>{const line=snapshot.snapshot.split('\n').find(l=>new RegExp('\\bref='+ref+'\\b').test(l))??'';return {ref,...m,disabled:/\[(?:[^\]]*,\s*)?disabled(?:,|\])/.test(line),checked:/\bchecked(?:=true)?(?:,|\])/.test(line)&&!line.includes('checked=false')};});
+    const actions=[];let fields=0,interactions=0;
+    for(const c of dom.controls){
+      if(c.count>1)throw Error(`Ambiguous selector for ${c.label}`);
+      if(!c.visible)continue;
+      if(c.type==='password')throw Error('Secret input requires host helper');
+      const purpose=c.purpose??(INPUTS.has(c.op)?'input':'interaction');
+      if(!c.blocked&&c.expected!=='optional'&&c.current!=='match'){
+        if(purpose==='input')fields++;
+        if(purpose==='interaction')interactions++;
+      }
+      // Disabled and modal-covered controls cannot be authorized executable actions.
+      if(c.blocked||!c.enabled)continue;
+      const role=c.role||refs.find(r=>r.name===c.label)?.role?.toLowerCase()||'button';
+      const a={...c,role,purpose,expected:c.expected??'assigned'};
+      actions.push(a);
+      if(c.viewport!=='inside')actions.push({...a,op:'scroll',role:'viewport',purpose:'reveal',sourcePurpose:purpose});
+    }
+    const ready=actions.filter(a=>a.op!=='scroll'&&a.current!=='match'&&a.expected==='assigned'&&a.viewport==='inside'&&['input','interaction','dismiss'].includes(a.purpose)).length;
+    const s={busy:dom.busy,success:dom.success,fields,interactions,modal:dom.modal,ready};
+    const relevant={s,actions:actions.map(a=>({...a,value:undefined,condition:undefined,expect:undefined,when:undefined})),targetId:this.targetId};
+    return {state:stateText(s),s,actions,snapshot,dom,signature:hash(relevant)};
+  }
+  async act(a){
+    if(!a.enabled||a.blocked)throw Error('Model selected a disabled or covered action');
+    if(a.op!=='scroll'&&a.viewport!=='inside')throw Error('Model attempted an offscreen action without scrolling');
+    if(a.href&&['click','link'].includes(a.op)&&!this.allowedOrigins.includes(new URL(a.href).origin))throw Error('Link destination outside task origins');
+    if(a.frame){
+      if(a.op==='scroll')await this.command(['scrollintoview',a.frame]);
+      await this.command(['frame',a.frame]);
+      try{return await this.act({...a,frame:null});}finally{await this.command(['frame','main']);}
+    }
+    const sel=a.selector;
+    switch(a.op){
+      case 'fill':
+        if(['date','time','datetime-local'].includes(a.type))return this.fillTemporal(a);
+        return this.command(['fill',sel,String(a.value)]);
+      case 'type':
+        await this.command(['focus',sel]);
+        await this.command(['press','End']);
+        return this.command(['keyboard','type',String(a.value)]);
+      case 'clear':return this.command(['fill',sel,'']);
+      case 'select':return this.command(['select',sel,String(a.value)]);
+      case 'multiselect':return this.command(['select',sel,...a.value.map(String)]);
+      case 'check':case 'uncheck':case 'hover':case 'dblclick':case 'focus':return this.command([a.op,sel]);
+      case 'scroll':return this.command(['scrollintoview',sel]);
+      case 'press':return process.platform==='darwin'&&/^(Escape|Esc)$/i.test(a.key)?this.pressEscape():this.command(['press',a.key]);
+      case 'drag':return this.command(['drag',sel,a.destination]);
+      case 'upload':return this.command(['upload',sel,...(Array.isArray(a.value)?a.value:[a.value]).map(String)]);
+      case 'tab':{
+        if(a.mode==='open'){
+          if(!this.allowedOrigins.includes(new URL(a.url).origin))throw Error('Tab URL outside task origins');
+          this.parentTargets.push(this.targetId);await this.command(['tab','new',a.url]);
+        }else if(a.mode==='return'){
+          const parent=this.parentTargets.pop();if(!parent)throw Error('No authorized parent tab');await this.command(['tab',parent]);
+        }else throw Error('Unsupported tab operation');
+        const tabs=(await this.command(['tab'])).tabs.filter(t=>t.active);if(tabs.length!==1)throw Error('Tab activation ambiguous');this.targetId=tabs[0].targetId;return;
+      }
+      case 'radio':case 'click':case 'open':case 'option':case 'add':case 'remove':case 'link':return this.command(['click',sel]);
+      default:throw Error(`Unsupported runtime operation ${a.op}`);
+    }
+  }
+  async pressEscape(){
+    // agent-browser 0.37.1 CLI press on this Mac emits a stream of unrelated
+    // native Minus key events after Escape. Its documented input_keyboard
+    // channel sends the intended native key once without that translation.
+    const status=await this.command(['stream','status']);
+    if(!status.enabled||!Number.isInteger(status.port)||status.port<1||status.port>65535)throw Error('agent-browser keyboard stream unavailable');
+    const ws=new WebSocket(`ws://127.0.0.1:${status.port}/?pacing=ack&maxFps=1`);
+    try{
+      await new Promise((resolve,reject)=>{const timer=setTimeout(()=>reject(Error('Keyboard stream connection timed out')),5000);ws.onopen=()=>{clearTimeout(timer);resolve();};ws.onerror=()=>{clearTimeout(timer);reject(Error('Keyboard stream connection failed'));};});
+      for(const eventType of ['keyDown','keyUp'])ws.send(JSON.stringify({type:'input_keyboard',eventType,key:'Escape',code:'Escape',windowsVirtualKeyCode:27,modifiers:0}));
+      this.streamKeyboardEvents=(this.streamKeyboardEvents??0)+2;
+      await this.command(['wait','100']);
+    }finally{ws.close();}
+  }
+  async fillTemporal(a){
+    const raw=String(a.value),parts=[];
+    if(a.type!=='time'){
+      const m=raw.match(/^(\d{4})-(\d{2})-(\d{2})/);if(!m)throw Error('Date must use ISO format');
+      parts.push([/День|\bDay\b/i,m[3]],[/Месяц|\bMonth\b/i,m[2]],[/Год|\bYear\b/i,m[1]]);
+    }
+    if(a.type!=='date'){
+      const m=raw.match(/(?:T|^)(\d{2}):(\d{2})(?::(\d{2}))?$/);if(!m)throw Error('Time must use HH:MM[:SS]');
+      parts.push([/Час|\bHour\b/i,m[1]],[/Минут|\bMinute\b/i,m[2]]);if(m[3])parts.push([/Секунд|\bSecond\b/i,m[3]]);
+    }
+    for(const [pattern,value] of parts){
+      const s=await this.command(['snapshot','-s',a.selector]);
+      const found=Object.entries(s.refs).filter(([r,m])=>m.role==='spinbutton'&&pattern.test(m.name)&&new RegExp('\\bref='+r+'\\b').test(s.snapshot));
+      if(found.length!==1)throw Error('Date/time segment is missing or ambiguous in current locale');
+      await this.command(['click','@'+found[0][0]]);
+      for(const digit of value)await this.command(['press',digit]);
+    }
+    await this.command(['press','Tab']);
+    const result=await this.command(['get','value',a.selector]);if(result.value!==raw)throw Error('Date/time input did not preserve the assigned value');return result;
+  }
+}
+
+function readDom(task){
+  const context=frame=>frame?document.querySelector(frame)?.contentDocument:document;
+  const query=(s,frame)=>s?Array.from(context(frame)?.querySelectorAll(s)??[]):[];
+  const shown=e=>!!e&&!!e.getClientRects().length&&getComputedStyle(e).visibility!=='hidden'&&getComputedStyle(e).display!=='none';
+  const value=e=>!e?null:e.type==='checkbox'||e.type==='radio'?e.checked:e.tagName==='SELECT'&&e.multiple?Array.from(e.selectedOptions).map(o=>o.value):e.type==='file'?Array.from(e.files).map(f=>({name:f.name,size:f.size})):('value'in e?e.value:e.textContent.trim());
+  const same=(a,b)=>JSON.stringify(a)===JSON.stringify(b);
+  const viewBounds=el=>{
+    const w=el.ownerDocument.defaultView,b={top:0,left:0,right:w.innerWidth,bottom:w.innerHeight};
+    for(let p=el.parentElement;p;p=p.parentElement){
+      const style=w.getComputedStyle(p),r=p.getBoundingClientRect();
+      if(/auto|scroll|hidden|clip/.test(style.overflowY)){b.top=Math.max(b.top,r.top+p.clientTop);b.bottom=Math.min(b.bottom,r.top+p.clientTop+p.clientHeight);}
+      if(/auto|scroll|hidden|clip/.test(style.overflowX)){b.left=Math.max(b.left,r.left+p.clientLeft);b.right=Math.min(b.right,r.left+p.clientLeft+p.clientWidth);}
+    }return b;
+  };
+  const condition=(c,frame)=>{
+    if(!c)return false;frame=c.frame??frame;const els=query(c.selector,frame),e=els[0];
+    if(c.kind==='any')return c.conditions.some(x=>condition(x,frame));
+    if(c.kind==='all')return c.conditions.every(x=>condition(x,frame));
+    if(c.kind==='absent')return !e||!shown(e);
+    if(c.kind==='visible')return shown(e);
+    if(c.kind==='count')return els.filter(shown).length===c.value;
+    if(c.kind==='text')return !!e&&e.textContent.trim()===c.value;
+    if(c.kind==='includes')return !!e&&e.textContent.includes(c.value);
+    if(c.kind==='attribute')return !!e&&e.getAttribute(c.attribute)===c.value;
+    if(c.kind==='focused')return !!e&&e.ownerDocument.activeElement===e;
+    if(c.kind==='property')return !!e&&e[c.property]===c.value;
+    if(c.kind==='value')return same(value(e),c.value);
+    return false;
+  };
+  const openDialogs=query('dialog[open],[role="dialog"][aria-modal="true"]').filter(shown),dialog=openDialogs.at(-1);
+  const controls=task.controls.map(c=>{
+    const els=query(c.selector,c.frame),e=els[0],frameElement=c.frame?document.querySelector(c.frame):null,visible=shown(e)&&(!c.frame||shown(frameElement))&&(!c.when||condition(c.when,c.frame));
+    if(!e)return {...c,count:0,visible:false};
+    const r=e.getBoundingClientRect(),bounds=viewBounds(e),fr=frameElement?.getBoundingClientRect();
+    let above=r.top<bounds.top-1||r.left<bounds.left-1,below=r.bottom>bounds.bottom+1||r.right>bounds.right+1;
+    if(frameElement){const outer=viewBounds(frameElement);above||=r.top+fr.top<outer.top-1||r.left+fr.left<outer.left-1;below||=r.bottom+fr.top>outer.bottom+1||r.right+fr.left>outer.right+1;}
+    const viewport=above?'above':below?'below':'inside';
+    let matched=false;
+    if(c.expect)matched=condition(c.expect,c.frame);
+    else if(c.op==='check'||c.op==='radio')matched=e.checked===true;
+    else if(c.op==='uncheck')matched=e.checked===false;
+    else if(c.op==='clear')matched=value(e)==='';
+    else if(c.op==='multiselect')matched=same([...value(e)].sort(),[...c.value].sort());
+    else if(c.op==='upload')matched=same(value(e).map(f=>f.name).sort(),(Array.isArray(c.value)?c.value:[c.value]).map(p=>p.split('/').at(-1)).sort());
+    else if(['fill','type','select'].includes(c.op))matched=same(value(e),c.finalValue??c.value);
+    const current=matched?'match':value(e)===''||value(e)===false?'empty':'wrong';
+    const enabled=!e.disabled&&e.getAttribute('aria-disabled')!=='true'&&!e.closest('[inert]')&&(!['fill','type','clear'].includes(c.op)||!e.readOnly);
+    const nativeRole=e.getAttribute('role')||(e.tagName==='SELECT'?(e.multiple?'listbox':'combobox'):e.tagName==='TEXTAREA'?'textbox':e.tagName==='INPUT'?({number:'spinbutton',checkbox:'checkbox',radio:'radio',file:'button'}[e.type]??'textbox'):e.tagName==='A'?'link':'button');
+    return {...c,role:c.role??nativeRole,count:els.length,visible,current,enabled,viewport,blocked:!!dialog&&!dialog.contains(frameElement??e),type:e.type??null,href:e.tagName==='A'?e.href:null,actual:value(e)};
+  });
+  return {controls,errors:query(task.errorSelector??'[role="alert"]').filter(shown).map(e=>e.textContent.trim()).filter(Boolean),busy:query(task.busySelector??'[aria-busy="true"]').some(shown),success:condition(task.success),modal:controls.some(c=>c.visible&&!c.blocked&&c.purpose==='dismiss')};
+}
+
+export function validateTask(t){
+  if(!t.name||!t.url||!Array.isArray(t.controls)||!t.controls.length||!Array.isArray(t.allowedOrigins)||!t.allowedOrigins.includes(new URL(t.url).origin))throw Error('Invalid task contract');
+  if(t.controls.some(c=>!OPS.has(c.op)||!c.selector||!c.label))throw Error('Invalid control');
+  if(new Set(t.controls.map(c=>c.id)).size!==t.controls.length)throw Error('Duplicate control IDs');
+  return t;
+}
+export async function runTask(task,{session,endpoint,maxSteps=100,outDir=resolve(ROOT,'.local/runs'),setup=true}={}){
+  if(!endpoint)throw Error('An explicit NanoJev endpoint is required');
+  validateTask(task);session??=`nanojev-${task.name}-${Date.now()}`;const browser=new Browser(session,{origins:task.allowedOrigins});browser.allowedOrigins=task.allowedOrigins;await mkdir(outDir,{recursive:true});
+  if(setup){await browser.command(['open',task.url]);await browser.command(['set','viewport','1100','800']);}
+  const runnerSha256=createHash('sha256').update(await readFile(fileURLToPath(import.meta.url))).digest('hex');
+  const start=performance.now(),trace=[],visits=new Map();let status='step_limit',error=null,last=null,repeats=0,modelIdentity=null;
+  try{
+    for(let step=0;step<maxSteps;step++){
+      if(performance.now()-start>600000){status='time_limit';break;}
+      const observation=await browser.observe(task);
+      observation.actions=observation.actions.filter(a=>(a.op==='scroll'||a.viewport==='inside')&&!(a.current==='match'&&a.expected==='assigned'&&['input','interaction','dismiss','reveal'].includes(a.purpose)));
+      const criteria=Object.fromEntries(observation.actions.map((a,i)=>[`a${i}`,description(a)]));Object.assign(criteria,SPECIALS);
+      const request={states:[{id:'browser',state:observation.state,questions:{next:{type:'choice',instructions:INSTRUCTION,criteria}}}]};
+      const then=performance.now();const response=await fetch(endpoint+'/api/evaluate',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(request),signal:AbortSignal.timeout(60000)});const result=await response.json();
+      if(!response.ok)throw Error(`NanoJev inference HTTP ${response.status}: ${result.error}`);
+      const answer=result.states[0].answers.next;const identity=result.checkpoint.id;
+      if(modelIdentity&&modelIdentity!==identity)throw Error('Model changed mid-run');modelIdentity=identity;
+      const a=answer.choice.startsWith('a')?observation.actions[Number(answer.choice.slice(1))]:null;
+      if(!a&&!Object.hasOwn(SPECIALS,answer.choice))throw Error('Invalid choice');
+      const row={step:step+1,request,answer,execution:result.execution,apiMs:performance.now()-then,action:a??answer.choice,before:observation.dom,executed:false};trace.push(row);
+      const fresh=await browser.observe(task);
+      if(fresh.signature!==observation.signature){row.skipped='stale_observation';continue;}
+      if(answer.choice==='DONE'){status=fresh.s.success?'completed':'premature_done';break;}
+      if(answer.choice==='BLOCKED'){status='model_blocked';break;}
+      const key=hash([fresh.s,a?.op??answer.choice,a?.selector,a?.current,a?.viewport]);repeats=key===last?repeats+1:0;last=key;
+      visits.set(key,(visits.get(key)??0)+1);
+      if(answer.choice!=='WAIT'&&visits.get(key)>3){status='action_cycle';break;}
+      if(answer.choice!=='WAIT'&&repeats>=2){status='no_progress';break;}
+      if(answer.choice==='WAIT')await browser.command(['wait','--fn',`![...document.querySelectorAll(${JSON.stringify(task.busySelector??'[aria-busy="true"]')})].some(e=>e.getClientRects().length&&getComputedStyle(e).visibility!=='hidden')`]);
+      else await browser.act(a);
+      row.executed=true;console.log(JSON.stringify({run:task.name,step:step+1,choice:answer.choice,op:a?.op??'WAIT',label:a?.label,probability:answer.probabilities[answer.choice]}));
+    }
+  }catch(e){status='error';error=String(e.message);}
+  const elapsedMs=performance.now()-start;let final=null,screenshot=null,evidenceError=null;
+  try{final=(await browser.observe(task)).dom;screenshot=resolve(outDir,task.name+'.png');await browser.command(['screenshot','--full',screenshot]);}
+  catch(e){evidenceError=String(e.message);screenshot=null;if(status==='completed'){status='error';error='Could not verify final browser state: '+evidenceError;}}
+  const report={name:task.name,session,status,error,evidenceError,modelIdentity,runnerSha256,elapsedMs,browserCalls:browser.calls,browserMs:browser.ms,agentBrowserStreamKeyboardEvents:browser.streamKeyboardEvents??0,taskHash:hash(task),trace,final,screenshot};
+  await writeFile(resolve(outDir,task.name+'.json'),JSON.stringify(report,null,2));console.log(JSON.stringify({finished:task.name,status,error,steps:trace.length,elapsedMs}));return {report,browser};
+}

scripts/check-install.py

@@ -0,0 +1,15 @@
+"""Check the local runtime without loading a second model."""
+from pathlib import Path
+import hashlib,json,platform,subprocess
+import torch,transformers,safetensors
+ROOT=Path(__file__).resolve().parents[1]
+assert platform.system()=='Darwin' and platform.machine()=='arm64','Native Apple Silicon Python required'
+assert torch.backends.mps.is_available(),'PyTorch MPS is unavailable'
+expected='0a93cfcf7121112fdf90336bda1198ad67a3bb45247da6eedf0dd8672d4d53b5'
+h=hashlib.sha256()
+with (ROOT/'model/best.safetensors').open('rb') as f:
+    for block in iter(lambda:f.read(8*1024*1024),b''):h.update(block)
+assert h.hexdigest()==expected,'Model checksum mismatch'
+browser=subprocess.check_output([str(ROOT/'node_modules/.bin/agent-browser'),'--version'],text=True).strip()
+assert browser=='agent-browser 0.37.1',browser
+print(json.dumps({'passed':True,'platform':platform.platform(),'torch':torch.__version__,'transformers':transformers.__version__,'safetensors':safetensors.__version__,'agent_browser':browser,'modelSha256':expected},indent=2))

scripts/common.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -euo pipefail
+nanojev_root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
+nanojev_saved_node=""
+if [[ -f "$nanojev_root/.runtime/node-path" ]]; then
+  IFS= read -r nanojev_saved_node < "$nanojev_root/.runtime/node-path" || true
+  [[ -x "$nanojev_saved_node" ]] || nanojev_saved_node=""
+fi
+nanojev_node="${NANOJEV_NODE_BIN:-${nanojev_saved_node:-$(command -v node || true)}}"
+if [[ -z "$nanojev_node" ]] || ! "$nanojev_node" -e 'process.exit(Number(process.versions.node.split(".")[0])>=24?0:1)' 2>/dev/null; then
+  printf '%s\n' 'Node.js 24+ required. Install Node 24 or set NANOJEV_NODE_BIN to its executable.' >&2
+  exit 1
+fi
+export PATH="$(dirname -- "$nanojev_node"):$nanojev_root/node_modules/.bin:$PATH"
+export NANOJEV_AGENT_BROWSER_BIN="${NANOJEV_AGENT_BROWSER_BIN:-$nanojev_root/node_modules/.bin/agent-browser}"

scripts/publish.py

@@ -0,0 +1,20 @@
+"""Prepare an allowlisted Hugging Face upload; no network writes without --publish."""
+import argparse,json,re
+from pathlib import Path
+from release import ROOT,verify
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--repo-id',help='Your Hugging Face namespace/NanoJev-Web')
+    p.add_argument('--publish',action='store_true',help='Create a PUBLIC repository and upload the verified files')
+    p.add_argument('--update-existing',action='store_true',help='Explicitly allow adding/replacing these files in an existing repository')
+    a=p.parse_args();m=verify();paths=sorted([*m['files'],'MANIFEST.json'])
+    if a.repo_id and not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_.-]*/[A-Za-z0-9][A-Za-z0-9_.-]*',a.repo_id):p.error('Expected namespace/repository')
+    print(json.dumps({'mode':'publish' if a.publish else 'dry-run','repo_id':a.repo_id,'public':True,'files':len(paths),'bytes':sum((ROOT/x).stat().st_size for x in paths),'local_runtime_and_runs_excluded':True}))
+    if not a.publish:return
+    if not a.repo_id:p.error('--repo-id is required for publishing')
+    from huggingface_hub import HfApi,CommitOperationAdd
+    api=HfApi();api.create_repo(repo_id=a.repo_id,repo_type='model',private=False,exist_ok=a.update_existing)
+    commit=api.create_commit(repo_id=a.repo_id,repo_type='model',commit_message='Release NanoJev-Web browser action model',operations=[CommitOperationAdd(path_in_repo=name,path_or_fileobj=str(ROOT/name)) for name in paths])
+    print(commit.commit_url)
+if __name__=='__main__':main()

scripts/release.py

@@ -0,0 +1,37 @@
+"""Verify or export the exact public files listed in MANIFEST.json."""
+import argparse,gzip,hashlib,json,tarfile
+from pathlib import Path
+ROOT=Path(__file__).resolve().parents[1]
+FORBIDDEN={'.local','.runtime','.venv','node_modules','__pycache__','.git','runs','bench'}
+def digest(path):
+    h=hashlib.sha256()
+    with path.open('rb') as f:
+        for block in iter(lambda:f.read(8*1024*1024),b''):h.update(block)
+    return h.hexdigest()
+def verify():
+    manifest=json.loads((ROOT/'MANIFEST.json').read_text())
+    for name,info in manifest['files'].items():
+        p=Path(name)
+        if name=='bench.command' or p.is_absolute() or '..' in p.parts or set(p.parts)&FORBIDDEN or any(x.startswith('.env') for x in p.parts):raise ValueError('Forbidden manifest path')
+        file=ROOT/p
+        if file.is_symlink() or not file.is_file() or ROOT not in file.resolve().parents:raise ValueError('Release file missing or not a regular contained file')
+        if file.stat().st_size!=info['bytes'] or digest(file)!=info['sha256']:raise ValueError('Release checksum mismatch: '+name)
+    return manifest
+
+def export(path,manifest):
+    path=path.resolve()
+    if path==ROOT or ROOT in path.parents:raise ValueError('Export outside the release directory')
+    path.parent.mkdir(parents=True,exist_ok=True)
+    if path.exists():raise ValueError('Output already exists; choose a new filename')
+    with path.open('xb') as raw,gzip.GzipFile(filename='',fileobj=raw,mode='wb',mtime=0,compresslevel=6) as gz,tarfile.open(fileobj=gz,mode='w') as archive:
+        for name in sorted([*manifest['files'],'MANIFEST.json']):
+            file=ROOT/name;info=tarfile.TarInfo('NanoJev-Web/'+name)
+            info.size=file.stat().st_size;info.mode=0o755 if name.endswith('.command') or name.endswith('.sh') else 0o644
+            info.uid=info.gid=0;info.uname=info.gname='';info.mtime=0
+            with file.open('rb') as src:archive.addfile(info,src)
+    checksum=digest(path);path.with_suffix(path.suffix+'.sha256').write_text(checksum+'  '+path.name+'\n')
+    print(json.dumps({'archive':path.name,'bytes':path.stat().st_size,'sha256':checksum}))
+if __name__=='__main__':
+    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--export',type=Path);a=p.parse_args();m=verify()
+    print(json.dumps({'verified':True,'files':len(m['files']),'bytes':sum(i['bytes'] for i in m['files'].values())}))
+    if a.export:export(a.export,m)

setup.command

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -euo pipefail
+cd -- "$(dirname -- "$0")"
+source scripts/common.sh
+if [[ "$(uname -s)" != Darwin || "$(uname -m)" != arm64 ]]; then
+  printf '%s\n' 'This installer targets native macOS Apple Silicon. Use an ARM terminal, without Rosetta.' >&2
+  exit 1
+fi
+nanojev_macos_version="$(sw_vers -productVersion)"
+if (( ${nanojev_macos_version%%.*} < 14 )); then
+  printf '%s\n' 'macOS 14 or newer is required by the pinned PyTorch build.' >&2
+  exit 1
+fi
+if ! command -v uv >/dev/null; then
+  printf '%s\n' 'Install uv first (for example: brew install uv), then run setup.command again.' >&2
+  exit 1
+fi
+command -v npm >/dev/null || { printf '%s\n' 'npm is required; install Node.js with npm.' >&2; exit 1; }
+export UV_PYTHON_INSTALL_DIR="$nanojev_root/.runtime/python"
+export UV_CACHE_DIR="${NANOJEV_UV_CACHE:-$nanojev_root/.runtime/cache}"
+uv python install 3.12.13 --no-bin
+uv venv --clear --managed-python --python 3.12.13 "$nanojev_root/.venv"
+uv pip sync --python "$nanojev_root/.venv/bin/python" "$nanojev_root/requirements-lock.txt"
+if [[ -f package-lock.json ]]; then npm ci --no-audit --no-fund; else npm install --no-audit --no-fund; fi
+"$nanojev_root/node_modules/.bin/agent-browser" install
+"$nanojev_root/.venv/bin/python" "$nanojev_root/scripts/check-install.py"
+printf '%s\n' "$nanojev_node" > "$nanojev_root/.runtime/node-path"
+printf '%s\n' 'Ready. Start the model with ./start.command. To execute your page contract, run ./run.command --task your-task.json.'

start.command

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+nanojev_root="$(cd -- "$(dirname -- "$0")" && pwd)"
+nanojev_python="$nanojev_root/.venv/bin/python"
+[[ -x "$nanojev_python" ]] || { printf '%s\n' 'Run setup.command first.' >&2; exit 1; }
+exec "$nanojev_python" -u "$nanojev_root/python/server.py" "$@"

test.command

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+cd -- "$(dirname -- "$0")"
+export PYTHONDONTWRITEBYTECODE=1
+.venv/bin/python -m unittest discover -s tests -p test_contract.py
+.venv/bin/python scripts/release.py

tests/parity.py

@@ -0,0 +1,22 @@
+"""Compare the extracted model to frozen decisions from the original v5 server."""
+from pathlib import Path
+import argparse,json,urllib.request
+ROOT=Path(__file__).resolve().parents[1]
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--endpoint',default='http://127.0.0.1:8774');p.add_argument('--out',type=Path,default=ROOT/'.local/parity.json');a=p.parse_args()
+    reference=json.loads((ROOT/'tests/reference-decisions.json').read_text());results=[]
+    for case in reference['cases']:
+        r=json.load(urllib.request.urlopen(urllib.request.Request(a.endpoint+'/api/evaluate',json.dumps(case['request']).encode(),{'Content-Type':'application/json'}),timeout=60))
+        diffs=[];choices=[]
+        for expected,actual in zip(case['expected'],r['states'],strict=True):
+            assert expected['id']==actual['id']
+            for qid,e in expected['answers'].items():
+                found=actual['answers'][qid];assert set(e['probabilities'])==set(found['probabilities'])
+                diffs.extend(abs(v-found['probabilities'][k]) for k,v in e['probabilities'].items());choices.append(e['choice']==found['choice'])
+        delta=max(diffs);passed=delta<=1e-4 and all(choices)
+        results.append({'case':case['case'],'maxProbabilityDifference':delta,'sameChoices':all(choices),'passed':passed})
+        print(json.dumps(results[-1]),flush=True)
+    out={'passed':all(x['passed'] for x in results),'cases':results,'tolerance':1e-4}
+    a.out.parent.mkdir(parents=True,exist_ok=True);a.out.write_text(json.dumps(out,indent=2)+'\n')
+    if not out['passed']:raise SystemExit(1)
+if __name__=='__main__':main()