experiential 0.4.0__tar.gz

experiential-0.4.0/.gitignore

@@ -0,0 +1,42 @@
+__pycache__/
+*.py[cod]
+.venv/
+.env
+.env.*
+!.env.example
+.exp/
+dist/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.ty_cache/
+.DS_Store
+
+# Local-only design notes; not committed.
+DESIGN.md
+
+demos/
+
+# baseline-grid run scratch (not artifacts)
+.exp-rebuild/
+logs/
+
+.exp-fixed/
+
+# Local per-project settings (telemetry ids etc.) — never committed, wherever the root is.
+settings.toml
+
+# Claude Code local state (skills ARE committed; local settings/locks are not).
+.claude/settings.local.json
+.claude/scheduled_tasks.lock
+.claude/projects/
+
+# wandb run directories (local mirrors of what is already on the server)
+wandb/
+
+# External clones land in the working directory, never in git.
+.tau2-bench/
+
+# Local agent scratchpads: never tracked, never in PRs (AGENTS.md, Repository layout).
+.agents/

experiential-0.4.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.5
+Name: experiential
+Version: 0.4.0
+Summary: Build simulations and optimize model routing from agent traces.
+Requires-Python: >=3.12
+Requires-Dist: boto3<2,>=1.35
+Requires-Dist: botocore<2,>=1.35
+Requires-Dist: click>=8.2
+Requires-Dist: fastapi>=0.128
+Requires-Dist: filelock>=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: numpy>=1.26
+Requires-Dist: openai<4,>=3.0
+Requires-Dist: posthog>=7.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: rich>=14.1
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: typer>=0.16
+Requires-Dist: uvicorn>=0.38
+Provides-Extra: dev
+Requires-Dist: pytest-xdist>=3.8; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: tinker-cookbook<0.5,>=0.4.3; extra == 'dev'
+Requires-Dist: tinker<0.24,>=0.23; extra == 'dev'
+Requires-Dist: ty>=0.0.1a1; extra == 'dev'
+Provides-Extra: sft
+Requires-Dist: tinker-cookbook<0.5,>=0.4.3; extra == 'sft'
+Requires-Dist: tinker<0.24,>=0.23; extra == 'sft'
+Description-Content-Type: text/markdown
+
+# Experiential
+
+Experiential is an open source gateway and router for agent workflows:
+
+1. Use hosted, BYOK, and local models through one OpenAI-compatible API.
+2. Control which users and agents can use which models, for which use cases, and how much they can spend.
+3. Turn production traffic into a custom router or model optimized for quality, speed, and cost.
+
+![Your traces flow through simulation into routing and training optimization](https://raw.githubusercontent.com/experientiallabs/experiential/main/assets/experiential-workflow.png)
+
+<p align="center">
+  🌐 <a href="https://platform.experientiallabs.ai">Platform</a> |
+  📚 <a href="https://github.com/experientiallabs/experiential/tree/main/docs">Docs</a> |
+  <a href="https://discord.gg/B6sM8xTVwU"><img src="https://cdn.simpleicons.org/discord/5865F2" alt="" width="16" height="16"> Discord</a>
+</p>
+
+## Getting Started
+
+Start a local OpenAI-compatible gateway. On first run, the setup wizard asks for a provider,
+model, and public alias, then prints a one-time virtual key:
+
+```bash
+pip install experiential
+exp run
+```
+
+Choose a public alias such as `support-agent`, capture the issued key, and send a request:
+
+```bash
+export EXP_GATEWAY_KEY=...
+curl http://127.0.0.1:8000/v1/chat/completions \
+  -H "Authorization: Bearer $EXP_GATEWAY_KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"model":"support-agent","messages":[{"role":"user","content":"Help me"}]}'
+```
+
+## Using the API
+
+Create a local gateway programmatically:
+
+```python
+import uvicorn
+
+from exp.runtime.gateway.lifecycle import load_local_gateway
+
+gateway = load_local_gateway()
+uvicorn.run(gateway.app, lifespan="on")
+```
+
+For hosted workers with their own storage and provider services, use the lower-level
+`exp.create_gateway_runtime(...)` composition API.
+
+## Optimize from Traffic
+
+First, collect OpenTelemetry traces from your current agent. If you just want to try it out, grab
+the public [terminal-tasks OTLP dataset](https://huggingface.co/datasets/experiential-labs/wmo-terminal-tasks-traces):
+
+```bash
+curl -L -o traces.otel.jsonl \
+  https://huggingface.co/datasets/experiential-labs/wmo-terminal-tasks-traces/resolve/540883e451dc13d34fb50fdd36b143cb0f1fb0db/traces.otel.jsonl
+```
+
+Then build a project. The build command walks you through providers,
+models, and budget, and asks for your trace file:
+
+```bash
+# Build simulation from your agent traces and optimize a router against it
+exp build support-agent
+```
+
+After collecting traces from your router, fine-tune an open source model you own using
+[Tinker](https://tinker.thinkingmachines.ai/).
+
+```bash
+exp optimize model support-agent
+```
+
+## Telemetry
+
+Anonymous aggregate PostHog product telemetry is enabled by default. It never includes prompts,
+traces, actions, observations, paths, model names, credentials, or raw customer content.
+
+```bash
+exp config telemetry status
+exp config telemetry disable
+exp config telemetry enable
+```
+
+The preference is stored locally in `.exp/settings.toml`.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run ruff format --check .
+uv run ruff check .
+uv run ty check
+uv run pytest -q
+```
+
+Repository and documentation conventions live in [AGENTS.md](./AGENTS.md).

experiential-0.4.0/README.md

@@ -0,0 +1,101 @@
+# Experiential
+
+Experiential is an open source gateway and router for agent workflows:
+
+1. Use hosted, BYOK, and local models through one OpenAI-compatible API.
+2. Control which users and agents can use which models, for which use cases, and how much they can spend.
+3. Turn production traffic into a custom router or model optimized for quality, speed, and cost.
+
+![Your traces flow through simulation into routing and training optimization](https://raw.githubusercontent.com/experientiallabs/experiential/main/assets/experiential-workflow.png)
+
+<p align="center">
+  🌐 <a href="https://platform.experientiallabs.ai">Platform</a> |
+  📚 <a href="https://github.com/experientiallabs/experiential/tree/main/docs">Docs</a> |
+  <a href="https://discord.gg/B6sM8xTVwU"><img src="https://cdn.simpleicons.org/discord/5865F2" alt="" width="16" height="16"> Discord</a>
+</p>
+
+## Getting Started
+
+Start a local OpenAI-compatible gateway. On first run, the setup wizard asks for a provider,
+model, and public alias, then prints a one-time virtual key:
+
+```bash
+pip install experiential
+exp run
+```
+
+Choose a public alias such as `support-agent`, capture the issued key, and send a request:
+
+```bash
+export EXP_GATEWAY_KEY=...
+curl http://127.0.0.1:8000/v1/chat/completions \
+  -H "Authorization: Bearer $EXP_GATEWAY_KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"model":"support-agent","messages":[{"role":"user","content":"Help me"}]}'
+```
+
+## Using the API
+
+Create a local gateway programmatically:
+
+```python
+import uvicorn
+
+from exp.runtime.gateway.lifecycle import load_local_gateway
+
+gateway = load_local_gateway()
+uvicorn.run(gateway.app, lifespan="on")
+```
+
+For hosted workers with their own storage and provider services, use the lower-level
+`exp.create_gateway_runtime(...)` composition API.
+
+## Optimize from Traffic
+
+First, collect OpenTelemetry traces from your current agent. If you just want to try it out, grab
+the public [terminal-tasks OTLP dataset](https://huggingface.co/datasets/experiential-labs/wmo-terminal-tasks-traces):
+
+```bash
+curl -L -o traces.otel.jsonl \
+  https://huggingface.co/datasets/experiential-labs/wmo-terminal-tasks-traces/resolve/540883e451dc13d34fb50fdd36b143cb0f1fb0db/traces.otel.jsonl
+```
+
+Then build a project. The build command walks you through providers,
+models, and budget, and asks for your trace file:
+
+```bash
+# Build simulation from your agent traces and optimize a router against it
+exp build support-agent
+```
+
+After collecting traces from your router, fine-tune an open source model you own using
+[Tinker](https://tinker.thinkingmachines.ai/).
+
+```bash
+exp optimize model support-agent
+```
+
+## Telemetry
+
+Anonymous aggregate PostHog product telemetry is enabled by default. It never includes prompts,
+traces, actions, observations, paths, model names, credentials, or raw customer content.
+
+```bash
+exp config telemetry status
+exp config telemetry disable
+exp config telemetry enable
+```
+
+The preference is stored locally in `.exp/settings.toml`.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run ruff format --check .
+uv run ruff check .
+uv run ty check
+uv run pytest -q
+```
+
+Repository and documentation conventions live in [AGENTS.md](./AGENTS.md).

experiential-0.4.0/conftest.py

@@ -0,0 +1,11 @@
+"""Repo-wide pytest configuration."""
+
+from __future__ import annotations
+
+import os
+
+# Rich consoles snapshot color support when constructed, and `exp.cli.app` builds its console at
+# import time — so color-forcing vars must go before any test module imports it, or a dev shell
+# exporting FORCE_COLOR would inject ANSI codes into CliRunner captures and fail assertions.
+os.environ.pop("FORCE_COLOR", None)
+os.environ.pop("CLICOLOR_FORCE", None)

experiential-0.4.0/docs/reference/gateway-architecture.md

@@ -0,0 +1,187 @@
+# Local gateway architecture
+
+## Supported surface
+
+No-argument `exp run` starts an authenticated multi-alias gateway on `127.0.0.1`.
+It serves:
+
+- `GET /v1/models`
+- `POST /v1/chat/completions`
+- `POST /v1/responses`
+- `GET /health/live` and `GET /health/ready`
+- `GET /usage` and `GET /usage.json`
+
+`exp run PROJECT` is compatibility sugar that activates one project-backed alias and launches this
+same gateway application. It does not create a router HTTP server. Gateway startup and readiness
+perform no provider request. Only an authorized model request may cross the provider boundary.
+
+## Embeddable worker composition
+
+Platform workers use the public `create_gateway_runtime` seam. The worker supplies storage,
+provider, secret, project-selection, clock, readiness, and usage implementations, then owns the
+returned lifecycle handle:
+
+```python
+runtime = exp.create_gateway_runtime(
+    config=exp.GatewayRuntimeConfig(graceful_timeout_seconds=10),
+    authority=authority,
+    ledger=ledger,
+    routes=routes,
+    executor=executor,
+    clock=clock,
+    readiness=readiness,
+    usage=usage,
+    replay=replay,
+    continuations=continuations,
+)
+
+app = runtime.app
+# Serve app with the platform's ASGI worker, including ASGI lifespan.
+```
+
+The factory performs no filesystem, SQLite, environment, lock, or server access. A worker may use
+any `SecretResolver` while constructing its provider executor and any `ProjectTargetResolver`
+while constructing its catalog route resolver. The composed application always mounts the same
+`create_gateway_app` data plane used by the local CLI. The lifecycle exposes explicit preflight,
+readiness, bounded drain, and shutdown operations in addition to its ASGI lifespan.
+
+An ASGI host that drives application lifespan owns preflight and shutdown automatically. A host
+that does not drive lifespan calls `runtime.preflight()` before admission and
+`runtime.shutdown()` during teardown. Shutdown is idempotent across those paths: one runtime starts
+one bounded drain and one terminal flush, then remains permanently not ready.
+
+## Authority and management
+
+`exp config gateway` owns explicit local setup. Its provider, identity, key, grant, alias, pool, and
+monthly budget commands produce versioned receipts suitable for interactive or non-interactive
+callers. There are no runtime seeds. A usable installation requires an organization, active
+identity, active virtual key, explicit identity-to-alias grant, active alias revision, immutable
+catalog snapshot, and a resolvable provider credential reference.
+
+Private serving authority lives in `ROOT/gateway/gateway.db`, including identities, keys, grants,
+provider connections and revisions, aliases and revisions, attempts, and usage. SQLite uses WAL
+mode, versioned forward
+migrations, private backups before migration, newer-schema refusal, and serialized initialization.
+Virtual keys are stored only as peppered fingerprints. Key material is delivered once in a JSON
+receipt or to a new mode-`0600` file, and commit ambiguity preserves recoverability. Provider
+configuration stores an environment variable name, never its value. The local pepper is mode
+`0600` and is not exported.
+
+Every data-plane request is authenticated and authorized before request decoding, routing,
+continuation lookup, or provider work. Authorization freezes organization, identity, API surface,
+alias revision, target, catalog digest, request digest, optional hashed operation identity, and one
+monotonic deadline. Identity disable, key revocation or expiry, grant removal, and alias revision
+changes fail closed.
+
+## Catalog, aliases, and exact-model pools
+
+The gateway database owns current provider connection state. Existing model metadata remains the
+authoring input for builds, policies, evaluations, and datasets; it is not consulted as mutable
+serving authority after an alias revision binds exact connection revisions. Gateway snapshots under
+`ROOT/gateway/catalog-snapshots/` are immutable, secret-free artifacts for an exact catalog digest.
+An advertised alias is executable only when readiness holds for the exact tuple of alias name,
+alias revision, and catalog digest used by authorization.
+
+An alias targets either:
+
+1. a direct exact-model pool, or
+2. one immutable project activation.
+
+A singleton alias creates a one-deployment pool. `exp config gateway pool certify` can replace that
+with an ordered pool only when every member has the same exact logical model identity and an
+operator-supplied equivalence certification. The certification records an ID, provenance, evidence
+digest, time, and exact deployment order. Project policy selection still chooses one exact logical
+model; operational fallback can only move among certified deployments for that model.
+
+## Request, route, and provider attempts
+
+The content-free ledger accepts the logical request before learned project selection. Selection or
+direct resolution then produces an execution snapshot containing the exact model, pool, and ordered
+deployment IDs. Each physical provider dispatch gets its own durable attempt row immediately before
+network work. Attempt ordinal counts all physical dispatches; route depth identifies the selected
+deployment position.
+
+Provider execution is always internally streaming. Bounded same-deployment retries and ordered
+deployment fallback are allowed only for typed precommit failures. The first outward text, refusal,
+or tool-call semantic event commits the deployment, after which the gateway never switches
+providers. Typed refusal fallback is disabled unless the active alias revision explicitly enables
+it. Opted-in refusal deltas are withheld only in a bounded in-memory buffer: a refusal-only terminal
+result can advance to the next certified deployment, while mixed semantic output or buffer overflow
+commits and flushes the original route. Provider-internal retry layers are disabled so every
+possible billable dispatch is visible to the gateway ledger.
+
+Before each physical dispatch, the same immediate SQLite transaction reserves the request's
+conservative maximum integer micro-USD cost and inserts its attempt row. Applicable hard limits can
+cover the local team, one identity, one alias pool, and each provider deployment within that pool.
+An exhausted deployment allocation removes only that route from the current certified waterfall.
+If no route can fit the shared team, identity, or total pool allocation, the neutral protocol
+returns HTTP 429 with OpenAI `insufficient_quota` semantics before provider work. Any required
+unknown price makes that route ineligible while a hard limit applies.
+
+Settlement replaces the reservation with observed integer micro-USD usage. A dispatched failure,
+cancellation, or crash without trustworthy usage retains its conservative reservation because it
+may be billable. Retries and fallbacks therefore consume one allocation entry per physical attempt,
+while keyed replay creates no new reservation. A period is the immutable UTC bucket beginning at
+`YYYY-MM-01T00:00:00+00:00`; rollover selects a new bucket and never clears or rewrites an earlier
+month. Management and remaining-allocation reports are CLI surfaces only. There is no budgets
+dashboard.
+
+Each physical attempt records its own provider, model, usage, latency, terminal state, estimated
+cost attribution, and frozen credential-ownership billing source. Later catalog activation and
+process restart never rewrite that source. Schema-v1/v2 attempt rows migrate explicitly as
+`customer_managed`; current dispatches persist either `host_managed` or `customer_managed` before
+network work. The public usage report conserves physical attempt, token, cost, unknown-cost, and
+terminal totals across those source buckets without partitioning logical request counts. The parent
+request terminalizes once after success, final failure, cancellation, disconnect, or crash
+reconciliation. Unknown prices remain unknown instead of being treated as zero or copied across
+deployments.
+
+## OpenAI-compatible protocol
+
+`exp/runtime/openai_protocol` is the only OpenAI wire implementation. Chat Completions and
+Responses have separate allowlist decoders and field-specific OpenAI error responses, but both
+convert to one canonical gateway request without conflating their wire contracts. The package also
+owns headers, response assembly, SSE framing, tool-call reconstruction, and official SDK
+compatibility.
+Chat streaming emits valid completion chunks and one `[DONE]`. Responses streaming emits the
+created, in-progress, output, and exactly one terminal lifecycle. Provider tool-argument fragments
+are accumulated in original order and validated only at the complete-call boundary.
+
+Commit-independent headers are available before streaming begins. Route-dependent headers are
+emitted only after an execution snapshot exists. Stable public IDs do not expose raw key,
+idempotency, request, or provider values.
+
+OpenAI `3.0.0` `OpenAI` and `AsyncOpenAI` clients are release-certified for Chat Completions and
+Responses in synchronous and asynchronous, streaming and non-streaming forms. Responses
+continuation and duplicate replay retain content only in bounded, process-local, tenant and
+alias-revision-scoped stores. Replay is opt-in through an idempotency or client request key. Restart
+or eviction returns an explicit unavailable error and never reconstructs content from SQLite.
+
+## Content-free observability and lifecycle
+
+SQLite stores hashes, frozen authority, route identity, state transitions, token counts, latency,
+and estimated cost. It never stores prompts, responses, raw tool arguments, raw virtual keys, or
+provider secrets. `GET /usage` and `GET /usage.json` are two renderings of the same schema-v2 report
+and expose only aggregate, per-identity, and physical-attempt `by_billing_source` accounting.
+Source buckets conserve attempt, token, known-cost, unknown-cost, and terminal-state totals but do
+not partition logical request counts. Estimated cost is attribution, not a provider invoice.
+
+The process owns readiness from preflight through bounded drain. New work is rejected after drain
+starts. Admitted tasks, upstream streams, disconnect cleanup, replay ownership, continuation state,
+and final ledger settlement are process-owned and bounded. A stuck cancellation cannot prevent the
+terminal flusher from attempting content-free settlement.
+
+## Certification boundary
+
+Deterministic release evidence uses a built and freshly installed wheel, real SQLite, a real
+subprocess-bound loopback gateway, a real loopback upstream, and the official SDK clients. One
+scanner checks database, WAL, backups when present, catalog snapshots, stdout, stderr, logs, usage
+responses, and error bodies for raw content and secret canaries.
+
+`exp/runtime/gateway/provider_certification.py` is the dated provider capability matrix. Each cell
+names the official client SDK, public gateway surfaces, provider wire surface, fixture result, and
+credential-gated live status. OpenAI and Anthropic have native fixtures; generic OpenAI-compatible,
+Azure, and OpenRouter share compatible-stream coverage; Gemini and Bedrock have native deterministic
+fixtures. Live provider cells remain explicitly `not_run_requires_credentials` until a separately
+authorized run supplies dated evidence. Deterministic fixtures do not imply hosted-provider
+availability, billing, or account-specific behavior.

experiential-0.4.0/docs/release-scope.md

@@ -0,0 +1,86 @@
+# Release scope
+
+This release supports the current source and one wheel with either core dependencies or the
+optional `sft` dependency extra on their documented local paths. It claims only behavior exercised
+on the exact release checkout.
+
+## Supported and verified
+
+- Root CLI commands are exactly `build`, `config`, `optimize`, and `run`; optimizer commands are
+  exactly `router` and `model`.
+- The local gateway supports explicit provider references, identities, virtual keys, grants,
+  singleton and certified ordered exact-model pools, frozen-project aliases, bounded precommit
+  provider fallback, Chat Completions, Responses, bounded in-memory continuation and replay,
+  content-free SQLite accounting, monthly integer micro-USD enforcement, and loopback-only health
+  and usage views.
+- Both no-argument gateway launch and the retained `exp run PROJECT [--ghost]` compatibility form
+  are installed-wheel surfaces. Gateway startup is provider-idle and requires explicit authority.
+- The installed-wheel gateway lane uses real SQLite, a real subprocess listener, a real loopback
+  upstream, and OpenAI `3.0.0`. It covers `OpenAI` and `AsyncOpenAI` across Chat Completions and
+  Responses, with both stream and non-stream requests. HTML and JSON usage are checked for the same
+  per-identity accounting values. The same lane measures default SDK retries against physical
+  attempts, provider-authentication fallback, refusal policy, post-commit no-switch, restart and
+  replay behavior, revocation, cancellation, WAL mode, and mixed `host_managed`/
+  `customer_managed` cost attribution that remains frozen across restart and catalog replacement.
+- Real-SQLite monthly budget evidence covers atomic concurrent reservations, provider-only route
+  exhaustion, shared identity quota errors, billable failure and crash retention, retry and
+  fallback accounting, keyed replay without duplicate spend, explicit schema migration, and UTC
+  month rollover without a reset job. The real loopback waterfall is configured through the
+  interactive-capable CLI and returns OpenAI `insufficient_quota` after shared exhaustion.
+- Deterministic source-level certification additionally covers selection-only project routing,
+  authentication-circuit open/skip/recovery, concurrent multi-identity key revocation and alias
+  revision activation, and atomic rollback of a failed legacy SQLite migration.
+- One content and secret canary scanner covers the gateway database, live WAL, migration backups
+  when present, catalog snapshots, stdout, stderr, logs, usage responses, and HTTP error bodies.
+- Public Python exposes provider-free build, explicit router composition, frozen selection-only
+  router load through the normal gateway application, structural text-versus-sandbox comparison,
+  and managed SFT composition. No separate router HTTP or SSE implementation is shipped.
+- W16 router evidence uses 100 normalized traces, 50 fit tasks, 20 held-out tasks, 140 planned
+  cells, 130 deterministic text simulations, and 140 deterministic judgments under one finite
+  simulation and judgment budget. Observed hosted-service spend is exactly $0.00.
+- W16 sandbox evidence compares two exact post-lock text and Darwin local-process pairs. It retains
+  one malformed sandbox failure in the denominator and claims structural terminal agreement only.
+- Exact-checkout CI supplies the full 40-hex Git revision, recursively verifies every evidence
+  artifact and manifest input, and publishes machine-readable JSON plus JUnit evidence.
+
+## Gateway provider evidence matrix
+
+This table separates deterministic protocol evidence from hosted calls that need account
+credentials. `Not run` means exactly that; it is not inferred from fixture coverage.
+
+| Provider surface | Deterministic evidence in this release | Credential-gated live evidence |
+|---|---|---|
+| OpenAI | Native Responses fixtures for text, tool arguments, usage, cancellation, and refusal; all eight official SDK quadrants run against the installed local gateway | Not run; requires an OpenAI credential |
+| Anthropic | Native Messages fixtures for text, tool arguments, usage, cancellation, and refusal through both public gateway surfaces | Not run; requires an Anthropic credential |
+| Generic OpenAI-compatible | Real loopback upstream through the installed gateway; text, tool arguments, usage, cancellation, and refusal contracts | Not run; requires a compatible hosted endpoint and credential |
+| Azure OpenAI | Compatible-adapter fixtures for text, tool arguments, usage, cancellation, and refusal | Not run; requires Azure endpoint and credential |
+| OpenRouter | Compatible-adapter fixtures for text, tool arguments, usage, cancellation, and refusal | Not run; requires OpenRouter credential |
+| Gemini | Native fixtures for text, structured complete function arguments, usage, cancellation, and refusal | Not run; requires Gemini credential |
+| Amazon Bedrock | Native EventStream fixtures for text, incremental tool arguments, usage, bounded cancellation, refusal, and single dispatch | Not run; requires an authorized AWS account and region |
+
+The machine-readable dated matrix is
+`exp/runtime/gateway/provider_certification.py`. Its live cells are
+`not_run_requires_credentials`. Gemini complete structured function arguments are explicitly not
+labeled as provider-byte incremental tool-argument streaming.
+
+## Explicitly excluded
+
+- There is no budgets dashboard. Monthly allocation management and remaining-allocation reporting
+  are explicit interactive or non-interactive CLI operations.
+
+- No paid E2B or Harbor cloud smoke ran. The repository verifies the optional `bounded-close-v1`
+  Harbor lifecycle and ledger with injected fakes, but makes no cloud cleanup, provider-quality, or
+  environment-parity claim.
+- No real Tinker training ran. Managed SFT remains fail-closed unless its immutable configuration
+  has a finite positive ceiling and its backend supplies a conservative full-schedule estimate.
+- No trained-versus-base behavioral comparison ran because this release produced no paid training
+  artifact. It makes no trained-model quality-improvement claim.
+- No hosted model, judge, embedding, telemetry, environment, credential, or `.env` path was used by
+  release evidence. The deterministic W16 evidence reports exactly $0.00 observed service spend.
+- Deterministic gateway certification uses a real loopback upstream and local SQLite. No live
+  provider matrix cell ran, so hosted availability, account limits, billing, and service-specific
+  behavior are not claimed.
+
+These exclusions are product boundaries, not evidence that the corresponding hosted services are
+unsafe or unsupported forever. Any future claim requires separately authorized, finite-budget,
+denominator-preserving evidence.