jevkit-runtime 0.1.0__tar.gz → 0.3.0__tar.gz

{jevkit_runtime-0.1.0 → jevkit_runtime-0.3.0}/.github/workflows/downstream.yml

@@ -14,8 +14,6 @@ permissions:
   contents: read
 jobs:
   consumers:
-    # Enabled after all five migration PRs land; manual runs remain available.
-    if: vars.JEVKIT_CONSUMERS_READY == 'true' || github.event_name == 'workflow_dispatch'
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false

jevkit_runtime-0.3.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: jevkit-runtime
+Version: 0.3.0
+Summary: Shared transport, configuration, caching, and accounting for JevKit tools
+Project-URL: Homepage, https://github.com/keltokhy/jevkit-core
+Project-URL: Issues, https://github.com/keltokhy/jevkit-core/issues
+Author: Khaled Eltokhy
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: http2
+Requires-Dist: httpx[http2]>=0.27; extra == 'http2'
+Description-Content-Type: text/markdown
+
+# JevKit core
+
+Distribution **`jevkit-runtime`**, import **`jevkit_runtime`**. The PyPI name `jevkit-core` belongs
+to a different project.
+
+One request pipeline, one answer store, one provider catalog for jgrep, jsort, jlink, jselect,
+and jcol. Each tool remains its own package and repository; the core imports none of them, and a
+tool's adapter is a few lines naming which providers it offers.
+
+## What a tool gets
+
+```python
+from jevkit_runtime import AnswerStore, Client, catalog, resolve
+
+PROVIDERS = catalog("typesafe", "openrouter", "gateway")
+backend = resolve(PROVIDERS, name=None, model=None)          # or JEV_API / JEV_MODEL, else the first configured
+async with Client(backend, store=AnswerStore()) as client:
+    answers = await client.ask(state, {"q": {"type": "noul", "instructions": "..."}})
+```
+
+`Client.ask` does the whole thing: computes each question's identity, serves what the store already
+knows, joins an identical request already in flight, sends only the misses, validates the entire
+response before storing any of it, and meters the call before validation so a billed but malformed
+answer still counts. It returns `Answers`, a dict by question id whose `origins` say who answered
+each one and whether it came from the API, the store, or a shared call. Per-call policy is keyword
+arguments: `allow_paid=False` for cache-only runs, `on_cost` for the caller who should be charged,
+`hedge_after` to resend a slow call, and `keys` for callers whose reuse unit is not the request.
+HTTP/2 is used whenever the `http2` extra is installed.
+
+| Module | Owns |
+|---|---|
+| `settings.py` | Every environment and filesystem convention, read in one place: `XDG_*`, `JEV_API`, `JEV_URL`, `JEV_MODEL`, `JEV_PRICE_PER_MTOK`, provider keys and URL files |
+| `providers.py` | The catalog (`Provider`), a tool's selection of it or its own entries, and `resolve()` to one `Backend`: endpoint, model, key |
+| `protocol.py` | Request bodies, typed answer validation (`noul`, `choice`, `score`), usage parsing, answer identity, provenance |
+| `transport.py` | One HTTP call with a total deadline, retries with backoff and `Retry-After`, structured status errors |
+| `store.py` | SQLite answers with their provenance in one row, one versioned schema |
+| `client.py` | The pipeline above, request sharing, hedging |
+| `meter.py` | Calls, cache hits, retries, hedges, tokens, cost, and which models actually answered |
+| `errors.py` | `JevError`, `JevFatal`, `JevBudgetExceeded`, `RequestExhausted`, `ProviderError`, `ProviderFatal` |
+
+## Conventions every tool shares
+
+- **Answer identity** is `answer_key(backend, state, question)`: provider, endpoint, model, state and
+  question. An answer from one provider or model is never served for another.
+- **The store** lives at `$XDG_CACHE_HOME/jev/answers.sqlite` (default `~/.cache/jev`), is created
+  private to the user, and resets itself when it finds an older schema. Version 0.2 cannot read
+  caches written by 0.1 tools; the first run after upgrading re-asks.
+- **Credentials** come from the provider's variable, then `$XDG_CONFIG_HOME/jev/<provider>.key`.
+  Gateways take their URL from `JEV_GATEWAY_URL` or `<provider>.url`. `JEV_URL` overrides any endpoint.
+- **Metering** refuses malformed usage rather than under-counting; a response without a reported
+  cost is priced from its tokens at the provider's price, zero for local servers, or the list price.
+  `JEV_PRICE_PER_MTOK` overrides both.
+- **Errors** keep their wording across tools: a fatal status reads `PROVIDER said 401: detail`, a
+  bad request reads `HTTP 400: detail`, and exhaustion reads `gave up after 15s (last failure)`.
+  Both status errors carry `provider`, `status` and `detail` for tools that word or redact them.
+
+## Local servers
+
+Two catalog entries point at System One servers on your own machine: `diffusiongemma`, an
+[OpenJev](https://github.com/razorback16/openjev) server on port 8080, and `laya`, a
+[laya-mlx](https://github.com/mizorewww/laya-mlx) server on port 8081. Every JevKit tool names
+them in its catalog, so `--api laya` or `JEV_API=laya` works everywhere. They are never chosen
+in place of a configured hosted provider, need no key, and are metered at zero API fees unless
+`JEV_PRICE_PER_MTOK` says otherwise. `JEV_LAYA_URL` and `JEV_DIFFUSIONGEMMA_URL`, or the matching
+`.url` files, point at a server elsewhere.
+
+DiffusionGemma reads every question in a batch together, so the runtime keys each of its answers
+on the whole ordered batch and re-sends a batch whole when any slot is missing.
+
+No package ships the models. [docs/diffusiongemma.md](docs/diffusiongemma.md) and
+[docs/laya.md](docs/laya.md) explain how to run the servers, and `scripts/laya_server.py` is the
+adapter the Laya guide starts.
+
+## Development
+
+Keep the six checkouts as siblings. Each consumer depends on `jevkit-runtime>=0.2.0,<0.3.0` and
+overrides it for development with `jevkit-runtime = { path = "../jevkit-core", editable = true }`
+under `[tool.uv.sources]`.
+
+```bash
+python3 scripts/dev.py setup          # uv sync every checkout, fetch jselect's tokenizer data
+python3 scripts/dev.py check          # core and consumer suites, credentials stripped, sockets blocked
+python3 scripts/dev.py wheel-check    # build and exercise real wheel installs in temporary environments
+python3 scripts/dev.py run jgrep -- --help
+```
+
+`check` also proves each consumer imports this exact source tree; `wheel-check` proves the installed
+wheel, not the checkout. `--tool NAME` limits either to one consumer and `--suffix` selects
+alternatively named checkouts. The GitHub workflows run the core suite on Python 3.10 and 3.13 and
+the downstream matrix against each consumer's main branch.
+
+## Releasing
+
+Tag the verified core `vX.Y.Z` and dispatch the publish workflow with that tag; the workflow checks
+the tag matches the package version and publishes through PyPI Trusted Publishing. Then release each
+consumer through its own process, bumping its supported core range, lockfile, and CI core reference
+together.

jevkit_runtime-0.3.0/README.md

@@ -0,0 +1,97 @@
+# JevKit core
+
+Distribution **`jevkit-runtime`**, import **`jevkit_runtime`**. The PyPI name `jevkit-core` belongs
+to a different project.
+
+One request pipeline, one answer store, one provider catalog for jgrep, jsort, jlink, jselect,
+and jcol. Each tool remains its own package and repository; the core imports none of them, and a
+tool's adapter is a few lines naming which providers it offers.
+
+## What a tool gets
+
+```python
+from jevkit_runtime import AnswerStore, Client, catalog, resolve
+
+PROVIDERS = catalog("typesafe", "openrouter", "gateway")
+backend = resolve(PROVIDERS, name=None, model=None)          # or JEV_API / JEV_MODEL, else the first configured
+async with Client(backend, store=AnswerStore()) as client:
+    answers = await client.ask(state, {"q": {"type": "noul", "instructions": "..."}})
+```
+
+`Client.ask` does the whole thing: computes each question's identity, serves what the store already
+knows, joins an identical request already in flight, sends only the misses, validates the entire
+response before storing any of it, and meters the call before validation so a billed but malformed
+answer still counts. It returns `Answers`, a dict by question id whose `origins` say who answered
+each one and whether it came from the API, the store, or a shared call. Per-call policy is keyword
+arguments: `allow_paid=False` for cache-only runs, `on_cost` for the caller who should be charged,
+`hedge_after` to resend a slow call, and `keys` for callers whose reuse unit is not the request.
+HTTP/2 is used whenever the `http2` extra is installed.
+
+| Module | Owns |
+|---|---|
+| `settings.py` | Every environment and filesystem convention, read in one place: `XDG_*`, `JEV_API`, `JEV_URL`, `JEV_MODEL`, `JEV_PRICE_PER_MTOK`, provider keys and URL files |
+| `providers.py` | The catalog (`Provider`), a tool's selection of it or its own entries, and `resolve()` to one `Backend`: endpoint, model, key |
+| `protocol.py` | Request bodies, typed answer validation (`noul`, `choice`, `score`), usage parsing, answer identity, provenance |
+| `transport.py` | One HTTP call with a total deadline, retries with backoff and `Retry-After`, structured status errors |
+| `store.py` | SQLite answers with their provenance in one row, one versioned schema |
+| `client.py` | The pipeline above, request sharing, hedging |
+| `meter.py` | Calls, cache hits, retries, hedges, tokens, cost, and which models actually answered |
+| `errors.py` | `JevError`, `JevFatal`, `JevBudgetExceeded`, `RequestExhausted`, `ProviderError`, `ProviderFatal` |
+
+## Conventions every tool shares
+
+- **Answer identity** is `answer_key(backend, state, question)`: provider, endpoint, model, state and
+  question. An answer from one provider or model is never served for another.
+- **The store** lives at `$XDG_CACHE_HOME/jev/answers.sqlite` (default `~/.cache/jev`), is created
+  private to the user, and resets itself when it finds an older schema. Version 0.2 cannot read
+  caches written by 0.1 tools; the first run after upgrading re-asks.
+- **Credentials** come from the provider's variable, then `$XDG_CONFIG_HOME/jev/<provider>.key`.
+  Gateways take their URL from `JEV_GATEWAY_URL` or `<provider>.url`. `JEV_URL` overrides any endpoint.
+- **Metering** refuses malformed usage rather than under-counting; a response without a reported
+  cost is priced from its tokens at the provider's price, zero for local servers, or the list price.
+  `JEV_PRICE_PER_MTOK` overrides both.
+- **Errors** keep their wording across tools: a fatal status reads `PROVIDER said 401: detail`, a
+  bad request reads `HTTP 400: detail`, and exhaustion reads `gave up after 15s (last failure)`.
+  Both status errors carry `provider`, `status` and `detail` for tools that word or redact them.
+
+## Local servers
+
+Two catalog entries point at System One servers on your own machine: `diffusiongemma`, an
+[OpenJev](https://github.com/razorback16/openjev) server on port 8080, and `laya`, a
+[laya-mlx](https://github.com/mizorewww/laya-mlx) server on port 8081. Every JevKit tool names
+them in its catalog, so `--api laya` or `JEV_API=laya` works everywhere. They are never chosen
+in place of a configured hosted provider, need no key, and are metered at zero API fees unless
+`JEV_PRICE_PER_MTOK` says otherwise. `JEV_LAYA_URL` and `JEV_DIFFUSIONGEMMA_URL`, or the matching
+`.url` files, point at a server elsewhere.
+
+DiffusionGemma reads every question in a batch together, so the runtime keys each of its answers
+on the whole ordered batch and re-sends a batch whole when any slot is missing.
+
+No package ships the models. [docs/diffusiongemma.md](docs/diffusiongemma.md) and
+[docs/laya.md](docs/laya.md) explain how to run the servers, and `scripts/laya_server.py` is the
+adapter the Laya guide starts.
+
+## Development
+
+Keep the six checkouts as siblings. Each consumer depends on `jevkit-runtime>=0.2.0,<0.3.0` and
+overrides it for development with `jevkit-runtime = { path = "../jevkit-core", editable = true }`
+under `[tool.uv.sources]`.
+
+```bash
+python3 scripts/dev.py setup          # uv sync every checkout, fetch jselect's tokenizer data
+python3 scripts/dev.py check          # core and consumer suites, credentials stripped, sockets blocked
+python3 scripts/dev.py wheel-check    # build and exercise real wheel installs in temporary environments
+python3 scripts/dev.py run jgrep -- --help
+```
+
+`check` also proves each consumer imports this exact source tree; `wheel-check` proves the installed
+wheel, not the checkout. `--tool NAME` limits either to one consumer and `--suffix` selects
+alternatively named checkouts. The GitHub workflows run the core suite on Python 3.10 and 3.13 and
+the downstream matrix against each consumer's main branch.
+
+## Releasing
+
+Tag the verified core `vX.Y.Z` and dispatch the publish workflow with that tag; the workflow checks
+the tag matches the package version and publishes through PyPI Trusted Publishing. Then release each
+consumer through its own process, bumping its supported core range, lockfile, and CI core reference
+together.

jevkit_runtime-0.3.0/docs/diffusiongemma.md

@@ -0,0 +1,86 @@
+# DiffusionGemma (local, experimental)
+
+Any JevKit tool can send its decisions to a DiffusionGemma decision server on your own machine
+instead of a hosted provider. The server is chosen only by name, never automatically, and its
+calls are metered at zero API fees:
+
+```bash
+jgrep --api diffusiongemma -j 1 "a complaint about noise" complaints.txt
+jcol --api diffusiongemma run table.csv codebook.json
+```
+
+No JevKit package ships the model; it runs in its own environment and process. Model quality
+and useful probability thresholds need evaluation on your own inputs.
+
+## Apple silicon
+
+[OpenJev](https://github.com/razorback16/openjev) supplies an MLX implementation of the
+structured-read approach from [vLLM PR #57250](https://github.com/vllm-project/vllm/pull/57250).
+Its 4-bit checkpoint is roughly 16.6 GB to download and needs about 16 GB of model memory plus
+working memory. Install the server in its own directory and environment:
+
+```bash
+git clone https://github.com/razorback16/openjev.git
+cd openjev
+git checkout e04794ab36e4f7e6040c2547baecdb2737ce2e79
+uv sync --python 3.12 --extra mlx
+OPENJEV_BACKEND=mlx uv run --extra mlx python -m openjev
+```
+
+The server downloads `mlx-community/diffusiongemma-26B-A4B-it-4bit` on first start. Wait for
+`Application startup complete` before querying it. `OPENJEV_MLX_MODEL` can point at a downloaded
+snapshot to pin the weights; the revision used in the original experiment was
+`a7a81407613811e8ba63af92ac0d852b809e191f`. Then, in another terminal:
+
+```bash
+printf '%s\n' 'The music next door keeps me awake.' 'The elevator is broken.' |
+  jgrep --api diffusiongemma --model openjev-0.1 -j 1 --timeout 120 --stats -o 'a complaint about noise'
+```
+
+Start with one request at a time: the MLX backend executes model work serially, and a deep
+queue can exceed a tool's per-request deadline. The longer timeout covers the first inference.
+Raise concurrency from measured throughput once the model is warm.
+
+## NVIDIA / vLLM
+
+Run OpenJev's documented vLLM deployment, or the prototype `structured_server.py` from
+[PR #57250](https://github.com/vllm-project/vllm/pull/57250). That PR was unmerged at the time of
+writing, so a released vLLM is not enough on its own; follow the server's pinned build
+instructions. Its `/v1/systemone` adapter sits in front of vLLM. For the PR example server's
+default port:
+
+```bash
+JEV_DIFFUSIONGEMMA_URL=http://127.0.0.1:8011/v1/systemone \
+  jgrep --api diffusiongemma --model jev-latest 'a stack trace' build.log
+```
+
+## Configuration
+
+| Setting | Meaning |
+|---|---|
+| `--api diffusiongemma` or `JEV_API=diffusiongemma` | Select it; it is never picked by discovery |
+| `JEV_DIFFUSIONGEMMA_URL` or `~/.config/jev/diffusiongemma.url` | Full endpoint, default `http://127.0.0.1:8080/v1/systemone` |
+| `JEV_DIFFUSIONGEMMA_API_KEY` or `~/.config/jev/diffusiongemma.key` | Optional bearer token; no `Authorization` header when absent |
+| `--model` or `JEV_MODEL` | Default `openjev-latest`; `openjev-0.1` pins the server's decision model |
+| `JEV_PRICE_PER_MTOK` | Overrides the zero price for `--stats`, `--estimate`, and dollar budgets |
+
+`JEV_URL` overrides every endpoint. A cost the server reports always wins over the price.
+Zero means no API fee, not zero compute. Configure a price before using a dollar budget against
+a metered remote server; an offline estimate is a byte-based approximation and cannot predict
+the server's adaptive re-reads.
+
+## Joint reads and the cache
+
+A diffusion read answers every question in a batch in the light of the others, so the runtime
+keys each of this provider's answers on the provider, endpoint, model, state, and the entire
+ordered batch of questions, IDs included. A batch is reused only whole: if any slot is missing
+from the cache, the whole batch is sent again. Hosted providers and Laya keep per-question
+caching. Pin both server and weights; after changing weights or inference settings behind the
+same URL and model, use `--no-cache` or a separate `XDG_CACHE_HOME`.
+
+## What to expect
+
+A September 2026 jgrep comparison over 10,000 public-data decisions found news classification
+close to hosted Jev but more false positives on SMS spam at a 0.9 cutoff. For code, judge whole
+diff hunks or functions; isolated diff lines recalled poorly on a small synthetic fixture. Keep
+it experimental and evaluate its cutoff on your own data.

jevkit_runtime-0.3.0/docs/laya.md

@@ -0,0 +1,80 @@
+# Laya (local, experimental)
+
+Any JevKit tool can send its decisions to a Laya server on your own machine instead of a hosted
+provider. The server is chosen only by name, never automatically, and its calls are metered at
+zero API fees:
+
+```bash
+jgrep --api laya "a complaint about noise" complaints.txt
+jsort --api laya "more urgent" tickets.txt
+JEV_API=laya jlink link left.csv right.csv --on name
+```
+
+This guide runs the general English 421M-parameter [Laya](https://github.com/NandhaKishorM/laya)
+checkpoint through the independent [laya-mlx port](https://github.com/mizorewww/laya-mlx) on
+Apple silicon. No JevKit package ships the model; it runs in its own environment and process.
+The multilingual and newer typed-decision checkpoints have not been tried.
+
+## Setup (Apple silicon)
+
+Keep the model dependencies in a separate environment. From a directory outside this repository:
+
+```bash
+git clone https://github.com/mizorewww/laya-mlx.git
+cd laya-mlx
+git checkout fc1df62828a3fedf4d8229fdac1cbd85f1cdf337
+uv sync --python 3.12
+uv pip install --python .venv/bin/python fastapi==0.141.1 uvicorn==0.53.0
+.venv/bin/python -c 'from huggingface_hub import snapshot_download; print(snapshot_download("aac6fef/laya-mlx", revision="047678560251f28113ee8f5df4be82102c7bf336"))'
+```
+
+Use the printed snapshot path as `--checkpoint`, then start the adapter from this repository
+with that environment's Python:
+
+```bash
+/path/to/laya-mlx/.venv/bin/python scripts/laya_server.py \
+  --checkpoint /path/to/downloaded/snapshot \
+  --audit /path/to/laya-audit.jsonl
+```
+
+It binds to loopback port 8081, loads FP16 weights, warms the model, and serves `/v1/systemone`.
+`/health` reports the checkpoint, context budget, and truncation policy. Then, in another terminal:
+
+```bash
+printf '%s\n' 'The music next door keeps me awake.' 'The elevator is broken.' |
+  jgrep --api laya -j 4 --timeout 120 --stats -o 'a complaint about noise'
+```
+
+## Context limit
+
+The model's 512-token window includes the question's instructions and options, leaving less
+room for the record. The adapter checks the remaining budget separately for every question and
+answers HTTP 422 if any state would be cropped; the tool reports an error rather than a negative
+answer. `--allow-truncation` enables the native runtime's prefix retention instead, and every
+request then records the available and dropped state tokens per question in the audit log.
+Ordinary use should keep rejection on. Long question instructions can also be shortened by the
+runtime's own question budget; the adapter audits state truncation, not question truncation.
+
+## Configuration
+
+| Setting | Meaning |
+|---|---|
+| `--api laya` or `JEV_API=laya` | Select it; it is never picked by discovery |
+| `JEV_LAYA_URL` or `~/.config/jev/laya.url` | Full endpoint, default `http://127.0.0.1:8081/v1/systemone` |
+| `JEV_LAYA_API_KEY` or `~/.config/jev/laya.key` | Optional bearer token for a server that authenticates; the supplied adapter does not |
+| `--model` or `JEV_MODEL` | `laya-421m`; the supplied adapter rejects other IDs |
+| `JEV_PRICE_PER_MTOK` | Overrides the zero price for `--stats`, `--estimate`, and dollar budgets |
+
+`JEV_URL` overrides every endpoint. Zero API fees exclude hardware and electricity.
+
+Laya reads each question on its own, so its answers share the ordinary per-question cache with
+the hosted providers, keyed by provider, endpoint, model, state, and question. Pin the server
+and the weights; after changing the model behind the same URL and model ID, use `--no-cache`
+or a separate `XDG_CACHE_HOME`.
+
+## What to expect
+
+A September 2026 jgrep experiment on an M3 Ultra found fast, strong short-text classification
+(92% top-1 on a news set) but weak precision on spam at the default 0.5 cutoff (53%, rising to
+79% at 0.9) and weak code judgments. Treat it as a fast classifier for short texts, and evaluate
+thresholds on your own labeled inputs before relying on the scores.

{jevkit_runtime-0.1.0 → jevkit_runtime-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jevkit-runtime"
-version = "0.1.0"
+version = "0.3.0"
 description = "Shared transport, configuration, caching, and accounting for JevKit tools"
 readme = "README.md"
 license = "MIT"
@@ -23,7 +23,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/jevkit_core"]
+packages = ["src/jevkit_runtime"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{jevkit_runtime-0.1.0 → jevkit_runtime-0.3.0}/scripts/dev.py

@@ -12,6 +12,10 @@ from pathlib import Path
 
 CORE = Path(__file__).resolve().parents[1]
 TOOLS = ("jgrep", "jsort", "jlink", "jselect", "jcol")
+PACKAGED_ASSETS = {
+    "jcol": ["static/index.html"],
+    "jlink": ["assets/review.html", "assets/review.js", "assets/review.css"],
+}
 
 
 def command(argv, *, cwd=CORE, env=None):
@@ -39,10 +43,34 @@ def python(repo):
     return repo / ".venv" / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
 
 
+def runtime_environment(executable, env=None):
+    """Use the selected environment for child CLI processes as well as Python."""
+    result = dict(os.environ if env is None else env)
+    result["PATH"] = os.pathsep.join((str(executable.parent), result.get("PATH", os.defpath)))
+    result["VIRTUAL_ENV"] = str(executable.parent.parent)
+    return result
+
+
+def expect_core(executable, location, *, cwd, env):
+    """The consumer's interpreter must import the core from `location`, not a stray install."""
+    command(
+        [
+            executable,
+            "-c",
+            "import sys, pathlib, jevkit_runtime; "
+            "here = pathlib.Path(jevkit_runtime.__file__).resolve().parent; "
+            "assert here == pathlib.Path(sys.argv[1]).resolve(), here",
+            location,
+        ],
+        cwd=cwd,
+        env=env,
+    )
+
+
 def main():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--repos-root", type=Path, default=CORE.parent)
-    parser.add_argument("--suffix", default="", help="e.g. --suffix=-jevkit for isolated migration worktrees")
+    parser.add_argument("--suffix", default="", help="checkout name suffix, e.g. --suffix=-wip")
     parser.add_argument("--tool", choices=TOOLS, help="operate on only one consumer")
     parser.add_argument(
         "--tokenizer-cache", type=Path, default=Path(tempfile.gettempdir()) / "data-gym-cache"
@@ -63,7 +91,11 @@ def main():
     if args.action == "run":
         repo = root / (args.name + args.suffix)
         arguments = args.arguments[1:] if args.arguments[:1] == ["--"] else args.arguments
-        command([python(repo), "-m", args.name, *arguments], cwd=Path.cwd())
+        command(
+            [python(repo), "-m", args.name, *arguments],
+            cwd=Path.cwd(),
+            env=runtime_environment(python(repo)),
+        )
         return
     for repo in repos.values():
         if not (repo / "pyproject.toml").is_file():
@@ -89,25 +121,11 @@ def main():
         temp = Path(temporary)
         env = environment(temp, args.tokenizer_cache)
         if args.action == "check":
-            baselines = json.loads((CORE / "consumer-baselines.json").read_text())
-            command([python(CORE), "-m", "pytest", "-q"], env=env)
-            for name, repo in repos.items():
-                command(
-                    [
-                        python(repo),
-                        CORE / "scripts/probe_consumer.py",
-                        name,
-                        "--expect-core",
-                        CORE / "src/jevkit_core",
-                        "--baseline-repo",
-                        repo,
-                        "--baseline-ref",
-                        baselines[name],
-                    ],
-                    cwd=temp,
-                    env=env,
-                )
-                command([python(repo), "-m", "pytest", "-q"], cwd=repo, env=env)
+            command([python(CORE), "-m", "pytest", "-q"], env=runtime_environment(python(CORE), env))
+            for repo in repos.values():
+                consumer_env = runtime_environment(python(repo), env)
+                expect_core(python(repo), CORE / "src/jevkit_runtime", cwd=temp, env=consumer_env)
+                command([python(repo), "-m", "pytest", "-q"], cwd=repo, env=consumer_env)
             return
         wheels = temp / "wheels"
         command(["uv", "build", "--no-sources", "--out-dir", wheels])
@@ -119,47 +137,27 @@ def main():
             venv = temp / name
             command(["uv", "venv", "--python", python(repo), venv])
             executable = venv / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+            wheel_env = runtime_environment(executable, env)
             command(["uv", "pip", "install", "--python", executable, core_wheel, package])
             site = subprocess.check_output(
                 [str(executable), "-c", "import sysconfig; print(sysconfig.get_path('purelib'))"], text=True
             ).strip()
-            command(
-                [
-                    executable,
-                    CORE / "scripts/probe_consumer.py",
-                    name,
-                    "--expect-core",
-                    Path(site) / "jevkit_core",
-                ],
-                cwd=temp,
-                env=env,
-            )
-            command([executable, "-m", name, "--version"], cwd=temp, env=env)
-            if name == "jcol":
-                cli = venv / ("Scripts/jcol.exe" if os.name == "nt" else "bin/jcol")
-                command([executable, repo / "tests/test_process.py", cli], cwd=temp, env=env)
+            expect_core(executable, Path(site) / "jevkit_runtime", cwd=temp, env=wheel_env)
+            command([executable, "-m", name, "--version"], cwd=temp, env=wheel_env)
+            for asset in PACKAGED_ASSETS.get(name, []):
                 command(
                     [
                         executable,
                         "-c",
                         "from importlib.resources import files; "
-                        "assert files('jcol').joinpath('static/index.html').is_file()",
+                        f"assert files({name!r}).joinpath({asset!r}).is_file()",
                     ],
                     cwd=temp,
-                    env=env,
-                )
-            if name == "jlink":
-                command(
-                    [
-                        executable,
-                        "-c",
-                        "from importlib.resources import files; "
-                        "assert all(files('jlink').joinpath('assets', f).is_file() "
-                        "for f in ('review.html', 'review.js', 'review.css'))",
-                    ],
-                    cwd=temp,
-                    env=env,
+                    env=wheel_env,
                 )
+            if name == "jcol":
+                cli = venv / ("Scripts/jcol.exe" if os.name == "nt" else "bin/jcol")
+                command([executable, repo / "tests/test_process.py", cli], cwd=temp, env=wheel_env)
         print(json.dumps({"wheel_checks": names, "status": "passed"}))