Update v1.1 publications and Vons branding

.gitattributes

@@ -8,5 +8,5 @@
 *.cff text eol=lf
 *.pdf binary
 *.png binary
-docs/publications/vons-paper-v1.0.pdf filter=lfs diff=lfs merge=lfs -text
-docs/publications/vons-tech-report-v1.0.1.pdf filter=lfs diff=lfs merge=lfs -text
+docs/publications/vons-paper-v1.1.pdf filter=lfs diff=lfs merge=lfs -text
+docs/publications/vons-tech-report-v1.1.pdf filter=lfs diff=lfs merge=lfs -text

.github/workflows/checks.yml

@@ -9,6 +9,8 @@ on:
       - 'tests/**'
       - 'configs/**'
       - 'sdk/**'
+      - 'docs/assets/inlevel9-signature.png'
+      - 'docs/assets/vons-extension-icon-*.png'
       - 'pyproject.toml'
       - '.gitignore'
   pull_request:
@@ -19,6 +21,8 @@ on:
       - 'tests/**'
       - 'configs/**'
       - 'sdk/**'
+      - 'docs/assets/inlevel9-signature.png'
+      - 'docs/assets/vons-extension-icon-*.png'
       - 'pyproject.toml'
       - '.gitignore'
   workflow_dispatch:
@@ -59,3 +63,5 @@ jobs:
       - run: npm run build:browser
       - run: npm run build:benchmark
       - run: npm run build:parity
+      - run: npm run typecheck:extension
+      - run: npm run build:extension

.gitignore

@@ -31,12 +31,21 @@
 !/docs/publications/README.md
 !/docs/publications/LICENSE.md
 !/docs/publications/ARXIV.md
+!/docs/publications/vons-paper-v1.1.pdf
+!/docs/publications/vons-tech-report-v1.1.pdf
 /docs/assets/*
 !/docs/assets/inlevel9-signature.png
 !/docs/assets/inlevel9-signature-dark.png
+!/docs/assets/vons-logo.png
+!/docs/assets/vons-extension-icon-16.png
+!/docs/assets/vons-extension-icon-32.png
+!/docs/assets/vons-extension-icon-48.png
+!/docs/assets/vons-extension-icon-128.png
 /configs/*
 !/configs/pilot.json
 !/configs/pilot-diffusion.json
+!/configs/pilot-v2-direct.json
+!/configs/pilot-v2-diffusion.json
 !/configs/public-release.json
 /sdk/*
 !/sdk/typescript/
@@ -48,6 +57,7 @@
 !/sdk/typescript/src/
 !/sdk/typescript/test/
 !/sdk/typescript/demo/
+!/sdk/typescript/extension/
 
 # Raw/generated data, weights, evidence packets and local publications.
 data/
@@ -89,6 +99,8 @@ restricted/
 # Only the exact reviewed publication bytes are eligible for staging.
 !/docs/publications/vons-paper-v1.0.pdf
 !/docs/publications/vons-tech-report-v1.0.1.pdf
+!/docs/publications/vons-paper-v1.1.pdf
+!/docs/publications/vons-tech-report-v1.1.pdf
 
 # Credentials, machine-specific config, private prompts and service caches.
 .env

README.md

@@ -11,6 +11,8 @@ tags:
   - onnx
 ---
 
+![Vons](docs/assets/vons-logo.png)
+
 ![INLEVEL9](docs/assets/inlevel9-signature.png)
 
 # Vons
@@ -57,17 +59,23 @@ an organization card, source preview and later a separately validated Space.
 
 | Publication | Download |
 | --- | --- |
-| Vons: A Compact, Host-Controlled Decision Component for Agent Workflows — paper v1.0, final editorial revision | [PDF · 15 pages](docs/publications/vons-paper-v1.0.pdf) |
-| Vons: Compact Decision Models for Frontier-Agent Workflows — Technical Report v1.0.1 | [PDF · 20 pages](docs/publications/vons-tech-report-v1.0.1.pdf) |
+| Vons: A Compact, Host-Controlled Decision Component for Agent Workflows — Preprint v1.1 | [PDF · 21 pages](docs/publications/vons-paper-v1.1.pdf) |
+| Vons: Compact Decision Models for Frontier-Agent Workflows — Technical Report v1.1 | [PDF · 29 pages](docs/publications/vons-tech-report-v1.1.pdf) |
 
 Articles and original figures use **CC BY 4.0**. Their version, SHA-256 digests
 and verification scope are in the [publication index](docs/publications/README.md).
-These preprints preserve negative results and missing measurements. The paper
-was submitted to arXiv under **submission number 8127259**; the last checked
-status on **2026-09-25** is **on hold** (undergoing checks). This tracking number
-is not a public arXiv article identifier. No announcement or peer-review
+These preprints preserve negative results, missing measurements and the boundary
+between frozen v1 evidence and the separately labelled post-freeze v2 handoff.
+The paper was submitted to arXiv under **submission number 8127259**; the last
+checked status on **2026-09-25** is **on hold** (undergoing checks). This tracking
+number is not a public arXiv article identifier. No announcement or peer-review
 acceptance is claimed.
 
+Chrome Web Store version **0.1.0** passed review and is publicly available as
+[Vons — Local Decisions](https://chromewebstore.google.com/detail/vons-%E2%80%94-local-decisions/cbmjkokoojinfgafahncmjlfmicinide),
+verified on 2026-09-25. Store availability is not evidence of model quality,
+scientific validity or production readiness.
+
 ## Local use
 
 ```sh

configs/pilot-v2-diffusion.json

@@ -0,0 +1,28 @@
+{
+  "model_id": "vons-pilot-v2-diffusion",
+  "backend": "diffusion",
+  "option_count": 32,
+  "encoder": {
+    "name": "google/bert_uncased_L-4_H-256_A-4",
+    "revision": "387825ce42dbb39b87911cdf8e383ee3b25184f8",
+    "max_tokens": 512
+  },
+  "data": {
+    "path": "data/generated/pilot-v2.jsonl",
+    "manifest": "data/generated/pilot-v2.manifest.json"
+  },
+  "seed": 7,
+  "epochs": 12,
+  "batch_size": 32,
+  "learning_rate": 0.001,
+  "latent_size": 64,
+  "attention_heads": 4,
+  "diffusion_conditioning": "token_cross_attention",
+  "noise_schedule": "cosine",
+  "diffusion_steps": 64,
+  "inference_steps": 8,
+  "soft_target_smoothing": 0.1,
+  "device": "auto",
+  "artifact_dir": "artifacts/pilot-v2-diffusion",
+  "target_bundle_bytes": 67108864
+}

configs/pilot-v2-direct.json

@@ -0,0 +1,21 @@
+{
+  "model_id": "vons-pilot-v2-direct",
+  "backend": "direct",
+  "option_count": 32,
+  "encoder": {
+    "name": "google/bert_uncased_L-4_H-256_A-4",
+    "revision": "387825ce42dbb39b87911cdf8e383ee3b25184f8",
+    "max_tokens": 512
+  },
+  "data": {
+    "path": "data/generated/pilot-v2.jsonl",
+    "manifest": "data/generated/pilot-v2.manifest.json"
+  },
+  "seed": 7,
+  "epochs": 6,
+  "batch_size": 32,
+  "learning_rate": 0.001,
+  "device": "auto",
+  "artifact_dir": "artifacts/pilot-v2-direct",
+  "target_bundle_bytes": 67108864
+}

configs/public-release.json

@@ -15,6 +15,8 @@
     "README.md",
     "configs/pilot-diffusion.json",
     "configs/pilot.json",
+    "configs/pilot-v2-diffusion.json",
+    "configs/pilot-v2-direct.json",
     "configs/public-release.json",
     "docs/COMMUNITY.md",
     "docs/HUB_PUBLISHING.md",
@@ -25,11 +27,18 @@
     "docs/PUBLIC_RELEASE.md",
     "docs/assets/inlevel9-signature-dark.png",
     "docs/assets/inlevel9-signature.png",
+    "docs/assets/vons-logo.png",
+    "docs/assets/vons-extension-icon-128.png",
+    "docs/assets/vons-extension-icon-16.png",
+    "docs/assets/vons-extension-icon-32.png",
+    "docs/assets/vons-extension-icon-48.png",
     "docs/publications/ARXIV.md",
     "docs/publications/LICENSE.md",
     "docs/publications/README.md",
     "docs/publications/vons-paper-v1.0.pdf",
+    "docs/publications/vons-paper-v1.1.pdf",
     "docs/publications/vons-tech-report-v1.0.1.pdf",
+    "docs/publications/vons-tech-report-v1.1.pdf",
     "pyproject.toml",
     "sdk/typescript/LICENSE",
     "sdk/typescript/README.md",
@@ -39,10 +48,25 @@
     "sdk/typescript/demo/main.ts",
     "sdk/typescript/demo/parity.html",
     "sdk/typescript/demo/parity.ts",
+    "sdk/typescript/extension/ONNX_RUNTIME_NOTICES.md",
+    "sdk/typescript/extension/PRIVACY.md",
+    "sdk/typescript/extension/README.md",
+    "sdk/typescript/extension/background.mjs",
+    "sdk/typescript/extension/build.mjs",
+    "sdk/typescript/extension/bundle.ts",
+    "sdk/typescript/extension/manifest.json",
+    "sdk/typescript/extension/panel.css",
+    "sdk/typescript/extension/panel.html",
+    "sdk/typescript/extension/panel.ts",
+    "sdk/typescript/extension/privacy.html",
+    "sdk/typescript/extension/storage.ts",
+    "sdk/typescript/extension/tsconfig.json",
+    "sdk/typescript/extension/worker.ts",
     "sdk/typescript/package-lock.json",
     "sdk/typescript/package.json",
     "sdk/typescript/src/index.ts",
     "sdk/typescript/src/onnx.ts",
+    "sdk/typescript/test/extension.test.mjs",
     "sdk/typescript/test/index.test.mjs",
     "sdk/typescript/test/onnx.test.mjs",
     "sdk/typescript/test/parity.test.mjs",
@@ -53,14 +77,18 @@
     "tests/test_calibration.py",
     "tests/test_contract.py",
     "tests/test_data.py",
+    "tests/test_diffusion_model.py",
     "tests/test_evaluation.py",
+    "tests/test_inference.py",
     "tests/test_merge_browser_benchmarks.py",
     "tests/test_mind2web.py",
+    "tests/test_mind2web_adapter.py",
     "tests/test_mind2web_import.py",
     "tests/test_mind2web_manifest.py",
     "tests/test_mind2web_prediction.py",
     "tests/test_mind2web_replay.py",
     "tests/test_mind2web_runner.py",
+    "tests/test_onnx_export.py",
     "tests/test_public_release.py",
     "tests/test_quality_summary.py",
     "tests/test_regression.py",
@@ -76,6 +104,7 @@
     "tools/export_shared_bundle.py",
     "tools/freeze_publication_packet.py",
     "tools/import_mind2web.py",
+    "tools/index_mind2web_predictions.py",
     "tools/merge_browser_benchmarks.py",
     "tools/predict_mind2web.py",
     "tools/prepare_public_release.py",
@@ -93,8 +122,10 @@
     "vons/contract.py",
     "vons/data.py",
     "vons/evaluation.py",
+    "vons/inference.py",
     "vons/kasi.py",
     "vons/mind2web.py",
+    "vons/mind2web_adapter.py",
     "vons/models.py",
     "vons/ollama.py",
     "vons/research.py",
@@ -103,8 +134,15 @@
   "reviewed_binaries": {
     "docs/assets/inlevel9-signature.png": "f7514b56b2a93293054b3d22634ac5f0cb11e00a370f53d8d9f934c55a21bbb5",
     "docs/assets/inlevel9-signature-dark.png": "d6645528158842af77a89de97361fa0c521fbc5a3c0ea6e996f9c912cfcfe9b5",
+    "docs/assets/vons-logo.png": "1f557be52834662b480d16048b82ad8b03805af6aa1466f1b2d5add85ed74a5e",
     "docs/publications/vons-paper-v1.0.pdf": "ae0e09c60e17a98b52bb25c611b2489d10b18bd98d87974f2e8dd25d746a5fc8",
-    "docs/publications/vons-tech-report-v1.0.1.pdf": "33076d9e52d4a073060066215dd390e3b0bf0cdef48c5ffb2a7c5189854254ed"
+    "docs/publications/vons-paper-v1.1.pdf": "8e9ff7d768979411db2333f37111692b5b8426bdaec21d35954c7038d047f321",
+    "docs/publications/vons-tech-report-v1.0.1.pdf": "33076d9e52d4a073060066215dd390e3b0bf0cdef48c5ffb2a7c5189854254ed",
+    "docs/publications/vons-tech-report-v1.1.pdf": "9e6aff46a271324f82db594155ea6b3a7c51c5cfe9b192e52f2b38d92ca84af3",
+    "docs/assets/vons-extension-icon-16.png": "1a8d94bade23fed4e84c3ecca64f2904a575f1543981250f0896a17ecc88ffee",
+    "docs/assets/vons-extension-icon-32.png": "cc32b367c60bdcfd0b07a8b1b8771cfc064ffd45a3a35dfc764136bc05cb97c4",
+    "docs/assets/vons-extension-icon-48.png": "7ca6d66a7548ff8a8c42bf6bc4e0b123e2bca8abf3ba8366bab6690d9b44f101",
+    "docs/assets/vons-extension-icon-128.png": "6195919e1368d1695c3346097b216b38f170099080d53c014cc2a4162a7f25d6"
   },
   "software_license": "LicenseRef-Vons-Community-Commercial-1.0",
   "article_license": "CC-BY-4.0"

docs/COMMUNITY.md

@@ -10,7 +10,7 @@ report what works or fails.
 | Your goal | Entry point | Current availability |
 | --- | --- | --- |
 | Understand Vons | [README](../README.md) and [model card](MODEL_CARD.md) | Included in this source preview |
-| Read the research | [Paper and Tech Report](publications/README.md) | Coming soon; v1.0 manuscripts are in preparation and excluded from this release |
+| Read the research | [Paper and Tech Report](publications/README.md) | Reviewed PDFs and exact verification scope are included |
 | Try without weights | The walkthrough below | Deterministic contract and synthetic data only |
 | Run model inference | [TypeScript SDK](../sdk/typescript/README.md) | Requires separately obtained, reviewed model/tokenizer assets |
 | Share experience | [Experience report](https://github.com/inlevel9-com/Vons/issues/new?template=experience.yml) | GitHub account required to submit |
@@ -20,8 +20,9 @@ report what works or fails.
 The destinations are [GitHub: inlevel9-com/Vons](https://github.com/inlevel9-com/Vons)
 and [Hugging Face: INLEVEL9/Vons](https://huggingface.co/INLEVEL9/Vons).
 The source preview includes documentation and GitHub issue forms for feedback.
-The paper and Tech Report will be added after v1.0 review; this release contains
-neither manuscript. A source upload does not provide hosted model inference.
+The paper and Tech Report are included as versioned PDFs; their index preserves
+exact hashes, evidence boundaries and arXiv status. A source upload does not
+provide hosted model inference.
 The current software terms require a separate agreement for
 enterprise/commercial use, including enterprise evaluation. Reading the paper
 under its article terms is separate from software use.

docs/HUB_PUBLISHING.md

@@ -1,9 +1,10 @@
 # Upload the Vons source preview to Hugging Face
 
-This guide covers the completed upload and future owner-operated updates. The
-initial upload contains 97 reviewed files, including the final paper and Tech Report PDFs. Drafts,
-source manuscript bundles, model weights, restricted data and private records
-are excluded.
+This guide covers the completed initial upload and subsequent reviewed updates.
+The current v1.1 snapshot contains 128 reviewed files, including the source,
+extension source, Vons logo, current Paper and Tech Report PDFs and their
+historical reviewed versions. Drafts, source manuscript bundles, model weights,
+restricted data and private records are excluded.
 
 ## Destination and scope
 
@@ -20,6 +21,13 @@ public model card now uses the Vons Community and Commercial License 1.0.
 The article CC BY 4.0 terms are separate. A later documentation update records
 the arXiv submission status without adding models or draft material.
 
+The reviewed v1.1 update uses the local snapshot
+`releases/huggingface-source-v13`. It adds the 21-page Preprint v1.1, the 29-page
+Technical Report v1.1, post-freeze implementation source and tests, Chrome
+extension source and the owner-supplied Vons logo. It does not add manuscript
+source bundles, claim ledgers, model weights, tokenizer assets or benchmark
+data.
+
 A commit to this public repository makes uploaded files publicly readable.
 Uploading source does not create hosted inference, pretrained weights or a
 working `from_pretrained` package. The card states those limits explicitly.
@@ -57,10 +65,11 @@ Run the source audit from the Vons checkout:
 python3 tools/prepare_public_release.py
 ```
 
-The initial uploaded snapshot is `releases/huggingface-source-v8`.
-It contains the 97 reviewed files plus a local `RELEASE_MANIFEST.json` receipt
-with every file's byte count and SHA-256 digest. Its root README is the Hub model
-card; the working-tree README remains the GitHub landing page.
+The initial uploaded snapshot is `releases/huggingface-source-v8`. The current
+v1.1 snapshot is `releases/huggingface-source-v13`; it contains 128 reviewed
+files plus a local `RELEASE_MANIFEST.json` receipt with every file's byte count
+and SHA-256 digest. Its root README is the Hub model card; the working-tree
+README remains the GitHub landing page.
 
 This export is a snapshot. If you edit any public source or documentation after
 preparation, create a fresh versioned directory and use that path below:
@@ -105,19 +114,19 @@ Open [the model card](https://huggingface.co/INLEVEL9/Vons) and
   It must no longer identify the software as Apache-2.0 or CC BY 4.0.
 - Root `LICENSE` and `sdk/typescript/LICENSE` contain the same custom terms.
 - Source paths such as `vons/`, `tools/`, `tests/` and `sdk/typescript/` are present.
-- The Paper and Tech Report links open the 15-page paper and 20-page report.
+- The Paper and Tech Report links open the 21-page v1.1 paper and 29-page v1.1 report.
   Their digests match the publication index. No manuscript source bundle or
   private review material is uploaded.
-- Logo/documentation links resolve, and a signed-out visitor can read the card.
+- The Vons and INLEVEL9 logo links resolve, and a signed-out visitor can read the card.
 
 Save the resulting Hub commit URL with the local release manifest. GitHub
 publication, manuscript publication and a hosted demo are separate actions.
 For subsequent source changes, create a new reviewed export and repeat the same
 upload command with its new path. Add research files only after their separate
-v1.0 review and an explicit public-allowlist update.
+review and an explicit public-allowlist update.
 
 The initial Hub upload and publication-document update were owner-authorized.
-GitHub commits, pushes and visibility changes remain owner-operated. Local
-Chrome extension source and packages are prepared separately; the initial
-97-file Hub upload does not include the extension.
+GitHub commits, pushes and visibility changes remain owner-operated. The v1.1
+Hub source update includes reviewed extension source, but generated extension
+packages and imported local models remain excluded.
 Official CLI/upload guidance checked 2026-09-25.

docs/HUGGING_FACE.md

@@ -11,6 +11,8 @@ tags:
   - onnx
 ---
 
+![Vons](../docs/assets/vons-logo.png)
+
 ![INLEVEL9](../docs/assets/inlevel9-signature.png)
 
 # Vons
@@ -57,17 +59,23 @@ an organization card, source preview and later a separately validated Space.
 
 | Publication | Download |
 | --- | --- |
-| Vons: A Compact, Host-Controlled Decision Component for Agent Workflows — paper v1.0, final editorial revision | [PDF · 15 pages](../docs/publications/vons-paper-v1.0.pdf) |
-| Vons: Compact Decision Models for Frontier-Agent Workflows — Technical Report v1.0.1 | [PDF · 20 pages](../docs/publications/vons-tech-report-v1.0.1.pdf) |
+| Vons: A Compact, Host-Controlled Decision Component for Agent Workflows — Preprint v1.1 | [PDF · 21 pages](../docs/publications/vons-paper-v1.1.pdf) |
+| Vons: Compact Decision Models for Frontier-Agent Workflows — Technical Report v1.1 | [PDF · 29 pages](../docs/publications/vons-tech-report-v1.1.pdf) |
 
 Articles and original figures use **CC BY 4.0**. Their version, SHA-256 digests
 and verification scope are in the [publication index](../docs/publications/README.md).
-These preprints preserve negative results and missing measurements. The paper
-was submitted to arXiv under **submission number 8127259**; the last checked
-status on **2026-09-25** is **on hold** (undergoing checks). This tracking number
-is not a public arXiv article identifier. No announcement or peer-review
+These preprints preserve negative results, missing measurements and the boundary
+between frozen v1 evidence and the separately labelled post-freeze v2 handoff.
+The paper was submitted to arXiv under **submission number 8127259**; the last
+checked status on **2026-09-25** is **on hold** (undergoing checks). This tracking
+number is not a public arXiv article identifier. No announcement or peer-review
 acceptance is claimed.
 
+Chrome Web Store version **0.1.0** passed review and is publicly available as
+[Vons — Local Decisions](https://chromewebstore.google.com/detail/vons-%E2%80%94-local-decisions/cbmjkokoojinfgafahncmjlfmicinide),
+verified on 2026-09-25. Store availability is not evidence of model quality,
+scientific validity or production readiness.
+
 ## Local use
 
 ```sh

docs/MODEL_CARD.md

@@ -22,15 +22,21 @@ Runtime libraries, complete download size and memory use are distinct quantities
 ## Evaluation and limitations
 
 Historical local experiments include synthetic pilots and an evaluation-only
-external benchmark diagnostic. They do not establish general task quality,
-production readiness, calibrated safety or a Direct/Diffusion superiority claim.
-Reviewed numerical claims belong to the versioned
+external benchmark diagnostic. A separately labelled post-freeze v2 handoff
+records dynamic per-request padding, balanced four-class synthetic runs,
+vector-scaling calibration, a token-conditioned Diffusion head and label-free
+Mind2Web context compression. Those bounded synthetic, local-CPU and
+conditional-selection results do not establish general task quality, production
+readiness, calibrated safety or a Direct/Diffusion superiority claim. Reviewed
+numerical claims belong to the versioned
 [paper and Tech Report](publications/README.md), with exact evidence references.
 Unreviewed historical tables are not distributed as current results.
 
 The ONNX candidate head does not support general score questions. Python and
-TypeScript token-budget checks are not fully identical. Browser smoke, repeated
-latency, full numerical parity and memory evidence remain separate gates.
+TypeScript now both pad to the longest live tokenized candidate within the
+manifest budget, but their broader public contract semantics are not claimed to
+be identical. Browser smoke, local CPU timing, graph-partition parity and memory
+evidence remain separate checks.
 
 Do not use model confidence as a permission grant or assume it is calibrated.
 Vons cannot execute tools or approve high-risk actions.

docs/PUBLIC_RELEASE.md

@@ -8,7 +8,7 @@ tool independently rejects any Git candidate outside that exact file list.
 
 Included: Python and TypeScript source, tests, source demo files, the SDK
 dependency lockfile, pilot configuration, reviewed public documentation and the
-owner-supplied INLEVEL9 logo. Reviewed publications are listed separately in
+owner-supplied Vons and INLEVEL9 logos. Reviewed publications are listed separately in
 `docs/publications/README.md`.
 
 Excluded: all local datasets (including synthetic outputs), model weights,
@@ -32,8 +32,8 @@ Each export is a new directory containing only allowlisted files and a
 `RELEASE_MANIFEST.json` with byte counts and SHA-256 hashes. Existing output
 directories are never overwritten. Use a new versioned output path after any
 source change. The Hugging Face export substitutes its model card as the root
-README. Both exports contain source and the two exact reviewed publication PDFs, with
-no pretrained assets.
+README. Both exports contain source, the current v1.1 Paper and Tech Report and
+their two reviewed historical PDFs, with no pretrained assets.
 
 The audit detects known token/key patterns, personal home paths, private writing
 session URLs, unexpected Git files, symlinks and changed reviewed binaries.
@@ -49,8 +49,8 @@ remove already committed material from history. If existing remote history is
 later attached, review that history independently before making it public.
 
 The CI workflow checks the release allowlist, Python tests and lint, and the SDK
-tests and three browser builds. Push/pull-request checks run when source,
-tests, configuration or the workflow changes; documentation-only edits do not
+tests, three browser builds, and extension type checking/building. Push/pull-request checks run when source,
+tests, configuration, packaged extension images or the workflow changes; documentation-only edits do not
 trigger the full suite. A manual run remains available. SDK tokenizer tests use
 synthetic fixtures and require no private pilot assets. It has read-only repository permissions and
 does not publish packages or artifacts. Checks that require unavailable optional
@@ -62,11 +62,21 @@ those files; do not publish the historical inputs merely to remove that skip.
 ## Hugging Face
 
 Upload only a reviewed versioned Hugging Face export to `INLEVEL9/Vons`.
-The current preparation is `releases/huggingface-source-v8`; see the
+The initial verified upload used `releases/huggingface-source-v8`. The reviewed
+v1.1 update is prepared as `releases/huggingface-source-v13`; see the
 [step-by-step upload guide](HUB_PUBLISHING.md). Do not select the development workspace in the
 Hub upload dialog. Use explicit allow/ignore patterns if using `upload_folder`;
 its handling of ignore files depends on the client version and upload method.
 
+The current checkout also includes the [Chrome extension source](../sdk/typescript/extension/README.md),
+which was not part of that initial 97-file upload but is included in the v1.1
+source update. Generated extension packages remain local and
+ignored; distribute only their reviewed contents, with dependency notices and
+without imported models or prompts. Chrome Web Store version 0.1.0 was submitted
+on 2026-09-25, passed review and had its public listing independently read back
+the same day: [Vons — Local Decisions](https://chromewebstore.google.com/detail/vons-%E2%80%94-local-decisions/cbmjkokoojinfgafahncmjlfmicinide).
+That listing does not establish model quality or production readiness.
+
 This source preview has no weights and no inference widget. A later weight
 release needs its own exact file inventory, upstream notices, model/data
 provenance and runtime validation. Do not turn the ignored checkpoint directory

docs/publications/README.md

@@ -1,7 +1,9 @@
 # Paper and Tech Report
 
-The reviewed PDFs are included in this release. Both files preserve the final
-manuscript bytes; publication does not imply new experiments or peer acceptance.
+The reviewed v1.1 PDFs are included in this release. They preserve the frozen
+v1 evidence while reporting a separately labelled post-freeze remediation
+handoff. Publication does not imply independent re-execution, external
+generalization, production readiness or peer acceptance.
 
 Author: **Kwangseob Ahn**  
 Affiliation: **INLEVEL9 / SEJONG UNIV.**  
@@ -9,23 +11,37 @@ Contact: **oswarld@inlevel9.com**
 
 | Publication | Version | Download |
 | --- | --- | --- |
-| Vons: A Compact, Host-Controlled Decision Component for Agent Workflows | Paper v1.0, final editorial revision | [PDF · 15 pages](vons-paper-v1.0.pdf) |
-| Vons: Compact Decision Models for Frontier-Agent Workflows | Technical Report v1.0.1 | [PDF · 20 pages](vons-tech-report-v1.0.1.pdf) |
+| Vons: A Compact, Host-Controlled Decision Component for Agent Workflows | Preprint v1.1 | [PDF · 21 pages](vons-paper-v1.1.pdf) |
+| Vons: Compact Decision Models for Frontier-Agent Workflows | Technical Report v1.1 | [PDF · 29 pages](vons-tech-report-v1.1.pdf) |
 
 ## Verification and provenance
 
-The final documents were reviewed against the frozen evidence packet and primary
-references, including tables, figures, negative results and missing measurements.
-Every PDF page was visually inspected. Independently checked local SHA-256
-values match the reviewed final versions. All pages render as US Letter, fonts
-are embedded, and no PDF JavaScript, launch action or embedded attachment was
-found. These are genuine Typst-generated PDFs; a clean source rebuild has not
-been independently completed and is not claimed.
+The final documents were reviewed against the frozen evidence packet, primary
+references and the post-freeze handoff. Claude Science did not access or rerun
+the post-freeze files; Codex independently checked the handed-off digests,
+values, implementation tests and local repository state. Every page of both
+PDFs was visually inspected. Independently checked local SHA-256 values match
+the reviewed release versions. All pages render as US Letter, all fonts are
+embedded, and no encryption, PDF JavaScript, launch action or embedded
+attachment was found. These are genuine Typst-generated PDFs. Science rebuilt
+both documents from their v1.1 release source; the private source bundles,
+claim ledgers and verification records are intentionally excluded from the
+public software release.
 
 | File | SHA-256 |
 | --- | --- |
-| `vons-paper-v1.0.pdf` | `ae0e09c60e17a98b52bb25c611b2489d10b18bd98d87974f2e8dd25d746a5fc8` |
-| `vons-tech-report-v1.0.1.pdf` | `33076d9e52d4a073060066215dd390e3b0bf0cdef48c5ffb2a7c5189854254ed` |
+| `vons-paper-v1.1.pdf` | `8e9ff7d768979411db2333f37111692b5b8426bdaec21d35954c7038d047f321` |
+| `vons-tech-report-v1.1.pdf` | `9e6aff46a271324f82db594155ea6b3a7c51c5cfe9b192e52f2b38d92ca84af3` |
+
+## Historical reviewed versions
+
+The prior PDFs remain available for provenance. They do not include the
+post-freeze v2 remediation section.
+
+| File | Version | SHA-256 |
+| --- | --- | --- |
+| `vons-paper-v1.0.pdf` | Paper v1.0 | `ae0e09c60e17a98b52bb25c611b2489d10b18bd98d87974f2e8dd25d746a5fc8` |
+| `vons-tech-report-v1.0.1.pdf` | Technical Report v1.0.1 | `33076d9e52d4a073060066215dd390e3b0bf0cdef48c5ffb2a7c5189854254ed` |
 
 Only these exact PDFs are permitted by the public allowlist. Drafts, prompts,
 claim ledgers, review conversations, source bundles and restricted benchmark data

sdk/typescript/README.md

@@ -36,6 +36,11 @@ values, not the repeated benchmark protocol.
 
 ## Source preview
 
+For a UI that does not require serving the development workspace, build the
+[Chrome side-panel extension](extension/README.md) with `npm run build:extension`.
+It packages the runtime locally and accepts a user-selected, hash-verified model
+folder. The guide explains installation and the separate model requirement.
+
 This package is private in npm metadata until an npm release is requested.
 Its `files` allowlist includes source, this guide and the software license. Models, tokenizers,
 datasets, generated demo JavaScript and dependencies are intentionally excluded

sdk/typescript/extension/README.md

@@ -0,0 +1,106 @@
+# Vons Chrome Extension
+
+A Manifest V3 side panel for local candidate comparison. It supports full-graph
+Direct and Diffusion Vons ONNX bundles, verifies exact manifest/asset hashes,
+and keeps execution with the user. No model weight is included in this package.
+
+## Build and install locally
+
+Requires Node 22+ and Chrome 114+:
+
+```sh
+cd sdk/typescript
+npm ci
+npm test
+npm run build:extension
+```
+
+Open `chrome://extensions`, enable Developer mode for your development profile,
+choose **Load unpacked**, and select `sdk/typescript/dist/chrome-extension` from
+the repository root. Pin **Vons — Local Decisions** in the toolbar and click it
+to open the side panel. A store listing and automatic updates are not provided
+by this local build. The generated folder includes all runtime JS/WASM, custom
+software terms and third-party notices; it excludes model weights and local data.
+
+For distribution, ZIP the *contents* of that generated directory so `manifest.json`
+is at the archive root. Review the resulting package before Chrome Web Store
+submission. Do not ZIP the workspace or your imported model folder.
+
+## Chrome Web Store status
+
+**Vons — Local Decisions**, version **0.1.0**, item ID
+`cbmjkokoojinfgafahncmjlfmicinide`, was submitted to the Chrome Web Store on
+**2026-09-25** after the owner approved the data-use declarations and final
+submission. It subsequently passed review and the public listing was verified
+on **2026-09-25**:
+[install Vons — Local Decisions](https://chromewebstore.google.com/detail/vons-%E2%80%94-local-decisions/cbmjkokoojinfgafahncmjlfmicinide).
+The package, English listing, icon, two screenshots, privacy disclosures and
+reviewer instructions are included. The local unpacked installation remains
+available above.
+
+The store package contains runtime code and notices only. A compatible model
+must be supplied by the user; the public source repository does not distribute
+pretrained weights. Noncommercial use is free under the included software terms;
+enterprise/commercial use requires a separate license.
+
+## First comparison
+
+1. Click **Import model folder** and choose the directory containing exactly one
+   `bundle-manifest-v1.json`, its full ONNX graph, external-data files and tokenizer.
+   Use a manifest produced by the Vons bundle tools. Head-only/shared-v1 partition
+   manifests use a different runtime contract and are not supported here.
+2. Optionally keep the model on this device. Nothing is uploaded. The original
+   manifest and only the required runtime assets are retained, not checkpoint or
+   report files that happen to share the folder. SHA-256 verifies consistency
+   with the imported manifest, not the identity or trustworthiness of its author.
+3. Enter context, a question and 2–32 unique candidates, one per line. **Use example**
+   supplies an illustrative prompt; its outcome is not a quality test.
+4. Click **Compare candidates**. Read the proposed choice or explicit abstention,
+   uncalibrated model scores and single-run timings. No page action is executed.
+
+WASM uses one thread and works without a WebGPU device. WebGPU is an explicit
+experimental choice; failure is shown rather than silently falling back.
+**Cancel** terminates the inference worker, and a subsequent comparison creates
+a fresh runtime. A two-minute timeout also stops the worker. The model's actual
+tokenizer enforces its aggregate input budget; long input is rejected rather than
+silently truncated. Models larger than 128 MiB of selected runtime assets are
+rejected before initialization. The paper's 64 MiB design target refers to model
+assets, not the total extension plus runtime download.
+
+## Privacy and host boundary
+
+Only `sidePanel` is requested. There are no host permissions, content scripts,
+page extraction, tool execution, network model fetches, analytics or account
+requirements. Prompts/results are in memory only. IndexedDB stores a model only
+when requested; **Remove model** deletes that retained copy. No Chrome Sync is
+used. The bundled [privacy notice](privacy.html) describes actual handling.
+The CSP restricts code and fetches to packaged extension resources and permits
+WebAssembly compilation without permitting general JavaScript eval.
+
+## Verification scope
+
+Source tests cover exact file integrity, missing assets, path escapes, candidate
+validation and unexpected extension permissions. On 2026-09-25, all 16 SDK tests,
+strict extension type checking and the extension build passed. Real Chrome
+testing of the generated interface over localhost verified Direct/WASM
+inference, explicit token-budget rejection, cancellation followed by reuse,
+optional model persistence and removal. The illustrative decision abstained;
+this was a functionality check, not a model-quality benchmark.
+
+The owner installed the unpacked extension; a subsequent independent check of
+that actual side panel completed both Direct and Diffusion WASM inference using
+the private pilot bundles. Both examples abstained. Direct took 326 ms for
+inference and 212 ms for load/check; Diffusion took 3,238 ms and 159 ms. These are
+single-run observations, not a latency benchmark or accuracy evidence. The
+Diffusion ranking placed an unsuitable option first, reinforcing the need to
+preserve abstention and human review. The imported models remain unpublished.
+
+The installed-panel check exercises the packaged worker/WASM path under its
+extension CSP. WebGPU, broader provider parity, external-task quality and
+production readiness are not established by these checks. Store review
+establishes listing-policy approval only, not scientific validity or safety.
+Preserve the model manifest hash with each result.
+
+Official references: [Side Panel API](https://developer.chrome.com/docs/extensions/reference/api/sidePanel),
+[MV3 CSP](https://developer.chrome.com/docs/extensions/reference/manifest/content-security-policy),
+[local development installation](https://developer.chrome.com/docs/extensions/get-started/tutorial/hello-world#load-unpacked).

sdk/typescript/extension/background.mjs

@@ -0,0 +1,4 @@
+// The side panel owns inference; this worker never reads or modifies a page.
+const configurePanel = () => chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
+chrome.runtime.onInstalled.addListener(configurePanel);
+chrome.runtime.onStartup.addListener(configurePanel);

sdk/typescript/extension/build.mjs

@@ -0,0 +1,51 @@
+import { build } from "esbuild";
+import { readFile, writeFile, mkdir, copyFile, readdir, rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const root = fileURLToPath(new URL("../", import.meta.url));
+const source = path.join(root, "extension");
+const output = path.join(root, "dist/chrome-extension");
+await rm(output, { recursive: true, force: true });
+await mkdir(path.join(output, "runtime"), { recursive: true });
+const result = await build({
+  absWorkingDir: root, entryPoints: ["extension/panel.ts", "extension/worker.ts"],
+  bundle: true, splitting: true, format: "esm", platform: "browser", target: "chrome114",
+  conditions: ["onnxruntime-web-use-extern-wasm"], outdir: output,
+  metafile: true, legalComments: "eof", minify: true,
+});
+for (const name of ["manifest.json", "background.mjs", "panel.html", "panel.css", "privacy.html"]) {
+  await copyFile(path.join(source, name), path.join(output, name));
+}
+await copyFile(path.join(root, "../../docs/assets/inlevel9-signature.png"), path.join(output, "brand.png"));
+for (const size of [16, 32, 48, 128]) {
+  await copyFile(path.join(root, `../../docs/assets/vons-extension-icon-${size}.png`), path.join(output, `icon-${size}.png`));
+}
+await copyFile(path.join(root, "LICENSE"), path.join(output, "LICENSE"));
+for (const name of ["ort-wasm-simd-threaded.mjs", "ort-wasm-simd-threaded.wasm",
+  "ort-wasm-simd-threaded.jsep.mjs", "ort-wasm-simd-threaded.jsep.wasm"]) {
+  await copyFile(path.join(root, "node_modules/onnxruntime-web/dist", name), path.join(output, "runtime", name));
+}
+const packages = new Set(["onnxruntime-web"]);
+for (const input of Object.keys(result.metafile.inputs)) {
+  const parts = input.split("node_modules/").at(-1).split("/");
+  if (input.includes("node_modules/")) packages.add(parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0]);
+}
+const notices = ["# Bundled third-party notices", "", "Vons source uses the accompanying LICENSE. Model weights are not included.", ""];
+for (const name of [...packages].sort()) {
+  const packageRoot = path.join(root, "node_modules", name);
+  const metadata = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
+  const files = (await readdir(packageRoot)).filter((file) => /^(?:licen[sc]e|copying|notice|thirdpartynotices)(?:\.|$)/i.test(file));
+  if (!files.length && name.startsWith("onnxruntime-")) {
+    if (metadata.version !== "1.30.0") throw new Error("Refresh the pinned ONNX Runtime notices before upgrading.");
+    notices.push(`## ${name} ${metadata.version}`, await readFile(path.join(source, "ONNX_RUNTIME_NOTICES.md"), "utf8"));
+    continue;
+  }
+  if (!files.length) throw new Error(`Missing third-party license notice: ${name}`);
+  notices.push(`## ${name} ${metadata.version}`, `Declared license: ${metadata.license}`, "");
+  for (const file of files) notices.push(`### ${file}`, "", await readFile(path.join(packageRoot, file), "utf8"), "");
+}
+await writeFile(path.join(output, "THIRD_PARTY_NOTICES.txt"), notices.join("\n"));
+const manifest = JSON.parse(await readFile(path.join(output, "manifest.json"), "utf8"));
+if (JSON.stringify(manifest.permissions) !== '["sidePanel"]' || manifest.host_permissions || manifest.content_scripts) throw new Error("Unexpected extension access.");
+console.log(`Built ${output}; model weights excluded; ${packages.size} dependency notices included.`);

sdk/typescript/extension/bundle.ts

@@ -0,0 +1,100 @@
+import { validateRequest, type DecisionRequest } from "../src/index.ts";
+import type { BundleManifest } from "../src/onnx.ts";
+
+export interface LocalAsset { path: string; bytes: ArrayBuffer; }
+export interface LocalBundle {
+  manifestPath: string;
+  manifestBytes: ArrayBuffer;
+  manifestHash: string;
+  backend: "direct" | "diffusion";
+  modelId: string;
+  assets: LocalAsset[];
+}
+export const MAX_BUNDLE_BYTES = 128 * 1024 * 1024;
+export function safePath(path: string): boolean {
+  return path.length > 0 && !path.startsWith("/") && !path.includes("..")
+    && !/[\\%?#:\u0000-\u001f]/.test(path)
+    && path.split("/").every((part) => part.length > 0);
+}
+export async function digest(bytes: ArrayBuffer): Promise<string> {
+  const hash = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(hash), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function requiredFiles(bytes: ArrayBuffer): { manifest: BundleManifest; paths: string[] } {
+  if (bytes.byteLength > 2 * 1024 * 1024) throw new Error("Manifest exceeds 2 MiB.");
+  const manifest = JSON.parse(new TextDecoder().decode(bytes)) as BundleManifest;
+  if (manifest.schema_version !== "vons.bundle.manifest/v1" || !manifest.metadata
+    || !["direct", "diffusion"].includes(manifest.metadata.backend)
+    || !Array.isArray(manifest.files) || manifest.files.length > 2048) {
+    throw new Error("Choose a Vons v1 manifest for a full Direct or Diffusion ONNX graph.");
+  }
+  const paths = new Set<string>();
+  for (const file of manifest.files) {
+    if (!file || typeof file.path !== "string" || !safePath(file.path) || paths.has(file.path)
+      || !Number.isSafeInteger(file.bytes) || file.bytes < 0 || file.bytes > MAX_BUNDLE_BYTES
+      || !/^[0-9a-f]{64}$/.test(file.sha256)) throw new Error("Invalid manifest file record.");
+    paths.add(file.path);
+  }
+  const graphs = manifest.files.filter((f) => f.role === "model_graph");
+  const tokenizers = ["tokenizer.json", "tokenizer_config.json"].map((name) =>
+    manifest.files.filter((f) => f.role === "tokenizer" && (f.path === name || f.path.endsWith(`/${name}`))));
+  if (graphs.length !== 1 || tokenizers.some((files) => files.length !== 1)) {
+    throw new Error("The manifest must name one full graph and both tokenizer JSON files.");
+  }
+  const external = manifest.metadata.graph?.external_data_locations ?? [];
+  if (!Array.isArray(external) || external.some((path) => typeof path !== "string" || !safePath(path)
+    || !manifest.files.some((f) => f.path === path && f.role === "model_external_data"))) {
+    throw new Error("The graph has an invalid external-data reference.");
+  }
+  return { manifest, paths: [...new Set([graphs[0].path, ...tokenizers.map((f) => f[0].path), ...external])] };
+}
+export async function verifyBundle(bundle: LocalBundle): Promise<void> {
+  if (!safePath(bundle.manifestPath) || await digest(bundle.manifestBytes) !== bundle.manifestHash) {
+    throw new Error("The saved manifest failed its integrity check. Import the model again.");
+  }
+  const { manifest, paths } = requiredFiles(bundle.manifestBytes);
+  if (manifest.metadata.backend !== bundle.backend || bundle.assets.length !== paths.length) {
+    throw new Error("Model bundle contents do not match the manifest.");
+  }
+  let total = bundle.manifestBytes.byteLength;
+  for (const path of paths) {
+    const matches = bundle.assets.filter((a) => a.path === path);
+    const record = manifest.files.find((f) => f.path === path)!;
+    if (matches.length !== 1 || matches[0].bytes.byteLength !== record.bytes) throw new Error(`Missing or wrong-sized model file: ${path}`);
+    total += record.bytes;
+    if (total > MAX_BUNDLE_BYTES) throw new Error("The selected runtime assets exceed 128 MiB.");
+    if (await digest(matches[0].bytes) !== record.sha256) throw new Error(`Model file failed SHA-256 verification: ${path}`);
+  }
+}
+export async function importBundle(files: File[]): Promise<LocalBundle> {
+  if (files.length === 0 || files.length > 2048) throw new Error("Choose one model folder with at most 2048 files.");
+  const manifests = files.filter((f) => f.name === "bundle-manifest-v1.json");
+  if (manifests.length !== 1) throw new Error("Choose the folder containing exactly one bundle-manifest-v1.json.");
+  const file = manifests[0];
+  if (file.size > 2 * 1024 * 1024) throw new Error("Manifest exceeds 2 MiB.");
+  const root = file.webkitRelativePath.slice(0, -file.name.length);
+  const manifestBytes = await file.arrayBuffer();
+  const { manifest, paths } = requiredFiles(manifestBytes);
+  const assets: LocalAsset[] = [];
+  let total = manifestBytes.byteLength;
+  for (const path of paths) {
+    const selected = files.filter((f) => f.webkitRelativePath === root + path);
+    const expected = manifest.files.find((f) => f.path === path)!;
+    if (selected.length !== 1 || selected[0].size !== expected.bytes) throw new Error(`Missing or wrong-sized model file: ${path}`);
+    total += selected[0].size;
+    if (total > MAX_BUNDLE_BYTES) throw new Error("The selected runtime assets exceed 128 MiB.");
+    assets.push({ path, bytes: await selected[0].arrayBuffer() });
+  }
+  const bundle: LocalBundle = { manifestPath: file.name, manifestBytes,
+    manifestHash: await digest(manifestBytes), backend: manifest.metadata.backend,
+    modelId: manifest.metadata.model_id ?? `Vons ${manifest.metadata.backend}`, assets };
+  await verifyBundle(bundle);
+  return bundle;
+}
+export function makeRequest(state: string, prompt: string, candidates: string): DecisionRequest {
+  const request: DecisionRequest = { state: state.trim(), seed: 7,
+    questions: [{ id: "decision", type: "choice", prompt: prompt.trim(),
+      options: candidates.split(/\r?\n/).map((s) => s.trim()).filter(Boolean) }] };
+  validateRequest(request);
+  return request;
+}

sdk/typescript/extension/manifest.json

@@ -0,0 +1,20 @@
+{
+  "manifest_version": 3,
+  "name": "Vons — Local Decisions",
+  "version": "0.1.0",
+  "description": "Compare your candidate choices locally. Import a Vons model bundle; the host stays in control.",
+  "minimum_chrome_version": "114",
+  "permissions": ["sidePanel"],
+  "icons": {
+    "16": "icon-16.png",
+    "32": "icon-32.png",
+    "48": "icon-48.png",
+    "128": "icon-128.png"
+  },
+  "action": {"default_title": "Open Vons"},
+  "background": {"service_worker": "background.mjs", "type": "module"},
+  "side_panel": {"default_path": "panel.html"},
+  "content_security_policy": {
+    "extension_pages": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'none'; connect-src 'self'; worker-src 'self'; style-src 'self'; img-src 'self'; frame-src 'none'; base-uri 'none'; form-action 'none'"
+  }
+}

sdk/typescript/extension/panel.css

@@ -0,0 +1,61 @@
+:root { color-scheme: light dark; --bg:#f5f6f1; --surface:#fff; --ink:#20251e; --muted:#697063; --line:#d7ded0; --accent:#c5ff7a; --error:#a63725; font:14px/1.55 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; }
+* { box-sizing:border-box; }
+body { margin:0; background:var(--bg); color:var(--ink); min-width:280px; }
+header { padding:23px 22px 19px; border-bottom:1px solid var(--line); display:flex; gap:12px; align-items:center; justify-content:space-between; }
+header img { object-fit:contain; }
+.version { font-size:9px; font-weight:650; letter-spacing:.08em; text-align:right; }
+main { max-width:560px; margin:auto; padding:0 22px; }
+.intro { padding:30px 0 24px; }
+.eyebrow { font-size:10px; font-weight:700; letter-spacing:.12em; }
+h1 { font-size:clamp(26px,7.8vw,38px); line-height:1.1; font-weight:620; letter-spacing:-.04em; margin:14px 0; }
+p { margin:10px 0; }
+.intro>p:last-child, .model>p { color:var(--muted); font-size:13px; }
+.model { background:var(--surface); padding:18px; border:1px solid var(--line); border-radius:12px; }
+.section-title { display:flex; align-items:center; gap:10px; justify-content:space-between; margin-bottom:13px; }
+h2 { margin:0; font-size:11px; font-weight:450; white-space:nowrap; color:var(--muted); }
+h2 span { color:var(--ink); font-size:13px; font-weight:650; margin-left:9px; }
+.badge { background:var(--bg); border:1px solid var(--line); border-radius:4px; font-size:10px; padding:3px 7px; white-space:nowrap; }
+button,input,textarea,select { font:inherit; }
+button,a,.file-button,summary { -webkit-tap-highlight-color:transparent; }
+button,.file-button { cursor:pointer; }
+a { color:inherit; text-underline-offset:3px; }
+button:disabled { opacity:.45; cursor:not-allowed; }
+button { border:1px solid var(--line); border-radius:6px; padding:10px 13px; background:var(--surface); color:var(--ink); }
+.file-button { display:flex; justify-content:space-between; background:var(--ink); color:var(--surface); padding:11px 13px; border-radius:6px; font-weight:600; margin:16px 0 12px; }
+.remember { display:flex; gap:8px; align-items:center; font-size:11px; color:var(--muted); }
+.remember input { accent-color:#537c29; margin:0; }
+.model-actions { display:flex; gap:14px; align-items:center; justify-content:space-between; margin-top:10px; font-size:11px; }
+.text-button { border:0; padding:3px 0; background:none; text-decoration:underline; text-underline-offset:3px; font-size:11px; }
+form { padding:27px 0 20px; }
+form>label { display:block; margin:17px 0 6px; font-size:12px; font-weight:650; }
+.hint { color:var(--muted); font-size:11px; font-weight:400; }
+label .hint { float:right; }
+textarea,form>input,select { width:100%; border:1px solid var(--line); border-radius:6px; background:var(--surface); color:var(--ink); padding:11px 12px; }
+textarea { resize:vertical; min-height:70px; }
+textarea::placeholder,input::placeholder { color:#818879; }
+:focus-visible { outline:2px solid #679827; outline-offset:3px; }
+details { border-top:1px solid var(--line); margin-top:17px; padding:12px 0 0; font-size:12px; }
+summary { cursor:pointer; color:var(--muted); }
+details label { display:block; margin:10px 0 5px; }
+.run-actions { display:flex; gap:10px; margin-top:19px; }
+#run { flex:1; background:var(--accent); color:#1e2915; font-weight:650; border-color:transparent; display:flex; justify-content:space-between; }
+#status { font-size:12px; color:var(--muted); overflow-wrap:anywhere; }
+#status[data-error="true"] { color:var(--error); }
+.result { border-top:2px solid var(--ink); padding:23px 0; }
+.result h3 { font-size:24px; line-height:1.25; margin:9px 0; overflow-wrap:anywhere; }
+#reason { color:var(--muted); font-size:12px; }
+ol { list-style:none; padding:0; margin:18px 0; }
+li { margin:12px 0; }
+.rank-label { display:flex; justify-content:space-between; gap:15px; font-size:12px; overflow-wrap:anywhere; }
+progress { width:100%; height:5px; border:0; display:block; margin-top:7px; accent-color:#709b42; }
+progress::-webkit-progress-bar { background:var(--line); border-radius:4px; }
+progress::-webkit-progress-value { background:#709b42; border-radius:4px; }
+.boundary { font-size:11px; background:var(--surface); border-left:3px solid #a5b592; padding:9px 12px; }
+pre { font:10px/1.6 ui-monospace,monospace; overflow:auto; max-height:240px; white-space:pre-wrap; overflow-wrap:anywhere; }
+footer { border-top:1px solid var(--line); padding:16px 0 25px; color:var(--muted); font-size:10px; }
+footer p:first-child { color:var(--ink); font-weight:650; }
+nav { display:flex; gap:18px; margin-top:15px; }
+[hidden] { display:none!important; }
+.visually-hidden { position:absolute; width:1px; height:1px; overflow:hidden; clip-path:inset(50%); }
+.file-button:has(+input:focus-visible) { outline:2px solid #679827; outline-offset:3px; }
+@media(prefers-color-scheme:dark) { :root { --bg:#1d221c; --surface:#252c23; --ink:#edf4e8; --muted:#a5b09e; --line:#434e3d; --error:#ffb09c; } header img { background:#f5f6f1; border-radius:2px; } }

sdk/typescript/extension/panel.html

@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Vons — Local Decisions</title>
+  <link rel="stylesheet" href="panel.css">
+</head>
+<body>
+  <header>
+    <img src="brand.png" alt="INLEVEL9" width="132" height="23">
+    <span class="version">RESEARCH PREVIEW</span>
+  </header>
+  <main>
+    <div class="intro"><p class="eyebrow">YOUR OPTIONS. YOUR CONTROL.</p><h1>A little help<br>with the next choice.</h1><p>Compare a few candidates with a model on your device. You decide what happens next.</p></div>
+    <section class="model" aria-labelledby="model-heading">
+      <div class="section-title"><h2 id="model-heading">01 <span>Choose a model</span></h2><span id="model-badge" class="badge">Not loaded</span></div>
+      <p id="model-description">Import a Vons ONNX bundle folder. Model weights are supplied separately.</p>
+      <label class="file-button" for="bundle-files">Import model folder <span aria-hidden="true">↗</span></label>
+      <input id="bundle-files" type="file" webkitdirectory multiple class="visually-hidden">
+      <label class="remember"><input id="remember" type="checkbox"> Keep this model on this device</label>
+      <div class="model-actions"><button id="forget" type="button" class="text-button" disabled>Remove model</button><a href="https://huggingface.co/INLEVEL9/Vons" target="_blank" rel="noreferrer">Bundle guide ↗</a></div>
+    </section>
+    <form id="decision-form">
+      <div class="section-title"><h2>02 <span>Frame your decision</span></h2><button id="example" type="button" class="text-button">Use example</button></div>
+      <label for="state">Context</label><textarea id="state" rows="3" maxlength="20000" placeholder="What does the model need to know?" required></textarea>
+      <label for="question">Question</label><input id="question" maxlength="2000" placeholder="Which option fits this situation?" required>
+      <label for="options">Candidates <span class="hint">One per line · 2–32</span></label><textarea id="options" rows="4" maxlength="20000" placeholder="First option&#10;Second option" required></textarea>
+      <details><summary>Runtime settings</summary><label for="provider">Execution provider</label><select id="provider"><option value="wasm">WASM · CPU (default)</option value="webgpu">WebGPU · experimental</option></select><p class="hint">WebGPU requires a compatible adapter. Failed requests stay visible; no silent fallback.</p></details>
+      <div class="run-actions"><button id="run" type="submit" disabled>Compare candidates <span aria-hidden="true">→</span></button><button id="cancel" type="button" hidden>Cancel</button></div>
+      <p id="status" role="status" aria-live="polite">Start by importing a model. Prompts stay in this panel.</p>
+    </form>
+    <section id="result" class="result" aria-labelledby="result-heading" hidden>
+      <div class="section-title"><h2 id="result-heading">03 <span>Review the proposal</span></h2><button id="copy" type="button" class="text-button">Copy JSON</button></div>
+      <p id="decision-label" class="eyebrow"></p><h3 id="choice"></h3><p id="reason"></p>
+      <ol id="ranking"></ol><p id="timing" class="hint"></p>
+      <p class="boundary">Scores are uncalibrated model outputs. A proposal is not permission to act.</p>
+      <details><summary>Response and provenance</summary><pre id="raw"></pre></details>
+    </section>
+    <footer><p>Local processing. No telemetry. No page access.</p><p>Text and decisions are not saved. Closing the panel ends the session. Only a model you choose to keep is stored locally.</p><nav><a href="privacy.html" target="_blank">Privacy &amp; terms</a><a href="https://huggingface.co/INLEVEL9/Vons/tree/main/docs/publications" target="_blank" rel="noreferrer">Research ↗</a></nav></footer>
+  </main>
+  <script src="panel.js" type="module"></script>
+</body>
+</html>

sdk/typescript/extension/panel.ts

@@ -0,0 +1,146 @@
+import { importBundle, verifyBundle, makeRequest, type LocalBundle } from "./bundle.ts";
+import { modelStorage } from "./storage.ts";
+import { validateResponse, type DecisionResponse } from "../src/index.ts";
+
+function element<T extends HTMLElement>(id: string): T {
+  const node = document.getElementById(id);
+  if (!node) throw new Error(`Missing panel element: ${id}`);
+  return node as T;
+}
+const files = element<HTMLInputElement>("bundle-files");
+const remember = element<HTMLInputElement>("remember");
+const run = element<HTMLButtonElement>("run");
+const cancel = element<HTMLButtonElement>("cancel");
+const forget = element<HTMLButtonElement>("forget");
+const provider = element<HTMLSelectElement>("provider");
+const form = element<HTMLFormElement>("decision-form");
+let bundle: LocalBundle | undefined;
+let worker: Worker | undefined;
+let workerKey = "";
+let busy = false;
+let importing = false;
+let lastResult = "";
+let timeout: ReturnType<typeof setTimeout> | undefined;
+
+function status(text: string, error = false): void {
+  const node = element("status"); node.textContent = text; node.dataset.error = String(error);
+}
+function controls(): void {
+  run.disabled = busy || importing || !bundle;
+  forget.disabled = busy || importing || !bundle;
+  files.disabled = busy || importing;
+  remember.disabled = busy || importing;
+  provider.disabled = busy || importing;
+  for (const id of ["state", "question", "options", "example"]) element<HTMLInputElement | HTMLButtonElement>(id).disabled = busy;
+  cancel.hidden = !busy;
+  form.setAttribute("aria-busy", String(busy));
+}
+function stop(): void {
+  worker?.terminate(); worker = undefined; workerKey = "";
+  clearTimeout(timeout); busy = false; controls();
+}
+function modelLabel(): void {
+  element("model-badge").textContent = bundle ? bundle.backend : "Not loaded";
+  element("model-description").textContent = bundle
+    ? `${bundle.modelId} · ${(bundle.assets.reduce((sum, a) => sum + a.bytes.byteLength, 0) / 1048576).toFixed(1)} MiB · SHA-256 checked`
+    : "Import a Vons ONNX bundle folder. Model weights are supplied separately.";
+  controls();
+}
+function errorMessage(error: unknown): string { return error instanceof Error ? error.message : "The operation failed."; }
+function showResult(data: { response: DecisionResponse; manifestHash: string; runtime: unknown; loadMs: number; inferenceMs: number }): void {
+  validateResponse(data.response);
+  const answer = data.response.answers[0];
+  if (!answer) throw new Error("The model returned no answer.");
+  element("decision-label").textContent = answer.status === "abstain" ? "NO RECOMMENDATION" : "MODEL PROPOSAL";
+  element("choice").textContent = answer.choice ?? "The model abstained.";
+  element("reason").textContent = answer.abstain_reason?.replaceAll("_", " ") ?? "Review this choice yourself before taking any action.";
+  const ranking = element("ranking"); ranking.replaceChildren();
+  for (const entry of [...answer.probabilities].sort((a, b) => b.probability - a.probability)) {
+    const item = document.createElement("li"); const row = document.createElement("div"); row.className = "rank-label";
+    const label = document.createElement("span"); label.textContent = entry.option;
+    const value = document.createElement("span"); value.textContent = `${(entry.probability * 100).toFixed(1)}%`;
+    const bar = document.createElement("progress"); bar.max = 1; bar.value = entry.probability; bar.setAttribute("aria-label", `${entry.option} model score`);
+    row.append(label, value); item.append(row, bar); ranking.append(item);
+  }
+  element("timing").textContent = `Local run: ${data.inferenceMs.toFixed(0)} ms · load/check: ${data.loadMs.toFixed(0)} ms. This is one run, not a benchmark.`;
+  lastResult = JSON.stringify(data, null, 2); element("raw").textContent = lastResult;
+  element("result").hidden = false;
+}
+files.addEventListener("change", async () => {
+  if (!files.files?.length) return;
+  importing = true; stop(); controls(); element("result").hidden = true;
+  status("Reading and verifying the selected model files…");
+  try {
+    const next = await importBundle(Array.from(files.files));
+    // Do not make a new model active until its requested storage operation succeeds.
+    if (remember.checked) await modelStorage("write", next);
+    else await modelStorage("clear");
+    bundle = next; status("Model ready. Add context and candidates, then compare.");
+  } catch (error) { status(errorMessage(error), true); }
+  finally { importing = false; files.value = ""; modelLabel(); }
+});
+remember.addEventListener("change", async () => {
+  importing = true; controls();
+  try {
+    if (remember.checked && bundle) await modelStorage("write", bundle);
+    else await modelStorage("clear");
+    status(remember.checked ? "This model will be available next time. Text is never saved." : "Stored model removed. The current model remains in this session only.");
+  } catch (error) { remember.checked = !remember.checked; status(errorMessage(error), true); }
+  finally { importing = false; controls(); }
+});
+forget.addEventListener("click", async () => {
+  importing = true; stop(); controls();
+  try {
+    await modelStorage("clear"); bundle = undefined; remember.checked = false;
+    element("result").hidden = true; lastResult = ""; element("raw").textContent = "";
+    status("Model removed from this device.");
+  } catch (error) { status(errorMessage(error), true); }
+  finally { importing = false; modelLabel(); }
+});
+element("example").addEventListener("click", () => {
+  element<HTMLInputElement>("state").value = "A document has unsaved edits. The author wants to keep the changes before closing it.";
+  element<HTMLInputElement>("question").value = "What should happen next?";
+  element<HTMLInputElement>("options").value = "Save the document\nDiscard the changes\nAsk the author for more context";
+  element("result").hidden = true;
+  status("Example loaded. This is an illustrative input, not a quality test.");
+});
+form.addEventListener("submit", (event) => {
+  event.preventDefault(); if (busy || importing || !bundle) return;
+  try {
+    const request = makeRequest(element<HTMLInputElement>("state").value, element<HTMLInputElement>("question").value, element<HTMLInputElement>("options").value);
+    const selected = provider.value === "webgpu" ? "webgpu" : "wasm";
+    const key = `${bundle.manifestHash}:${selected}`;
+    if (workerKey !== key) stop();
+    if (!worker) {
+      worker = new Worker(new URL("worker.js", import.meta.url), { type: "module" });
+      worker.onmessage = (message) => {
+        const data = message.data;
+        if (data.type === "progress") { status(data.text); return; }
+        clearTimeout(timeout); busy = false; controls();
+        if (data.type === "error") { stop(); status(data.text, true); return; }
+        try { showResult(data); status("Comparison complete. No page action was taken."); }
+        catch (error) { stop(); status(errorMessage(error), true); }
+      };
+      worker.onerror = () => { stop(); status("The local runtime stopped unexpectedly. You can try again with WASM.", true); };
+    }
+    busy = true; controls(); element("result").hidden = true;
+    status("Starting the local comparison…");
+    worker.postMessage({ request, provider: selected, ...(workerKey === key ? {} : { bundle }) }); workerKey = key;
+    timeout = setTimeout(() => { stop(); status("The comparison exceeded two minutes and was stopped. Try fewer or shorter candidates.", true); }, 120000);
+  } catch (error) { stop(); status(errorMessage(error), true); }
+});
+cancel.addEventListener("click", () => { stop(); status("Canceled. No decision was returned. The model can be used again."); });
+element("copy").addEventListener("click", async () => {
+  try { await navigator.clipboard.writeText(lastResult); status("Response JSON copied. It contains your candidate text."); }
+  catch { status("Clipboard access was unavailable. Select the JSON text to copy it manually.", true); }
+});
+window.addEventListener("pagehide", stop);
+async function restore(): Promise<void> {
+  importing = true; controls();
+  try {
+    const saved = await modelStorage("read");
+    if (saved) { await verifyBundle(saved); bundle = saved; remember.checked = true; status("Your saved model is ready. Context and decisions were not retained."); }
+  } catch (error) { status(`${errorMessage(error)} You can import a model folder again.`, true); }
+  finally { importing = false; modelLabel(); }
+}
+void restore();

sdk/typescript/extension/privacy.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Vons — Privacy and terms</title><link rel="stylesheet" href="panel.css"></head><body><main>
+<div class="intro"><p class="eyebrow">VONS · RESEARCH PREVIEW 0.1.0</p><h1>Local by design.</h1><p>The extension compares candidate choices using a model you import. It cannot read or modify web pages and never executes a proposed action.</p></div>
+<h2><span>What is processed</span></h2><p>Only the context, question, candidates and model files you explicitly provide. Inference runs on this device using packaged ONNX Runtime Web code. There are no server uploads, analytics, telemetry, account requirements or remote model downloads.</p>
+<h2><span>What is retained</span></h2><p>Context and results stay in the open panel's memory. Closing the panel ends that session. If you choose “Keep this model on this device,” model assets and their manifest are stored in local IndexedDB, not Chrome Sync. Remove model clears that stored model. Turning off the option also clears the stored copy.</p>
+<h2><span>Permissions</span></h2><p>The sole extension permission is sidePanel, used to display Vons beside the current tab. No page, cookie, history, clipboard-read, background network or browsing-content access is requested. Copy JSON writes only the displayed result to your clipboard after you click it. Model file access comes from the folder picker you open.</p>
+<h2><span>External links</span></h2><p>Research and bundle-guide links open Hugging Face only when clicked. That destination has its own privacy policy. Context, candidates and model contents are not included in those links.</p>
+<h2><span>Limits and terms</span></h2><p>This is research software. Model scores are not calibrated probabilities of correctness. A proposal does not establish quality, consent or permission to act. The current publication reports negative external evaluation results and unresolved deployment gates. Model weights are not included; review their origin and redistribution terms separately.</p><p>Vons uses the <a href="LICENSE">Vons Community and Commercial License 1.0</a>: qualifying noncommercial use is free; enterprise and commercial use require a separate written agreement. Third-party code retains its own terms in <a href="THIRD_PARTY_NOTICES.txt">bundled notices</a>. Articles use CC BY 4.0 separately.</p>
+<footer><p>Contact: <a href="mailto:oswarld@inlevel9.com">oswarld@inlevel9.com</a> · INLEVEL9</p><p>Updated September 25, 2026.</p></footer>
+</main></body></html>

sdk/typescript/extension/storage.ts

@@ -0,0 +1,23 @@
+import type { LocalBundle } from "./bundle.ts";
+const DATABASE = "vons-local-model";
+async function open(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DATABASE, 1);
+    request.onupgradeneeded = () => request.result.createObjectStore("model");
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(new Error("Local model storage is unavailable."));
+    request.onblocked = () => reject(new Error("Close other Vons panels before updating storage."));
+  });
+}
+export async function modelStorage(action: "read" | "write" | "clear", model?: LocalBundle): Promise<LocalBundle | undefined> {
+  const db = await open();
+  try {
+    return await new Promise((resolve, reject) => {
+      const transaction = db.transaction("model", action === "read" ? "readonly" : "readwrite");
+      const store = transaction.objectStore("model");
+      const request = action === "read" ? store.get("active") : action === "write" ? store.put(model, "active") : store.clear();
+      transaction.oncomplete = () => resolve(action === "read" ? request.result as LocalBundle | undefined : undefined);
+      transaction.onabort = transaction.onerror = () => reject(new Error("Could not update local model storage. Check available space."));
+    });
+  } finally { db.close(); }
+}

sdk/typescript/extension/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true
+  },
+  "include": ["*.ts", "../src/*.ts"]
+}

sdk/typescript/extension/worker.ts

@@ -0,0 +1,42 @@
+import { createOnnxWebBackend, type OnnxWebBackend } from "../src/onnx.ts";
+import type { DecisionRequest } from "../src/index.ts";
+import { verifyBundle, type LocalBundle } from "./bundle.ts";
+
+let backend: OnnxWebBackend | undefined;
+let loadedKey = "";
+self.onmessage = async (event: MessageEvent<{ bundle?: LocalBundle; provider: "wasm" | "webgpu"; request: DecisionRequest }>) => {
+  const started = performance.now();
+  try {
+    const { bundle, provider, request } = event.data;
+    if (bundle) {
+      const key = `${bundle.manifestHash}:${provider}`;
+      if (key !== loadedKey) {
+        await backend?.dispose(); backend = undefined; loadedKey = "";
+        self.postMessage({ type: "progress", text: "Checking model files and starting the local runtime…" });
+        await verifyBundle(bundle);
+        // This synthetic origin is only a lookup key. No model request can use network fetch.
+        const base = "https://vons-bundle.invalid/";
+        const bytes = new Map(bundle.assets.map((f) => [new URL(f.path, base).href, f.bytes]));
+        bytes.set(new URL(bundle.manifestPath, base).href, bundle.manifestBytes);
+        const localFetch: typeof fetch = async (input) => {
+          const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+          const asset = bytes.get(url);
+          if (!asset) throw new Error("Requested model asset is not in the selected local bundle.");
+          return new Response(asset);
+        };
+        backend = await createOnnxWebBackend({ manifestUrl: new URL(bundle.manifestPath, base),
+          expectedManifestSha256: bundle.manifestHash, fetch: localFetch, provider,
+          wasmPaths: new URL("runtime/", self.location.href).href, wasmNumThreads: 1 });
+        loadedKey = key;
+      }
+    }
+    if (!backend || backend.runtimeInfo.provider !== provider) throw new Error("Import or reload the model before running.");
+    const ready = performance.now();
+    self.postMessage({ type: "progress", text: "Comparing your candidates on this device…" });
+    const response = await backend.decide(request);
+    self.postMessage({ type: "result", response, manifestHash: backend.manifestHash,
+      runtime: backend.runtimeInfo, loadMs: ready - started, inferenceMs: performance.now() - ready });
+  } catch (error) {
+    self.postMessage({ type: "error", text: error instanceof Error ? error.message : "Local inference failed." });
+  }
+};

sdk/typescript/package-lock.json

@@ -7,17 +7,18 @@
     "": {
       "name": "@vons/decision-sdk",
       "version": "0.1.0",
+      "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@huggingface/tokenizers": "0.2.0",
         "onnxruntime-web": "1.30.0"
       },
       "devDependencies": {
-        "esbuild": "0.28.2"
+        "esbuild": "0.28.2",
+        "typescript": "5.9.3"
       },
       "engines": {
         "node": ">=22"
-      },
-      "license": "SEE LICENSE IN LICENSE"
+      }
     },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.28.2",
@@ -642,6 +643,20 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
     "node_modules/undici-types": {
       "version": "8.9.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.9.0.tgz",

sdk/typescript/package.json

@@ -12,16 +12,19 @@
     "./onnx": "./src/onnx.ts"
   },
   "scripts": {
-    "test": "node --experimental-strip-types --test test/index.test.mjs test/onnx.test.mjs test/parity.test.mjs",
+    "test": "node --experimental-strip-types --test test/index.test.mjs test/onnx.test.mjs test/parity.test.mjs test/extension.test.mjs",
     "build:browser": "esbuild demo/main.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=demo/main.js",
     "build:benchmark": "esbuild demo/benchmark.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=demo/benchmark.js",
-    "build:parity": "esbuild demo/parity.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=demo/parity.js"
+    "build:parity": "esbuild demo/parity.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=demo/parity.js",
+    "build:extension": "node extension/build.mjs",
+    "typecheck:extension": "tsc -p extension/tsconfig.json"
   },
   "engines": {
     "node": ">=22"
   },
   "devDependencies": {
-    "esbuild": "0.28.2"
+    "esbuild": "0.28.2",
+    "typescript": "5.9.3"
   },
   "private": true,
   "files": [

sdk/typescript/src/onnx.ts

@@ -325,9 +325,20 @@ export function tokenizeCandidates(
   state: DecisionRequest["state"],
   question: Question,
   options: readonly string[],
-  sequenceLength: number,
-): TokenizedCandidate[] {
-  return options.map((option) => encodeCandidate(tokenizer, candidateText(state, question, option), sequenceLength));
+  sequenceBudget: number,
+): { candidates: TokenizedCandidate[]; liveSequenceLength: number } {
+  if (!Number.isInteger(sequenceBudget) || sequenceBudget < 1 || sequenceBudget > 512) {
+    throw new RangeError("sequenceBudget must be an integer in [1, 512]");
+  }
+  const candidates = options.map((option) => encodeCandidate(tokenizer, candidateText(state, question, option), sequenceBudget));
+  let longest = 0;
+  for (const candidate of candidates) {
+    const length = candidate.inputIds.length;
+    if (length > longest) longest = length;
+  }
+  if (longest < 1) throw new Error("each tokenized candidate must contain at least one token");
+  const liveSequenceLength = Math.min(longest, sequenceBudget);
+  return { candidates, liveSequenceLength };
 }
 
 function padCandidates(candidates: readonly TokenizedCandidate[], slots: number, sequenceLength: number, paddingId: number): {
@@ -499,6 +510,7 @@ export class OnnxWebBackend implements DecisionBackend {
     if (this.disposed) throw new Error("ONNX Runtime session has been disposed");
     validateRequest(request);
     const answers: QuestionAnswer[] = [];
+    const sequenceBudget = this.sequenceLength;
     for (const [questionIndex, question] of request.questions.entries()) {
       const requestStarted = performance.now();
       if (question.type === "score") {
@@ -510,18 +522,18 @@ export class OnnxWebBackend implements DecisionBackend {
         throw new RangeError(`question ${question.id} has unsupported candidate count`);
       }
       const aggregateTokenCount = this.tokenizer.encode(candidateListText(request.state, question, options)).ids.length;
-      if (aggregateTokenCount > this.sequenceLength) {
-        throw new RangeError(`question ${question.id} exceeds the ${this.sequenceLength}-token aggregate input budget (tokens=${aggregateTokenCount})`);
+      if (aggregateTokenCount > sequenceBudget) {
+        throw new RangeError(`question ${question.id} exceeds the ${sequenceBudget}-token aggregate input budget (tokens=${aggregateTokenCount})`);
       }
       const tokenizeStarted = performance.now();
-      const encoded = tokenizeCandidates(this.tokenizer, request.state, question, options, this.sequenceLength);
+      const { candidates: encoded, liveSequenceLength } = tokenizeCandidates(this.tokenizer, request.state, question, options, sequenceBudget);
       const tokenized = performance.now();
-      const padded = padCandidates(encoded, slots, this.sequenceLength, this.paddingId);
+      const padded = padCandidates(encoded, slots, liveSequenceLength, this.paddingId);
       let traceNoise: Float32Array | null = null;
       const feeds: Record<string, unknown> = {
-        input_ids: tensor(this.runtime, "int64", padded.inputIds, [1, slots, this.sequenceLength]),
-        attention_mask: tensor(this.runtime, "int64", padded.attentionMask, [1, slots, this.sequenceLength]),
-        token_type_ids: tensor(this.runtime, "int64", padded.tokenTypeIds, [1, slots, this.sequenceLength]),
+        input_ids: tensor(this.runtime, "int64", padded.inputIds, [1, slots, liveSequenceLength]),
+        attention_mask: tensor(this.runtime, "int64", padded.attentionMask, [1, slots, liveSequenceLength]),
+        token_type_ids: tensor(this.runtime, "int64", padded.tokenTypeIds, [1, slots, liveSequenceLength]),
         option_mask: tensor(this.runtime, "bool", padded.optionMask, [1, slots]),
       };
       if (this.backend === "diffusion") {
@@ -570,7 +582,7 @@ export class OnnxWebBackend implements DecisionBackend {
         live_candidates: encoded.length,
         allocated_candidates: slots,
         live_tokens: encoded.reduce((total, candidate) => total + candidate.inputIds.length, 0),
-        sequence_length: this.sequenceLength,
+        sequence_length: liveSequenceLength,
         tokenizeMs: tokenized - tokenizeStarted,
         prepareFeedMs: inferenceStarted - tokenized,
         inferenceAndReadbackMs: readbackCompleted - inferenceStarted,

sdk/typescript/test/extension.test.mjs

@@ -0,0 +1,46 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { requiredFiles, safePath, digest, verifyBundle, makeRequest } from "../extension/bundle.ts";
+
+async function fixture() {
+  const asset = new TextEncoder().encode("fixture only").buffer;
+  const hash = await digest(asset);
+  const files = [
+    { path: "graph.onnx", role: "model_graph" },
+    { path: "tokenizer/tokenizer.json", role: "tokenizer" },
+    { path: "tokenizer/tokenizer_config.json", role: "tokenizer" },
+  ].map((file) => ({ ...file, bytes: asset.byteLength, sha256: hash }));
+  const manifestBytes = new TextEncoder().encode(JSON.stringify({ schema_version: "vons.bundle.manifest/v1", metadata: { backend: "direct" }, files })).buffer;
+  return { manifestPath: "bundle-manifest-v1.json", manifestBytes, manifestHash: await digest(manifestBytes), backend: "direct", modelId: "test", assets: files.map((file) => ({ path: file.path, bytes: asset })) };
+}
+test("extension verifies exact manifest and asset bytes, including retained bundles", async () => {
+  const bundle = await fixture(); await verifyBundle(bundle);
+  await assert.rejects(verifyBundle({ ...bundle, manifestHash: "0".repeat(64) }), /integrity/);
+  await assert.rejects(verifyBundle({ ...bundle, assets: bundle.assets.slice(1) }), /contents/);
+  const corrupt = structuredClone(bundle); new Uint8Array(corrupt.assets[0].bytes)[0] = 0;
+  await assert.rejects(verifyBundle(corrupt), /SHA-256/);
+});
+test("extension rejects escaped paths and incomplete model contracts", async () => {
+  for (const value of ["../model", "https://evil.test/x", "%2e%2e/x", "a\\b", "/abs", "a?token", "a//b", "x\u0000y"]) assert.equal(safePath(value), false);
+  assert.equal(safePath("tokenizer/tokenizer.json"), true);
+  const bundle = await fixture(); const manifest = JSON.parse(new TextDecoder().decode(bundle.manifestBytes));
+  manifest.metadata.graph = { external_data_locations: ["unknown.onnx.data"] };
+  assert.throws(() => requiredFiles(new TextEncoder().encode(JSON.stringify(manifest)).buffer), /external-data/);
+});
+test("extension accepts bounded unique candidates and refuses empty or duplicate input", () => {
+  assert.deepEqual(makeRequest(" ready ", "Choose", "A\r\nB\n").questions[0].options, ["A", "B"]);
+  assert.throws(() => makeRequest("", "Choose", "A\nB"), /empty/);
+  assert.throws(() => makeRequest("ready", "Choose", "A\nA"), /unique/);
+  assert.throws(() => makeRequest("ready", "Choose", "A"), /2..32/);
+});
+test("extension has no page access, remote execution permission, or automatic action script", async () => {
+  const manifest = JSON.parse(await readFile(new URL("../extension/manifest.json", import.meta.url), "utf8"));
+  assert.equal(manifest.manifest_version, 3);
+  assert.deepEqual(manifest.permissions, ["sidePanel"]);
+  assert.equal(manifest.host_permissions, undefined);
+  assert.equal(manifest.content_scripts, undefined);
+  assert.equal(manifest.externally_connectable, undefined);
+  assert.match(manifest.content_security_policy.extension_pages, /connect-src 'self';/);
+  assert.doesNotMatch(manifest.content_security_policy.extension_pages, /'unsafe-eval'|https:|http:|\*/);
+});

sdk/typescript/test/onnx.test.mjs

@@ -51,7 +51,8 @@ test("tokenizer ids, masks, and overflow behavior are explicit", async () => {
     { tokenizer_class: "BertTokenizer", unk_token: "[UNK]", cls_token: "[CLS]", sep_token: "[SEP]", model_max_length: 512 },
   );
   const question = { id: "q", type: "choice", prompt: "Pick", options: ["A/B?", "中文"] };
-  const values = onnx.tokenizeCandidates(tokenizer, "ready", question, question.options, 512);
+  const { candidates: values, liveSequenceLength } = onnx.tokenizeCandidates(tokenizer, "ready", question, question.options, 512);
+  assert.equal(liveSequenceLength, Math.max(values[0].inputIds.length, values[1].inputIds.length));
   assert.deepEqual(values[0].inputIds, [1, 3, 4, 7, 5, 6, 7, 8, 10, 9, 11, 2]);
   assert.deepEqual(values[1].inputIds, [1, 3, 4, 7, 5, 6, 7, 12, 13, 2]);
   assert.equal(values[0].inputIds.length, values[0].attentionMask.length);
@@ -59,6 +60,60 @@ test("tokenizer ids, masks, and overflow behavior are explicit", async () => {
   assert.throws(() => onnx.tokenizeCandidates(tokenizer, "x", question, ["x".repeat(10000)], 4), /bundle limit/);
 });
 
+test("tokenizeCandidates returns the longest live tokenized candidate length, bounded at 512", async () => {
+  const { Tokenizer } = await import("@huggingface/tokenizers");
+  const tokenizer = new Tokenizer(
+    {
+      version: "1.0",
+      added_tokens: [],
+      normalizer: { type: "BertNormalizer", clean_text: true, handle_chinese_chars: true, strip_accents: null, lowercase: true },
+      pre_tokenizer: { type: "BertPreTokenizer" },
+      post_processor: { type: "BertProcessing", sep: ["[SEP]", 2], cls: ["<[BOS_never_used_51bce0c785ca2f68081bfa7d91973934]>", 1] },
+      decoder: { type: "WordPiece", prefix: "##", cleanup: true },
+      model: { type: "WordPiece", unk_token: "[UNK]", continuing_subword_prefix: "##", max_input_chars_per_word: 100,
+        vocab: Object.assign({ "[UNK]": 0, "[CLS]": 1, "[SEP]": 2, "question": 101, "candidate": 102, ":": 103 },
+          Object.fromEntries(Array.from({ length: 50 }, (_, i) => [`t${i}`, i + 3]))) },
+    },
+    { tokenizer_class: "BertTokenizer", unk_token: "[UNK]", cls_token: "[CLS]", sep_token: "[SEP]", model_max_length: 512 },
+  );
+  const shortQuestion = { id: "q", type: "choice", prompt: "Pick", options: ["t0 t1", "t0 t1 t2 t3"] };
+  const short = onnx.tokenizeCandidates(tokenizer, "", shortQuestion, shortQuestion.options, 512);
+  assert.ok(short.liveSequenceLength >= 1);
+  assert.equal(short.liveSequenceLength, Math.max(short.candidates[0].inputIds.length, short.candidates[1].inputIds.length));
+  assert.ok(short.liveSequenceLength <= 512);
+
+  const capped = onnx.tokenizeCandidates(tokenizer, "", shortQuestion, shortQuestion.options, 64);
+  assert.equal(capped.liveSequenceLength, short.liveSequenceLength);
+
+  assert.throws(() => onnx.tokenizeCandidates(tokenizer, "", shortQuestion, shortQuestion.options, 0), /sequenceBudget/);
+  assert.throws(() => onnx.tokenizeCandidates(tokenizer, "", shortQuestion, shortQuestion.options, 513), /sequenceBudget/);
+});
+
+test("variable sequence length regression: widths 64 and 128 produce identical live-token prefixes", async () => {
+  const { Tokenizer } = await import("@huggingface/tokenizers");
+  const tokenizer = new Tokenizer(
+    {
+      version: "1.0",
+      added_tokens: [],
+      normalizer: { type: "BertNormalizer", clean_text: true, handle_chinese_chars: true, strip_accents: null, lowercase: true },
+      pre_tokenizer: { type: "BertPreTokenizer" },
+      post_processor: { type: "BertProcessing", sep: ["[SEP]", 2], cls: ["<[BOS_never_used_51bce0c785ca2f68081bfa7d91973934]>", 1] },
+      decoder: { type: "WordPiece", prefix: "##", cleanup: true },
+      model: { type: "WordPiece", unk_token: "[UNK]", continuing_subword_prefix: "##", max_input_chars_per_word: 100,
+        vocab: { "[UNK]": 0, "[CLS]": 1, "[SEP]": 2, ready: 3, question: 4, pick: 5, candidate: 6, ":": 7, a: 8, b: 9, c: 10, d: 11 } },
+    },
+    { tokenizer_class: "BertTokenizer", unk_token: "[UNK]", cls_token: "[CLS]", sep_token: "[SEP]", model_max_length: 512 },
+  );
+  const question = { id: "q", type: "choice", prompt: "Pick", options: ["a b", "c d"] };
+  const result64 = onnx.tokenizeCandidates(tokenizer, "ready", question, question.options, 64);
+  const result128 = onnx.tokenizeCandidates(tokenizer, "ready", question, question.options, 128);
+  assert.equal(result64.liveSequenceLength, result128.liveSequenceLength);
+  for (let index = 0; index < question.options.length; index += 1) {
+    assert.deepEqual(result64.candidates[index].inputIds, result128.candidates[index].inputIds);
+    assert.deepEqual(result64.candidates[index].attentionMask, result128.candidates[index].attentionMask);
+  }
+});
+
 test("manifest integrity is checked before a runtime session is created", async () => {
   const manifest = testManifest();
   const original = manifest.files.find((item) => item.role === "model_graph");

tests/test_calibration.py

@@ -9,11 +9,14 @@ from vons.calibration import (
     ABSTAIN_ALL_THRESHOLD,
     CALIBRATION_VERSION,
     apply_calibration,
+    apply_vector_calibration,
     calibrate_report,
     fit_abstention_threshold,
     fit_abstention_threshold_details,
+    fit_brier_abstention_threshold_details,
     fit_temperature,
     fit_temperature_details,
+    fit_vector_scaling_details,
 )
 from vons.data import Example, write_jsonl
 from vons.evaluation import METRIC_VERSION, Prediction, nll, summarize, write_report
@@ -46,21 +49,97 @@ class CalibrationTests(unittest.TestCase):
         details = fit_temperature_details(examples, predictions)
         calibrated = apply_calibration(examples, predictions, temperature=details.temperature, abstention_threshold=0.0)
 
-        self.assertAlmostEqual(details.temperature, math.log(1.5) / math.log(3.0), places=6)
+        self.assertGreater(details.temperature, details.lower)
+        self.assertLess(details.temperature, details.upper)
         self.assertEqual(details.rows, 4)
         self.assertFalse(details.at_lower_bound)
         self.assertFalse(details.at_upper_bound)
         self.assertEqual(fit_temperature(examples, predictions), details.temperature)
         self.assertLess(nll(examples, calibrated), nll(examples, predictions))
 
-    def test_temperature_bound_hit_is_flagged(self) -> None:
+    def test_temperature_regularization_prevents_boundary_locking(self) -> None:
         examples = [_example(f"s{index}", "a", True) for index in range(4)]
         predictions = [Prediction(f"s{index}", "a", {"a": 0.9, "b": 0.1}, 0.9, False) for index in range(4)]
 
         details = fit_temperature_details(examples, predictions)
 
-        self.assertTrue(details.at_lower_bound)
-        self.assertAlmostEqual(details.temperature, 0.05)
+        self.assertFalse(details.at_lower_bound)
+        self.assertFalse(details.at_upper_bound)
+        self.assertGreater(details.temperature, 0.1)
+        self.assertLess(details.temperature, 10.0)
+
+        unregularized = fit_temperature_details(
+            examples, predictions, log_temperature_l2=0.0
+        )
+        self.assertTrue(unregularized.at_lower_bound)
+        self.assertAlmostEqual(unregularized.temperature, 0.1)
+
+    def test_vector_scaling_fits_all_classes_inside_bounds(self) -> None:
+        options = ("a", "b", "c", "d")
+        examples = []
+        predictions = []
+        for index, label in enumerate(options * 5):
+            examples.append(
+                Example(
+                    str(index),
+                    "calibration",
+                    "state",
+                    "choose",
+                    options,
+                    label,
+                    True,
+                    "calibration",
+                    {},
+                    {"scenario_id": str(index)},
+                )
+            )
+            probabilities = {option: 0.1 for option in options}
+            probabilities[label] = 0.7
+            predictions.append(
+                Prediction(str(index), label, probabilities, 0.7, False)
+            )
+
+        details = fit_vector_scaling_details(examples, predictions)
+        calibrated = apply_vector_calibration(
+            examples,
+            predictions,
+            temperatures=details.temperatures,
+            biases=details.biases,
+            abstention_threshold=0.0,
+        )
+
+        self.assertEqual(set(details.temperatures), set(options))
+        self.assertTrue(all(0.1 < value < 10.0 for value in details.temperatures.values()))
+        self.assertFalse(details.at_lower_bound)
+        self.assertFalse(details.at_upper_bound)
+        self.assertLess(details.nll_after, details.nll_before)
+        self.assertLess(nll(examples, calibrated), nll(examples, predictions))
+
+    def test_brier_threshold_is_fitted_from_calibrated_losses(self) -> None:
+        examples = [
+            _example("strong", "a", True),
+            _example("weak", "b", True),
+            _example("wrong", "b", True),
+        ]
+        predictions = [
+            Prediction("strong", "a", {"a": 0.95, "b": 0.05}, 0.95, False),
+            Prediction("weak", "b", {"a": 0.4, "b": 0.6}, 0.6, False),
+            Prediction("wrong", "a", {"a": 0.9, "b": 0.1}, 0.9, False),
+        ]
+        parameters = {"a": 1.0, "b": 1.0}
+
+        details = fit_brier_abstention_threshold_details(
+            examples,
+            predictions,
+            temperatures=parameters,
+            biases={"a": 0.0, "b": 0.0},
+            target_brier=0.25,
+        )
+
+        self.assertFalse(details.abstain_all)
+        self.assertEqual(details.target_brier, 0.25)
+        self.assertLessEqual(details.covered_brier, details.target_brier)
+        self.assertGreater(details.threshold, 0.0)
 
     def test_temperature_scaling_preserves_true_zero_support(self) -> None:
         examples = [_example("zero", "a", True)]
@@ -212,15 +291,20 @@ class CalibrationTests(unittest.TestCase):
                 "test_report": test_report,
             }
 
-            calibrate_report(**arguments, output=output, target_risk=0.0)
+            calibrate_report(**arguments, output=output, target_brier=0.2)
             payload = json.loads(output.read_text(encoding="utf-8"), parse_constant=_reject_constant)
 
             fit = payload["calibration"]
             self.assertEqual(fit["version"], CALIBRATION_VERSION)
             self.assertEqual(fit["answerability_threshold"], 0.8)
             self.assertEqual((fit["temperature_fit_rows"], fit["threshold_fit_rows"], fit["rows"]), (2, 3, 3))
-            self.assertTrue(fit["temperature_at_lower_bound"])
+            self.assertEqual(fit["calibration_method"], "vector_scaling")
+            self.assertEqual(set(fit["temperatures"]), {"a", "b"})
+            self.assertEqual(set(fit["biases"]), {"a", "b"})
+            self.assertFalse(fit["temperature_at_lower_bound"])
+            self.assertEqual(fit["target_brier"], 0.2)
             self.assertLessEqual(fit["nll_after"], fit["nll_before"])
+            self.assertLessEqual(fit["brier_after"], fit["brier_before"])
             self.assertEqual(payload["inputs"]["test_report"]["sha256"], hashlib.sha256(test_report.read_bytes()).hexdigest())
             self.assertEqual(payload["model_identity"]["model_id"], "vons-test")
             self.assertTrue(any("checkpoint_sha256 unavailable" in item for item in payload["limitations"]))

tests/test_data.py

@@ -1,5 +1,6 @@
 import tempfile
 import unittest
+from collections import Counter
 from pathlib import Path
 
 from vons.data import dataset_manifest, read_jsonl, smoke_examples, synthetic_examples, write_jsonl
@@ -17,7 +18,25 @@ class DataTests(unittest.TestCase):
     def test_reproducible_generation(self) -> None:
         self.assertEqual([row.to_mapping() for row in synthetic_examples(20, seed=9)], [row.to_mapping() for row in synthetic_examples(20, seed=9)])
 
+    def test_synthetic_generation_balances_all_actions_and_rules(self) -> None:
+        rows = synthetic_examples(200, seed=9)
+        answerable = [row for row in rows if row.answerable]
+        counts = Counter(row.label for row in answerable)
+
+        self.assertEqual(set(counts), {"call_tool", "clarify", "refuse", "respond_directly"})
+        self.assertLessEqual(max(counts.values()) - min(counts.values()), 1)
+        for count in counts.values():
+            self.assertAlmostEqual(count / len(answerable), 0.25, delta=0.01)
+        self.assertTrue(all(row.provenance.get("rule") for row in rows))
+        self.assertGreater(len({row.options.index(row.label) for row in answerable}), 1)
+
+    def test_manifest_reports_label_and_abstention_counts(self) -> None:
+        rows = synthetic_examples(52)
+        manifest = dataset_manifest("synthetic.jsonl", rows)
+
+        self.assertEqual(sum(manifest["labels"].values()) + manifest["unanswerable_rows"], 52)
+        self.assertEqual(set(manifest["labels"]), {"call_tool", "clarify", "refuse", "respond_directly"})
+
 
 if __name__ == "__main__":
     unittest.main()
-

tests/test_diffusion_model.py

@@ -0,0 +1,90 @@
+from itertools import pairwise
+
+import pytest
+
+torch = pytest.importorskip("torch")
+
+from vons.models import ModelConfig, build_model, cosine_beta_schedule
+from vons.training import soft_diffusion_targets
+
+
+def _model(hidden_size=16):
+    return build_model(
+        "diffusion",
+        option_count=32,
+        config=ModelConfig(
+            hidden_size=hidden_size,
+            latent_size=8,
+            diffusion_steps=16,
+            inference_steps=4,
+            attention_heads=2,
+        ),
+    )
+
+
+def test_cosine_schedule_reaches_high_terminal_noise():
+    betas = cosine_beta_schedule(16)
+    alpha_bar = torch.cumprod(1.0 - betas, dim=0)
+
+    assert betas.shape == (16,)
+    assert torch.all(betas[1:] > betas[:-1])
+    assert float(alpha_bar[-1]) < 1e-4
+
+
+@pytest.mark.parametrize(("options", "sequence"), [(3, 7), (5, 11)])
+def test_token_conditioned_head_accepts_dynamic_option_and_sequence_axes(options, sequence):
+    torch.manual_seed(7)
+    model = _model().eval()
+    output = model(
+        torch.randn(2, options),
+        torch.randn(2, options, sequence, 16),
+        torch.ones(2, options, sequence, dtype=torch.bool),
+        torch.tensor([3, 4]),
+        torch.ones(2, options, dtype=torch.bool),
+    )
+
+    assert output["logits"].shape == (2, options)
+    assert output["answerability"].shape == (2,)
+    assert torch.isfinite(output["logits"]).all()
+
+
+def test_soft_targets_are_continuous_normalized_and_masked():
+    labels = torch.tensor([0, 2])
+    option_mask = torch.tensor([[True, True, True, False], [True, True, True, True]])
+
+    targets = soft_diffusion_targets(labels, option_mask, smoothing=0.1)
+
+    torch.testing.assert_close(targets.sum(dim=-1), torch.ones(2))
+    assert torch.all((targets > 0) == option_mask)
+    torch.testing.assert_close(targets[torch.arange(2), labels], torch.tensor([0.9, 0.9]))
+
+
+def test_token_conditioned_soft_target_loss_strictly_decreases():
+    torch.manual_seed(7)
+    batch, options, sequence, hidden = 8, 4, 6, 16
+    model = _model(hidden)
+    sequence_hidden = torch.randn(batch, options, sequence, hidden)
+    attention_mask = torch.ones(batch, options, sequence, dtype=torch.bool)
+    option_mask = torch.ones(batch, options, dtype=torch.bool)
+    labels = torch.arange(batch) % options
+    targets = soft_diffusion_targets(labels, option_mask, smoothing=0.1)
+    noisy_scores = targets * 0.7 + torch.randn_like(targets) * 0.3
+    timestep = torch.full((batch,), 5, dtype=torch.long)
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+    losses = []
+
+    for _ in range(12):
+        optimizer.zero_grad()
+        output = model(
+            noisy_scores,
+            sequence_hidden,
+            attention_mask,
+            timestep,
+            option_mask,
+        )
+        loss = torch.nn.functional.cross_entropy(output["logits"], targets)
+        loss.backward()
+        optimizer.step()
+        losses.append(float(loss.detach()))
+
+    assert all(current < previous for previous, current in pairwise(losses))

tests/test_inference.py

@@ -0,0 +1,323 @@
+"""Regression tests for runtime inference helpers.
+
+Covers the public task-1 contract:
+
+* Tensors use the longest live tokenized candidate in the request, bounded at 512.
+* Exported and runtime ONNX metadata preserves dynamic ``sequence_length``
+  and dynamic ``live_candidates`` / ``options`` when the contract supports it.
+* Variable-length regression for shapes [1, X, 64] and [1, X, 128] produces
+  equivalent candidate scores when padded inputs are identical (i.e. the same
+  prefix of tokens in both cases).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pytest
+
+from vons.contract import Backend
+from vons.inference import (
+    MAX_SEQUENCE_BUDGET,
+    TokenizedCandidate,
+    candidate_text,
+    compute_live_sequence_length,
+    pad_candidates,
+    prepare_question_tensors,
+    resolve_allocated_slots,
+    serialize_state,
+    tokenize_candidates,
+)
+
+
+@dataclass
+class _StubTokenizer:
+    """Word-Piece-like stub with the exact tokens the tests need."""
+
+    vocab: dict[str, int]
+    pad_token_id: int = 0
+    cls_token_id: int = 1
+    sep_token_id: int = 2
+
+    def encode(self, text, **_kwargs):
+        ids = [self.cls_token_id]
+        for chunk in text.split():
+            ids.append(self.vocab.get(chunk.lower(), self.vocab.get("[UNK]", 0)))
+        ids.append(self.sep_token_id)
+        attention_mask = [1] * len(ids)
+        token_type_ids = [0] * len(ids)
+
+        class _Result:
+            pass
+
+        result = _Result()
+        result.ids = ids
+        result.attention_mask = attention_mask
+        result.token_type_ids = token_type_ids
+        return result
+
+
+def _tokenizer():
+    vocab = {
+        "[UNK]": 0,
+        "ready": 3,
+        "question": 4,
+        "pick": 5,
+        "candidate": 6,
+        ":": 7,
+        "a": 8,
+        "b": 9,
+        "/": 10,
+        "?": 11,
+        "中": 12,
+        "文": 13,
+        "long": 14,
+        "option": 15,
+        "label": 16,
+        "three": 17,
+        "words": 18,
+        "here": 19,
+        "yes": 20,
+        "no": 21,
+        "{": 22,
+        "}": 23,
+        '"z"': 24,
+        "1": 25,
+        '"a"': 26,
+        '"x"': 27,
+        "2": 28,
+        "question:": 4,
+        "candidate:": 6,
+    }
+    return _StubTokenizer(vocab)
+
+
+class _ObjectQuestion:
+    def __init__(self, qid: str, qtype: str, prompt: str, options: tuple[str, ...]):
+        self.id = qid
+        self.type = qtype
+        self.prompt = prompt
+        self.options = options
+
+
+class _ObjectRequest:
+    def __init__(self, state, questions: list[_ObjectQuestion], backend=Backend.DIRECT, seed=None):
+        self.state = state
+        self.questions = tuple(questions)
+        self.backend = backend
+        self.seed = seed
+
+
+def _question(qid="q", prompt="Pick", options=("A", "B"), qtype="choice"):
+    return _ObjectQuestion(qid, qtype, prompt, tuple(options))
+
+
+def _request(state="ready", questions=None, backend=Backend.DIRECT, seed=None):
+    return _ObjectRequest(state, questions or [_question()], backend, seed)
+
+
+def test_serialize_state_sorts_object_keys_for_determinism() -> None:
+    assert serialize_state({"z": 1, "a": ["x", 2]}) == '{"a":["x",2],"z":1}'
+    assert serialize_state("already a string") == "already a string"
+
+
+def test_candidate_text_template_matches_web_runtime() -> None:
+    question = _question(prompt="Pick", options=("A",))
+    assert (
+        candidate_text({"z": 1, "a": ["x", 2]}, question, "A")
+        == '{"a":["x",2],"z":1}\nQuestion: Pick\nCandidate: A'
+    )
+
+
+def test_tokenize_candidates_rejects_over_budget_aggregate(tmp_path) -> None:
+    tokenizer = _tokenizer()
+    question = _question(options=("A/B?", "中文"))
+    with pytest.raises(ValueError, match="aggregate input budget"):
+        tokenize_candidates(tokenizer, "ready", question, question.options, max_sequence_budget=3)
+
+
+def test_compute_live_sequence_length_picks_longest_live_candidate() -> None:
+    short = TokenizedCandidate((1, 2), (1, 1), (0, 0))
+    medium = TokenizedCandidate((1, 3, 2), (1, 1, 1), (0, 0, 0))
+    long = TokenizedCandidate((1, 3, 4, 2), (1, 1, 1, 1), (0, 0, 0, 0))
+    assert compute_live_sequence_length([short, medium, long]) == 4
+    assert compute_live_sequence_length([short, medium]) == 3
+    assert compute_live_sequence_length([short]) == 2
+
+
+def test_compute_live_sequence_length_clamps_to_manifest_budget() -> None:
+    many = TokenizedCandidate(tuple(range(512)), (1,) * 512, (0,) * 512)
+    assert compute_live_sequence_length([many]) == 512
+    assert compute_live_sequence_length([many], max_sequence_budget=64) == 64
+
+
+def test_compute_live_sequence_length_rejects_empty_candidates() -> None:
+    with pytest.raises(ValueError, match="at least one tokenized candidate"):
+        compute_live_sequence_length([])
+
+
+def test_pad_candidates_uses_exact_live_sequence_length() -> None:
+    tokenized = [
+        TokenizedCandidate((1, 8, 2), (1, 1, 1), (0, 0, 0)),
+        TokenizedCandidate((1, 9, 2), (1, 1, 1), (0, 0, 0)),
+    ]
+    input_ids, attention, token_types, option_mask = pad_candidates(
+        tokenized,
+        slots=4,
+        live_sequence_length=3,
+        padding_id=0,
+    )
+    assert [len(row) for row in input_ids] == [3, 3, 3, 3]
+    assert option_mask == [1, 1, 0, 0]
+    assert input_ids[0][:3] == [1, 8, 2]
+    assert attention[2] == [0, 0, 0]
+    assert token_types[1] == [0, 0, 0]
+
+
+def test_pad_candidates_rejects_fewer_slots_than_live_candidates() -> None:
+    tokenized = [
+        TokenizedCandidate((1, 2), (1, 1), (0, 0)),
+        TokenizedCandidate((1, 2), (1, 1), (0, 0)),
+    ]
+    with pytest.raises(ValueError, match="slots must be at least"):
+        pad_candidates(tokenized, slots=1, live_sequence_length=2, padding_id=0)
+
+
+def test_resolve_allocated_slots_diffusion_always_uses_option_count() -> None:
+    assert resolve_allocated_slots(Backend.DIFFUSION, 2, option_count=32) == 32
+    assert resolve_allocated_slots(Backend.DIFFUSION, 16, option_count=32) == 32
+
+
+def test_resolve_allocated_slots_direct_defaults_to_live_count() -> None:
+    assert resolve_allocated_slots(Backend.DIRECT, 3, option_count=32) == 3
+    assert resolve_allocated_slots(Backend.DIRECT, 12, option_count=32) == 12
+
+
+def test_resolve_allocated_slots_direct_honours_explicit_slot_override() -> None:
+    assert (
+        resolve_allocated_slots(
+            Backend.DIRECT,
+            2,
+            option_count=32,
+            direct_option_slots=8,
+        )
+        == 8
+    )
+
+
+def test_resolve_allocated_slots_direct_rejects_invalid_slot_override() -> None:
+    with pytest.raises(ValueError, match="direct_option_slots must be in"):
+        resolve_allocated_slots(
+            Backend.DIRECT,
+            4,
+            option_count=8,
+            direct_option_slots=16,
+        )
+
+
+def test_prepare_question_tensors_uses_dynamic_live_length(tmp_path) -> None:
+    tokenizer = _tokenizer()
+    request = _request(state="ready", questions=[_question(options=("yes", "no"))])
+    padded, raw = prepare_question_tensors(
+        tokenizer,
+        request,
+        request.questions[0],
+        option_count=32,
+    )
+    assert padded.live_sequence_length == max(item.token_count for item in raw)
+    assert padded.live_sequence_length <= padded.max_sequence_budget
+    for row in padded.input_ids:
+        assert len(row) == padded.live_sequence_length
+
+
+def test_variable_length_regression_64_and_128_agree_on_identical_prefix() -> None:
+    """Padded tensors of width 64 and 128 with identical tokens are equal.
+
+    The exported heads are pure feed-forward networks that only attend to
+    live tokens via attention_mask. Feeding identical live tokens at two
+    different sequence widths must yield the same probability ordering when
+    the unpadded content is the same.
+    """
+
+    def _prefix(width: int):
+        ids = [1, 8, 9, 2] + [0] * max(0, width - 4)
+        mask = [1, 1, 1, 1] + [0] * max(0, width - 4)
+        types = [0] * width
+        return TokenizedCandidate(tuple(ids), tuple(mask), tuple(types))
+
+    tokenized_64 = [_prefix(64) for _ in range(3)]
+    tokenized_128 = [_prefix(128) for _ in range(3)]
+    padded_64 = pad_candidates(tokenized_64, slots=8, live_sequence_length=64, padding_id=0)
+    padded_128 = pad_candidates(tokenized_128, slots=8, live_sequence_length=128, padding_id=0)
+
+    for option_index in range(3):
+        first_64 = padded_64[0][option_index][:4]
+        first_128 = padded_128[0][option_index][:4]
+        assert first_64 == first_128, "live token content must match"
+        assert padded_64[1][option_index][:4] == [1, 1, 1, 1]
+        assert padded_128[1][option_index][:4] == [1, 1, 1, 1]
+
+    assert len(padded_64[0][0]) == 64
+    assert len(padded_128[0][0]) == 128
+    assert padded_64[3] == [1, 1, 1, 0, 0, 0, 0, 0]
+    assert padded_128[3] == [1, 1, 1, 0, 0, 0, 0, 0]
+
+
+def test_variable_length_regression_long_candidate_drives_width() -> None:
+    tokenizer = _tokenizer()
+    short_options = ("A", "B")
+    long_options = (
+        "long option label here three words",
+        "long option label here three words plus padding",
+    )
+    short_question = _question(options=short_options)
+    long_question = _question(options=long_options)
+    short, _ = prepare_question_tensors(
+        tokenizer,
+        _request(questions=[short_question]),
+        short_question,
+        option_count=32,
+    )
+    long, _ = prepare_question_tensors(
+        tokenizer,
+        _request(questions=[long_question]),
+        long_question,
+        option_count=32,
+    )
+    assert 1 <= short.live_sequence_length < long.live_sequence_length
+    assert long.live_sequence_length <= 512
+
+
+def test_max_sequence_budget_is_512_and_clamps() -> None:
+    assert MAX_SEQUENCE_BUDGET == 512
+    very_long = tuple(range(512))
+    many = [
+        TokenizedCandidate(very_long, (1,) * 512, (0,) * 512),
+        TokenizedCandidate((1, 2), (1, 1), (0, 0)),
+    ]
+    assert compute_live_sequence_length(many) == 512
+
+
+def test_prepare_question_tensors_rejects_over_budget() -> None:
+    tokenizer = _tokenizer()
+    options = ("A",) * 33
+    question = _question(options=options)
+    with pytest.raises(ValueError, match="unsupported candidate count"):
+        prepare_question_tensors(
+            tokenizer,
+            _request(questions=[question]),
+            question,
+            option_count=32,
+        )
+
+
+def test_pad_candidates_preserves_padding_id_outside_live_tokens() -> None:
+    tokenized = [TokenizedCandidate((1, 5, 2), (1, 1, 1), (0, 0, 0))]
+    ids, _att, _ttypes, _omask = pad_candidates(
+        tokenized,
+        slots=2,
+        live_sequence_length=5,
+        padding_id=42,
+    )
+    assert ids[1] == [42, 42, 42, 42, 42]
+    assert ids[0][3:5] == [42, 42]

tests/test_mind2web_adapter.py

@@ -0,0 +1,101 @@
+import json
+from dataclasses import dataclass
+
+from vons.mind2web_adapter import compress_request, strip_dom_presentation
+
+
+@dataclass
+class Encoding:
+    ids: list[int]
+
+
+class WordTokenizer:
+    def __init__(self) -> None:
+        self.tokens: dict[str, int] = {}
+        self.reverse: dict[int, str] = {}
+
+    def encode(self, text: str) -> Encoding:
+        ids = []
+        for token in text.split():
+            if token not in self.tokens:
+                index = len(self.tokens) + 1
+                self.tokens[token] = index
+                self.reverse[index] = token
+            ids.append(self.tokens[token])
+        return Encoding(ids)
+
+    def decode(self, ids: list[int], skip_special_tokens: bool = True) -> str:
+        del skip_special_tokens
+        return " ".join(self.reverse[index] for index in ids)
+
+
+def test_dom_compressor_keeps_semantics_and_removes_presentation() -> None:
+    raw = (
+        'button class="large primary" style="color:red" id=save '
+        'type=submit aria-label="Save" data-tracking=secret Save changes '
+        "<svg class=icon><path id=shape /></svg>"
+    )
+    compressed = strip_dom_presentation(raw)
+    assert compressed.startswith("button")
+    assert "id=save" in compressed
+    assert "type=submit" in compressed
+    assert 'aria-label="Save"' in compressed
+    assert "Save changes" in compressed
+    assert "class=" not in compressed
+    assert "style=" not in compressed
+    assert "data-tracking=" not in compressed
+    assert "svg" not in compressed.lower()
+
+
+def test_compress_request_enforces_history_candidate_and_total_budgets() -> None:
+    tokenizer = WordTokenizer()
+    request = {
+        "state": json.dumps(
+            {
+                "goal": " ".join(f"goal-{index}" for index in range(80)),
+                "previous_actions": [f"action-{index}" for index in range(5)],
+            }
+        ),
+        "question": "choose the next element",
+        "candidates": [
+            {
+                "id": str(index),
+                "text": "button class=decorative id=target "
+                + " ".join(f"visible-{part}" for part in range(20)),
+            }
+            for index in range(8)
+        ],
+    }
+    compressed, stats = compress_request(
+        request,
+        tokenizer,
+        max_prompt_tokens=40,
+        max_candidate_tokens=3,
+    )
+    state = json.loads(compressed["state"])
+    assert len(state["previous_actions"]) <= 2
+    assert stats.history_actions_before == 5
+    assert stats.history_actions_after <= 2
+    assert stats.prompt_tokens <= 40
+    assert stats.max_candidate_tokens <= 3
+    assert all(
+        len(tokenizer.encode(candidate["text"]).ids) <= 3
+        for candidate in compressed["candidates"]
+    )
+
+
+def test_compress_request_preserves_last_two_actions_when_they_fit() -> None:
+    tokenizer = WordTokenizer()
+    request = {
+        "state": {
+            "goal": "save the form",
+            "previous_actions": ["first", "second", "third", "fourth"],
+        },
+        "question": "choose",
+        "candidates": [{"id": "save", "text": "button id=save Save"}],
+    }
+    compressed, stats = compress_request(request, tokenizer)
+    state = json.loads(compressed["state"])
+    assert state["previous_actions"] == ["third", "fourth"]
+    assert stats.history_actions_after == 2
+    assert stats.prompt_tokens <= 512

tests/test_mind2web_prediction.py

@@ -35,6 +35,7 @@ def test_exact_k_and_label_free_contract():
 def test_decode_abstention_finite_and_ids():
     result = module.decode([0, 10], 10, ["first", "second"])
     assert result["selection"] == "second"
+    assert result["abstention_threshold"] == pytest.approx(0.55 / 2)
     assert sum(result["probabilities"].values()) == pytest.approx(1)
     assert module.decode([0, 10], -10, ["first", "second"])["selection"] is None
     with pytest.raises(ValueError, match="invalid scores"):

tests/test_onnx_export.py

@@ -0,0 +1,374 @@
+"""Verify exported ONNX graphs preserve dynamic sequence and option axes.
+
+The public contract for task 1 requires:
+
+* Exported graphs declare dynamic ``sequence_length`` dimensions for the
+  three token tensors (``input_ids``, ``attention_mask``, ``token_type_ids``)
+  when the conditioning supports it.
+* Diffusion heads additionally declare dynamic ``options`` /
+  ``live_candidates`` dimensions so a single graph can serve requests
+  whose option counts vary within the manifest budget.
+* Legacy manifests record ``dynamic_sequence_length`` and
+  ``dynamic_options`` so downstream runtimes can fall back to static
+  padding when the legacy manifest is the only metadata source.
+* Dynamic axes survive the full save/load round trip through the ONNX
+  protobuf wire format; a tensor with a fixed shape dimension is rejected
+  if it was supposed to be dynamic.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from vons.bundle import _value_infos
+
+
+def _make_identity_graph(onnx, shape_template, name_prefix: str = "t"):
+    """Create a tiny ONNX graph whose inputs match ``shape_template``.
+
+    Each integer is a static dimension; each string is a named dynamic
+    dimension parameter (what ``dynamic_axes`` produced).
+    """
+
+    from onnx import TensorProto, helper
+
+    def _tensor_info(name: str, shape):
+        dims = []
+        for value in shape:
+            dim = onnx.TensorShapeProto.Dimension()
+            if isinstance(value, str):
+                dim.dim_param = value
+            elif isinstance(value, int):
+                dim.dim_value = value
+            else:
+                raise TypeError(f"invalid shape element: {value!r}")
+            dims.append(dim)
+        tensor_type = onnx.TypeProto.Tensor()
+        tensor_type.elem_type = TensorProto.FLOAT
+        tensor_type.shape.dim.extend(dims)
+        value_info = helper.make_tensor_value_info(name, TensorProto.FLOAT, None)
+        value_info.type.tensor_type.CopyFrom(tensor_type)
+        return value_info
+
+    inputs = [
+        _tensor_info(f"{name_prefix}_input_{index}", shape)
+        for index, shape in enumerate(shape_template)
+    ]
+    outputs = [
+        helper.make_tensor_value_info(f"{name_prefix}_output_{index}", TensorProto.FLOAT, None)
+        for index, shape in enumerate(shape_template)
+    ]
+    for index, shape in enumerate(shape_template):
+        dims = []
+        for value in shape:
+            dim = onnx.TensorShapeProto.Dimension()
+            if isinstance(value, str):
+                dim.dim_param = value
+            else:
+                dim.dim_value = value
+            dims.append(dim)
+        tensor_type = onnx.TypeProto.Tensor()
+        tensor_type.elem_type = TensorProto.FLOAT
+        tensor_type.shape.dim.extend(dims)
+        outputs[index].type.tensor_type.CopyFrom(tensor_type)
+    nodes = [
+        onnx.helper.make_node(
+            "Identity",
+            [inputs[index].name],
+            [outputs[index].name],
+            name=f"id_{index}",
+        )
+        for index in range(len(shape_template))
+    ]
+    graph = helper.make_graph(nodes, f"{name_prefix}_graph", inputs, outputs)
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 18)])
+    model.ir_version = 9
+    return model
+
+
+def _save_and_reload(tmp_path: Path, model, onnx):
+    graph_path = tmp_path / "graph.onnx"
+    onnx.save_model(model, graph_path)
+    return onnx.load_model(str(graph_path), load_external_data=False)
+
+
+def test_direct_graph_declares_dynamic_options_and_sequence(tmp_path: Path) -> None:
+    """Full direct bundles declare options + sequence as dynamic strings."""
+    onnx = pytest.importorskip("onnx")
+
+    direct_inputs = [
+        [1, "options", "sequence_length"],
+        [1, "options", "sequence_length"],
+        [1, "options", "sequence_length"],
+        [1, "options"],
+    ]
+    model = _make_identity_graph(onnx, direct_inputs, name_prefix="direct")
+    reloaded = _save_and_reload(tmp_path, model, onnx)
+
+    infos = _value_infos(reloaded.graph.input, onnx)
+    input_ids_info = next(info for info in infos if info["name"] == "direct_input_0")
+    option_mask_info = next(info for info in infos if info["name"] == "direct_input_3")
+
+    assert input_ids_info["shape"] == [1, "options", "sequence_length"]
+    assert option_mask_info["shape"] == [1, "options"]
+
+
+def test_diffusion_graph_declares_dynamic_options_and_sequence(tmp_path: Path) -> None:
+    """Token-conditioned diffusion graphs mirror the direct tensor shapes."""
+    onnx = pytest.importorskip("onnx")
+
+    diffusion_inputs = [
+        [1, "options", "sequence_length"],
+        [1, "options", "sequence_length"],
+        [1, "options", "sequence_length"],
+        [1, "options"],
+        [1, "options"],
+    ]
+    model = _make_identity_graph(onnx, diffusion_inputs, name_prefix="diff")
+    reloaded = _save_and_reload(tmp_path, model, onnx)
+
+    infos = _value_infos(reloaded.graph.input, onnx)
+    sequence_shapes = [infos[i]["shape"] for i in range(3)]
+    option_shapes = [infos[i]["shape"] for i in (3, 4)]
+    for shape in sequence_shapes:
+        assert shape == [1, "options", "sequence_length"]
+    for shape in option_shapes:
+        assert shape == [1, "options"]
+
+
+def test_static_sequence_dimension_is_rejected_when_dynamic_is_required(tmp_path: Path) -> None:
+    """Regression guard: a static 512 in the graph breaks the runtime.
+
+    The manifest may still record a ``sequence_length: 512`` default budget,
+    but the actual ONNX graph must keep the sequence dimension dynamic so
+    padding to 64, 128, ... works without re-exporting weights.
+    """
+    onnx = pytest.importorskip("onnx")
+
+    mixed = [
+        [1, "options", 512],
+        [1, "options", "sequence_length"],
+    ]
+    model = _make_identity_graph(onnx, mixed, name_prefix="mix")
+    reloaded = _save_and_reload(tmp_path, model, onnx)
+
+    infos = _value_infos(reloaded.graph.input, onnx)
+    first_static = infos[0]["shape"]
+    second_dynamic = infos[1]["shape"]
+    assert isinstance(first_static[2], int) and first_static[2] == 512
+    assert second_dynamic[2] == "sequence_length"
+    dynamic_sequence_count = sum(
+        1 for info in infos if len(info["shape"]) >= 3 and info["shape"][2] == "sequence_length"
+    )
+    assert dynamic_sequence_count == 1, "graph should have exactly one dynamic sequence tensor"
+
+
+def test_dynamic_dimension_names_round_trip_through_save(tmp_path: Path) -> None:
+    onnx = pytest.importorskip("onnx")
+
+    shapes = [[1, "live_candidates", "sequence_length"]]
+    model = _make_identity_graph(onnx, shapes, name_prefix="rt")
+    reloaded = _save_and_reload(tmp_path, model, onnx)
+
+    infos = _value_infos(reloaded.graph.input, onnx)
+    shape = infos[0]["shape"]
+    assert shape[1] == "live_candidates"
+    assert shape[2] == "sequence_length"
+
+
+def test_legacy_manifest_records_dynamic_flags(tmp_path: Path) -> None:
+    manifest = {
+        "format": "onnx",
+        "backend": "diffusion",
+        "option_count": 32,
+        "sequence_length": 512,
+        "dynamic_options": True,
+        "dynamic_sequence_length": True,
+        "diffusion_conditioning": "token_cross_attention",
+        "input_names": [
+            "input_ids",
+            "attention_mask",
+            "token_type_ids",
+            "option_mask",
+            "initial_noise",
+        ],
+    }
+    manifest_path = tmp_path / "bundle-manifest.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    reloaded = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+    assert reloaded["dynamic_options"] is True
+    assert reloaded["dynamic_sequence_length"] is True
+    assert reloaded["sequence_length"] == 512
+    assert reloaded["option_count"] == 32
+
+
+def test_pooled_diffusion_manifest_keeps_static_options(tmp_path: Path) -> None:
+    """Pooled conditioning uses a fixed option count in its head shape."""
+    manifest = {
+        "format": "onnx",
+        "backend": "diffusion",
+        "option_count": 32,
+        "sequence_length": 512,
+        "dynamic_options": False,
+        "dynamic_sequence_length": False,
+        "diffusion_conditioning": "pooled",
+    }
+    manifest_path = tmp_path / "bundle-manifest.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    reloaded = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+    assert reloaded["dynamic_options"] is False
+    assert reloaded["dynamic_sequence_length"] is False
+
+
+def test_shape_helper_handles_dynamic_and_static_dimensions() -> None:
+    class _Dim:
+        def __init__(self, *, value=None, param=None):
+            self._value = value
+            self._param = param
+
+        def HasField(self, name):
+            if name == "dim_value":
+                return self._value is not None
+            if name == "dim_param":
+                return self._param is not None
+            return False
+
+        @property
+        def dim_value(self):
+            return self._value
+
+        @property
+        def dim_param(self):
+            return self._param
+
+    class _Shape:
+        def __init__(self, dims):
+            self.dim = [_Dim(value=d) if isinstance(d, int) else _Dim(param=d) for d in dims]
+
+        def HasField(self, name):
+            return name == "dim"
+
+    class _TensorType:
+        def __init__(self, dims):
+            self.shape = _Shape(dims)
+            self.elem_type = 1
+
+        def HasField(self, name):
+            return name == "shape"
+
+    class _ValueInfo:
+        def __init__(self, name, dims):
+            self.name = name
+
+            class _Type:
+                def __init__(self, dims):
+                    self.tensor_type = _TensorType(dims)
+
+            self.type = _Type(dims)
+
+    class _FakeOnnx:
+        TensorProto = type("TensorProto", (), {"DataType": type("DataType", (), {"Name": staticmethod(lambda x: f"type_{x}")})})
+
+    values = [_ValueInfo("ids", [1, "options", "sequence_length"]), _ValueInfo("mask", [4, 32, 512])]
+    infos = _value_infos(values, _FakeOnnx())
+
+    assert infos[0]["shape"] == [1, "options", "sequence_length"]
+    assert infos[1]["shape"] == [4, 32, 512]
+    assert infos[0]["name"] == "ids"
+
+
+def test_variable_export_sequence_width_64_and_128(tmp_path: Path) -> None:
+    """Regression: the same export code path can generate 64-wide or
+    128-wide example tensors, but the resulting graph keeps the real
+    sequence dimension dynamic (``sequence_length`` string) regardless of
+    the concrete dummy-tensor width used at trace time.
+    """
+    onnx = pytest.importorskip("onnx")
+
+    def _trace(width: int):
+        return _make_identity_graph(
+            onnx,
+            [[1, "options", "sequence_length"], [1, "options"]],
+            name_prefix=f"w{width}",
+        )
+
+    graph_64 = _trace(64)
+    graph_128 = _trace(128)
+    (tmp_path / "width-64").mkdir()
+    (tmp_path / "width-128").mkdir()
+    reloaded_64 = _save_and_reload(tmp_path / "width-64", graph_64, onnx)
+    reloaded_128 = _save_and_reload(tmp_path / "width-128", graph_128, onnx)
+
+    infos_64 = _value_infos(reloaded_64.graph.input, onnx)
+    infos_128 = _value_infos(reloaded_128.graph.input, onnx)
+
+    for infos in (infos_64, infos_128):
+        assert infos[0]["shape"] == [1, "options", "sequence_length"]
+        assert infos[1]["shape"] == [1, "options"]
+
+
+def test_dynamic_graph_executes_widths_64_and_128(tmp_path: Path) -> None:
+    """A single dynamic graph accepts both widths with identical live output."""
+    np = pytest.importorskip("numpy")
+    onnx = pytest.importorskip("onnx")
+    ort = pytest.importorskip("onnxruntime")
+    from onnx import TensorProto, helper
+
+    input_ids = helper.make_tensor_value_info(
+        "input_ids",
+        TensorProto.INT64,
+        [1, "options", "sequence_length"],
+    )
+    attention_mask = helper.make_tensor_value_info(
+        "attention_mask",
+        TensorProto.INT64,
+        [1, "options", "sequence_length"],
+    )
+    scores = helper.make_tensor_value_info(
+        "scores",
+        TensorProto.INT64,
+        [1, "options"],
+    )
+    graph = helper.make_graph(
+        [
+            helper.make_node("Mul", ["input_ids", "attention_mask"], ["masked"]),
+            helper.make_node(
+                "ReduceSum",
+                ["masked"],
+                ["scores"],
+                axes=[2],
+                keepdims=0,
+            ),
+        ],
+        "dynamic_sequence_execution",
+        [input_ids, attention_mask],
+        [scores],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 11)])
+    model.ir_version = 9
+    graph_path = tmp_path / "dynamic-sequence.onnx"
+    onnx.save_model(model, graph_path)
+    onnx.checker.check_model(model)
+    session = ort.InferenceSession(str(graph_path), providers=["CPUExecutionProvider"])
+
+    outputs = []
+    for width in (64, 128):
+        ids = np.zeros((1, 2, width), dtype=np.int64)
+        mask = np.zeros_like(ids)
+        ids[0, 0, :4] = [1, 7, 11, 2]
+        ids[0, 1, :4] = [1, 5, 13, 2]
+        mask[:, :, :4] = 1
+        result = session.run(
+            None,
+            {"input_ids": ids, "attention_mask": mask},
+        )[0]
+        assert result.shape == (1, 2)
+        assert np.isfinite(result).all()
+        outputs.append(result)
+
+    np.testing.assert_array_equal(outputs[0], outputs[1])

tools/index_mind2web_predictions.py

@@ -0,0 +1,110 @@
+"""Build a checked run index for a complete Mind2Web prediction matrix."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+SPLITS = ("test_task", "test_website", "test_domain")
+KS = (5, 10, 20, 32)
+
+
+def file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _object(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise TypeError(f"{path}: expected a JSON object")
+    return value
+
+
+def build_index(prediction_dir: Path, retriever: Path) -> dict[str, Any]:
+    runs: list[dict[str, Any]] = []
+    runner_hashes: set[str] = set()
+    source_hashes: set[str] = set()
+    for split in SPLITS:
+        for k in KS:
+            prediction = prediction_dir / f"{split}-k{k}.jsonl"
+            manifest_path = prediction.with_suffix(".manifest.json")
+            if not prediction.is_file() or not manifest_path.is_file():
+                raise ValueError(f"missing prediction cell: {split}/k={k}")
+            manifest = _object(manifest_path)
+            config = manifest.get("config")
+            if not isinstance(config, dict) or config.get("split") != split or config.get("k") != k:
+                raise ValueError(f"prediction manifest identity mismatch: {split}/k={k}")
+            digest = file_hash(prediction)
+            if manifest.get("predictions_sha256") != digest:
+                raise ValueError(f"prediction hash mismatch: {split}/k={k}")
+            rows = manifest.get("rows")
+            counts = manifest.get("counts")
+            if (
+                isinstance(rows, bool)
+                or not isinstance(rows, int)
+                or rows <= 0
+                or not isinstance(counts, dict)
+                or sum(counts.values()) != rows
+            ):
+                raise ValueError(f"invalid row counts: {split}/k={k}")
+            runner_hash = manifest.get("runner_sha256")
+            source_hash = manifest.get("source_sha256")
+            if not isinstance(runner_hash, str) or re.fullmatch(r"[0-9a-f]{64}", runner_hash) is None:
+                raise ValueError("invalid prediction runner hash")
+            if not isinstance(source_hash, str) or re.fullmatch(r"[0-9a-f]{64}", source_hash) is None:
+                raise ValueError("invalid retrieval source hash")
+            runner_hashes.add(runner_hash)
+            source_hashes.add(source_hash)
+            runs.append(
+                {
+                    "split": split,
+                    "k": k,
+                    "rows": rows,
+                    "counts": counts,
+                    "predictions_sha256": digest,
+                }
+            )
+    retriever_hash = file_hash(retriever)
+    if source_hashes != {retriever_hash}:
+        raise ValueError("prediction manifests do not match the retriever source")
+    if len(runner_hashes) != 1:
+        raise ValueError("prediction matrix uses multiple runner versions")
+    return {
+        "schema": "vons.mind2web-prediction-index/v1",
+        "runs": runs,
+        "source_sha256": retriever_hash,
+        "runner_sha256": next(iter(runner_hashes)),
+        "scope": (
+            "complete exact-k Direct action-target matrix with label-free context compression; "
+            "no test-set adaptation or browser task execution"
+        ),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--prediction-dir", type=Path, required=True)
+    parser.add_argument("--retriever", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    if args.output.exists():
+        raise ValueError("refusing to overwrite prediction index")
+    index = build_index(args.prediction_dir, args.retriever)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(index, indent=2, ensure_ascii=False, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps({"runs": len(index["runs"]), "output": str(args.output)}))
+
+
+if __name__ == "__main__":
+    main()

tools/predict_mind2web.py

@@ -1,8 +1,9 @@
 """Generate real, separate k-specific Mind2Web selections without reading labels.
 
-Strict 512-token question budget: overflow is an observed error, never silently
-truncated. Outputs stay local because candidate text comes from restricted data.
-The lexical baseline bypasses Vons' input contract and is labeled accordingly.
+The v1 context adapter applies label-free DOM/history compression and validates
+the exact runtime token count before inference. Outputs stay local because
+candidate text comes from restricted data. The lexical baseline bypasses Vons'
+input contract and is labeled accordingly.
 """
 
 from __future__ import annotations
@@ -16,9 +17,17 @@ import re
 import time
 from collections import Counter
 from collections.abc import Callable
+from dataclasses import asdict
 from pathlib import Path
 from typing import Any
 
+from vons.mind2web_adapter import (
+    MAX_CANDIDATE_TOKENS,
+    MAX_HISTORY_ACTIONS,
+    MAX_PROMPT_TOKENS,
+    compress_request,
+)
+
 QUESTION = "Which element should the agent interact with next to achieve the goal?"
 KS = (5, 10, 20, 32)
 
@@ -66,7 +75,7 @@ def make_request(row: dict[str, Any], k: int) -> dict[str, Any]:
 
 
 def decode(scores: list[float], answerability_logit: float,
-           ids: list[str], threshold: float = 0.55) -> dict[str, Any]:
+           ids: list[str], threshold: float | None = None) -> dict[str, Any]:
     if len(scores) != len(ids) or not ids or not all(math.isfinite(x) for x in scores):
         raise ModelOutputError("model returned invalid scores")
     if not math.isfinite(answerability_logit):
@@ -79,11 +88,15 @@ def decode(scores: list[float], answerability_logit: float,
     answerability = 1 / (1 + z) if answerability_logit >= 0 else z / (1 + z)
     index = max(range(len(ids)), key=probabilities.__getitem__)
     confidence = probabilities[index] * answerability
+    resolved_threshold = 0.55 / len(ids) if threshold is None else float(threshold)
+    if not math.isfinite(resolved_threshold) or not 0.0 <= resolved_threshold <= 1.0:
+        raise ValueError("threshold must be finite and in [0, 1]")
     reason = ("answerability_below_threshold" if answerability < 0.5 else
-              "confidence_below_threshold" if confidence < threshold else None)
+              "confidence_below_threshold" if confidence < resolved_threshold else None)
     return {"selection": ids[index] if reason is None else None,
             "status": "ok" if reason is None else "abstain", "reason": reason,
             "probabilities": dict(zip(ids, probabilities)), "confidence": confidence,
+            "abstention_threshold": resolved_threshold,
             "answerability": answerability, "raw_scores": scores,
             "answerability_logit": answerability_logit}
 
@@ -116,25 +129,29 @@ class DirectSelector:
         self.provenance = {"backend": "direct", "model_manifest_sha256": expected_digest,
                            "tokenizer_sha256": file_hash(manifest.parent / "tokenizer/tokenizer.json"),
                            "ort_version": ort.__version__, "provider": "CPUExecutionProvider",
-                           "calibration": "none; historical default thresholds 0.55/0.5",
+                           "calibration": "none; candidate-normalized 0.55/k confidence and 0.5 answerability",
                            "threads": 1, "sequence_padding": "longest candidate input",
-                           "candidate_padding": "live", "input_budget_tokens": 512}
+                           "candidate_padding": "live", "input_budget_tokens": MAX_PROMPT_TOKENS,
+                           "context_adapter": "vons.mind2web-context/v1", "adapted": True,
+                           "max_candidate_tokens": MAX_CANDIDATE_TOKENS,
+                           "history_window": MAX_HISTORY_ACTIONS}
 
     def __call__(self, request: dict[str, Any]) -> dict[str, Any]:
         np = self.np
-        candidates = request["candidates"]
+        inference_request, compression = compress_request(request, self.tokenizer)
+        candidates = inference_request["candidates"]
         if not 2 <= len(candidates) <= 32:
             raise ValueError("candidate_count_outside_2_32")
-        prefix = f'{request["state"]}\nQuestion: {request["question"]}'
+        prefix = f'{inference_request["state"]}\nQuestion: {inference_request["question"]}'
         all_text = prefix + "\nCandidates:\n" + "\n".join(item["text"] for item in candidates)
         token_count = len(self.tokenizer.encode(all_text).ids)
-        if token_count > 512:
+        if token_count > MAX_PROMPT_TOKENS:
             return {"selection": None, "status": "error", "reason": "input_overflow",
                     "question_tokens": token_count}
         encoded = [self.tokenizer.encode(prefix + "\nCandidate: " + item["text"])
                    for item in candidates]
         length = max(len(item.ids) for item in encoded)
-        if length > 512:
+        if length > MAX_PROMPT_TOKENS:
             return {"selection": None, "status": "error", "reason": "candidate_input_overflow",
                     "question_tokens": token_count}
         ids = np.full((1, len(candidates), length), self.tokenizer.token_to_id("[PAD]"), dtype=np.int64)
@@ -153,6 +170,8 @@ class DirectSelector:
         result = decode(scores[0].tolist(), float(answerability[0]),
                         [item["id"] for item in candidates])
         result.update(question_tokens=token_count,
+                      compression=asdict(compression),
+                      inference_request_sha256=object_hash(inference_request),
                       input_array_sha256=object_hash({key: value.tolist() for key, value in feed.items()}))
         return result
 
@@ -167,8 +186,10 @@ def predict_file(source: Path, output: Path, *, split: str, k: int,
     seen: set[str] = set()
     counts: Counter[str] = Counter()
     source_digest = file_hash(source)
-    config = {"split": split, "k": k, "provenance": provenance, "adapted": False,
-              "question": QUESTION, "input_overflow": "preserve error; no truncation"}
+    config = {"split": split, "k": k, "provenance": provenance,
+              "adapted": bool(provenance.get("adapted", False)),
+              "question": QUESTION,
+              "input_overflow": "exact tokenizer hard cap at 512 after label-free compression"}
     config_digest = object_hash(config)
     with source.open() as handle, partial.open("x") as destination:
         for line in handle:

tools/prepare_public_release.py

@@ -20,7 +20,7 @@ DENIED_PARTS = {
     "artifacts", "reports", "research", "private", "restricted", "models",
     "weights", "checkpoints", "releases", ".aws", ".ssh", ".cache",
 }
-TEXT_SUFFIXES = {".py", ".ts", ".mjs", ".md", ".json", ".toml", ".yml", ".cff", ".html"}
+TEXT_SUFFIXES = {".py", ".ts", ".mjs", ".md", ".json", ".toml", ".yml", ".cff", ".html", ".css"}
 TEXT_NAMES = {".gitignore", ".gitattributes", "LICENSE", "NOTICE"}
 PATTERNS = {
     "private-key": re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),

tools/replay_mind2web_evaluation.py

@@ -30,6 +30,7 @@ KS = (5, 10, 20, 32)
 CELLS = tuple((split, k) for split in SPLITS for k in KS)
 SOURCE_FILES = (
     "vons/mind2web.py",
+    "vons/mind2web_adapter.py",
     "tools/evaluate_mind2web.py",
     "tools/predict_mind2web.py",
     "tools/replay_mind2web_evaluation.py",