@askalf/dario 5.4.16 → 5.4.19

package/docs/usage.md

@@ -0,0 +1,123 @@
+# Usage — SDK examples
+
+## Python (Anthropic SDK)
+
+```python
+import anthropic
+
+client = anthropic.Anthropic(
+    base_url="http://localhost:3456",
+    api_key="dario",
+)
+
+msg = client.messages.create(
+    model="claude-opus-5",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+print(msg.content[0].text)
+```
+
+## Python (OpenAI SDK — same proxy, different provider)
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:3456/v1",
+    api_key="dario",
+)
+
+# gpt-4o routes to the configured OpenAI backend
+msg = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+# claude-opus-5 routes to the Claude subscription backend — same SDK, same URL
+claude_msg = client.chat.completions.create(
+    model="claude-opus-5",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+```
+
+## TypeScript / Node.js
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic({
+  baseURL: "http://localhost:3456",
+  apiKey: "dario",
+});
+
+const msg = await client.messages.create({
+  model: "claude-opus-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+## OpenAI-compatible tools (universal env-var setup)
+
+```bash
+export OPENAI_BASE_URL=http://localhost:3456/v1
+export OPENAI_API_KEY=dario
+```
+
+Use Claude model names (`claude-fable-5`, `claude-opus-5`, `claude-sonnet-5`, `claude-haiku-4-5`, plus `[1m]` long-context variants like `claude-fable-5[1m]` or `claude-opus-5[1m]` — every family except haiku has one, or shortcuts `fable` / `opus` / `sonnet` / `haiku` and their `1m` forms like `fable1m` / `opus1m`) for the Claude subscription backend, or GPT-family / Llama / any-other-model names for your configured OpenAI-compat backends. `GET /v1/models` autodetects the available set from Anthropic's live catalog (hourly TTL; baked fallback when offline), and the family shortcuts always resolve to the newest model of that family it lists.
+
+For per-tool setup (Cursor, Continue, Aider, Cline, Roo, Zed, OpenHands, etc.), see [agent compatibility](./integrations/agent-compat.md#per-tool-setup).
+
+## curl
+
+```bash
+# Claude backend via Anthropic format
+curl http://localhost:3456/v1/messages \
+  -H "Content-Type: application/json" \
+  -H "anthropic-version: 2023-06-01" \
+  -d '{"model":"claude-opus-5","max_tokens":1024,"messages":[{"role":"user","content":"Hello!"}]}'
+
+# OpenAI backend via OpenAI format
+curl http://localhost:3456/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer dario" \
+  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello!"}]}'
+```
+
+## Streaming, tool use, prompt caching, extended thinking
+
+All supported. Claude backend: full Anthropic SSE format plus OpenAI-SSE translation for tool_use streaming. OpenAI-compat backend: streaming body forwarded byte-for-byte. See [Wire-fidelity axes](./wire-fidelity.md) for the v3.25 `--drain-on-close` knob that matches CC's read-to-EOF stream-consumption pattern.
+
+## Provider prefix
+
+Any request's `model` field can be written as `<provider>:<name>` to force which backend handles it, regardless of what the model name looks like.
+
+| Prefix | Backend |
+|---|---|
+| `openai:` | OpenAI-compat backend |
+| `groq:` | OpenAI-compat backend |
+| `openrouter:` | OpenAI-compat backend |
+| `local:` | OpenAI-compat backend |
+| `compat:` | OpenAI-compat backend |
+| `claude:` | Claude subscription backend |
+| `anthropic:` | Claude subscription backend |
+
+The prefix gets stripped before the request goes upstream — the backend only sees the bare model name. Unrecognized prefixes are ignored, so Ollama-style `llama3:8b` passes through untouched. `dario proxy --model=openai:gpt-4o` applies the prefix to every request server-wide.
+
+## Library mode
+
+```typescript
+import { startProxy, getAccessToken, getStatus, listBackends } from "@askalf/dario";
+
+await startProxy({ port: 3456, verbose: true });
+const token = await getAccessToken();
+const status = await getStatus();
+const backends = await listBackends();
+```
+
+## Health check
+
+```bash
+curl http://localhost:3456/health
+```

package/docs/vpn-routing.md

@@ -0,0 +1,108 @@
+# VPN routing
+
+For users who want their dario traffic — `api.anthropic.com` requests, OAuth flows, OpenAI-compat backend forwarding — routed through a VPN without putting the entire host on a system VPN. Three approaches, ordered by friction:
+
+## Option A — System VPN (zero config, covers everyone)
+
+The simplest approach. Run a system-level VPN client and **all** outbound from your machine — including dario's calls — goes through the tunnel.
+
+```bash
+# 1. Install your provider's client (ProtonVPN, Mullvad, AirVPN, Tailscale, raw WireGuard…)
+# 2. Connect.
+# 3. Verify your egress IP changed:
+curl ifconfig.me
+# 4. Run dario normally:
+dario proxy
+```
+
+This covers every dario use case. No flags needed. The tradeoff is that *all* traffic from the machine is now tunneled — fine if you wanted that anyway, less ideal if you only want dario egress to be private.
+
+## Option B — Per-process via `--upstream-proxy=` (v3.35.0+)
+
+Routes only dario's outbound through an HTTP/HTTPS proxy. The rest of your system stays on the default route.
+
+```bash
+# Mullvad's HTTP proxy endpoint (Mullvad SOCKS5 also exists; see notes below)
+dario proxy --upstream-proxy=http://10.64.0.1:80
+
+# Or with credentials embedded:
+dario proxy --upstream-proxy=http://user:pass@proxy.example.com:8080
+
+# Or via env var:
+DARIO_UPSTREAM_PROXY=http://127.0.0.1:8118 dario proxy
+
+# Short alias is also supported:
+dario proxy --via=http://127.0.0.1:8118
+```
+
+dario's startup banner confirms when it's active:
+
+```
+[dario] Outbound proxy: http://10.64.0.1:80/ (all upstream fetches routed; localhost bypasses)
+```
+
+`dario doctor` surfaces the same:
+
+```
+[INFO]  Outbound proxy   DARIO_UPSTREAM_PROXY=http://10.64.0.1:80/. Upstream fetches routed via this proxy; localhost calls bypass.
+```
+
+### Provider matrix
+
+| Provider | HTTP proxy | Notes |
+|---|---|---|
+| **Mullvad** | `http://10.64.0.1:80` (default) | SOCKS5 also at `:1080`; use HTTP for dario |
+| **AirVPN** | `http://nl.airvpn.org:443` (varies by region) | HTTP available on all gateways |
+| **ProtonVPN** | (no native HTTP proxy) | Use Option A (system VPN) instead |
+| **Privoxy / Polipo** | `http://127.0.0.1:8118` | Local; useful with Tor (`forward-socks5 / 127.0.0.1:9050`) |
+| **Cloudflare WARP** | `http://127.0.0.1:40000` | Native HTTP proxy mode in `warp-cli set-mode proxy` |
+| **Corporate proxy** | `http://proxy.corp:8080` | Standard org pattern |
+| **Squid (self-hosted)** | `http://your-squid:3128` | Run a squid instance in a desired jurisdiction |
+
+### Constraints
+
+- **Bun runtime required.** Bun's fetch implements the `proxy` option natively. Node's built-in fetch ignores it silently — to avoid a false-success failure mode where the flag appears to work while requests actually go direct, dario refuses to start with `--upstream-proxy` unless running under Bun. dario auto-relaunches under Bun when available; `bun run dario proxy --upstream-proxy=...` works directly.
+- **HTTP/HTTPS schemes only.** SOCKS5 is not currently supported by Bun 1.3.x's fetch (`UnsupportedProxyProtocol`). If your VPN provider only exposes SOCKS5, run a local SOCKS-to-HTTP bridge such as `privoxy` with `forward-socks5 / 127.0.0.1:1080` and point dario at the privoxy HTTP side.
+- **TLS terminates end-to-end at Anthropic.** The proxy sees only the destination hostname (via SNI) and byte timing in CONNECT mode — not your request bodies. Your `bun-match` BoringSSL ClientHello is preserved.
+- **Localhost calls bypass the proxy.** Anything dario fetches at `localhost`, `127.0.0.1`, `::1`, or any `*.localhost` host goes direct (so self-tests and inbound aren't accidentally tunneled).
+
+## Option C — Tailscale exit nodes (zero dario config, ideal for teams)
+
+If you already run Tailscale, you can route through any peer node:
+
+```bash
+# 1. Designate an exit node on a peer (e.g., a Tailscale-routed node in a desired region)
+# 2. From your machine:
+sudo tailscale up --exit-node=<peer-name-or-IP>
+# 3. Run dario normally — egress is now via the Tailscale exit
+dario proxy
+```
+
+This is the cleanest pattern for teams: one peer runs in a known jurisdiction, every team member's dario egresses through it, audit trail lives at the peer. The hosted dario Pro tier can ship managed exit nodes as a turnkey feature.
+
+## What this does NOT do
+
+- **Doesn't change CC's wire fingerprint.** TLS ClientHello is still Bun's BoringSSL (or Node's OpenSSL if you're on Node — see `dario doctor`'s Runtime/TLS row). The proxy is at L4 transport; the L7 TLS fingerprint is end-to-end.
+- **Doesn't hide your usage from Anthropic.** Anthropic still sees an authenticated OAuth subscription session billed against your account. Egress IP varies; the account does not.
+- **Doesn't proxy CC's own traffic during live capture.** dario spawns the installed `claude` binary to capture its outbound — that subprocess uses the host's normal network. If you also want CC's capture traffic tunneled, run dario under Option A or C.
+
+## Verifying it's working
+
+The most direct check: hit a request-and-response endpoint that echoes your egress IP:
+
+```bash
+# With dario running:
+DARIO_UPSTREAM_PROXY=http://your-proxy:port dario proxy --verbose &
+
+# Then in another terminal, force a request through dario:
+curl http://localhost:3456/v1/messages \
+  -H "Content-Type: application/json" \
+  -H "anthropic-version: 2023-06-01" \
+  -d '{"model":"claude-haiku-4-5","max_tokens":50,"messages":[{"role":"user","content":"hi"}]}'
+
+# In the dario verbose log, the upstream connection will show as routed
+# via the proxy. Provider-side logs (Mullvad / AirVPN / squid) will show
+# a CONNECT to api.anthropic.com:443 from your dario process.
+```
+
+If your VPN provider's status page or dashboard shows the connection, the routing is working. If it doesn't, double-check that dario relaunched under Bun (`dario doctor`'s Runtime/TLS row should say `bun-match`).

package/docs/why-now-2026-06.md

@@ -0,0 +1,93 @@
+# The 2026 billing split: announced, paused, watched
+
+Anthropic [announced on 2026-05-13](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan) — via the Claude Help Center and a [@ClaudeDevs post](https://x.com/ClaudeDevs/status/2054610152817619388), with no anthropic.com blog post and no email to most subscribers — that starting **2026-06-15**, Claude Agent SDK and `claude -p` (Claude Code headless mode) usage would no longer count toward Claude plan usage limits. Instead, eligible plans would receive a fixed monthly Agent-SDK credit. The announced terms:
+
+| Plan | Subscription pool (interactive Claude Code, Claude Cowork, Claude.ai) | Announced Agent-SDK / `claude -p` credit |
+|---|---|---|
+| Pro | $20/mo | $20/mo |
+| Max 5x | $100/mo | $100/mo |
+| Max 20x | $200/mo | $200/mo |
+| Team Premium | $100/mo | $100/mo |
+| Enterprise (seat-based) | included | $200/mo |
+
+Once the Agent-SDK credit was exhausted, those calls would flip to **metered per-token API pricing**, with the subscription pool reserved for interactive use.
+
+## What actually happened: it was paused
+
+**Anthropic paused the change before 2026-06-15, and it never took effect.** The Help Center now states that Agent-SDK usage, `claude -p`, and third-party app usage continue drawing from your existing subscription pool, unchanged. Anthropic said it is reworking the proposal "to better support how users build with Claude subscriptions" and pledged advance notice before implementing any revised version. No credits were issued; no subscription limits changed.
+
+So as of this writing, the split is **not live**. A `claude -p` run or an Agent SDK app bills your subscription pool today whether or not it goes through dario. The reason this document still exists — and the reason dario's daily billing-classifier canary still runs — is that the change was announced once, on short public notice, and Anthropic has explicitly reserved the right to bring back a revised version.
+
+## Why dario holds either way
+
+Dario's Claude backend was designed to make every outbound request look like an **interactive Claude Code session** at the wire level. That predates the 2026-05-13 announcement — it's the same mechanism that's routed traffic through your Pro / Max 5x / Max 20x subscription pool since v3.22.
+
+The relevant property: Anthropic's billing classifier identifies traffic by what arrives at `api.anthropic.com`, not by what initiated it locally. A `claude -p` invocation that talks to dario gets rewritten into an interactive Claude Code request shape before it leaves your machine. The classifier sees interactive CC and applies the subscription pool — today, with the split paused, and equally if a revised split ever makes the entrypoint billable.
+
+This is the entire point of the wire-fidelity work in [`wire-fidelity.md`](./wire-fidelity.md). Axes — body key order, TLS ClientHello, inter-request timing, stream-consumption shape, session-ID lifecycle, request headers — were closed specifically so the upstream classifier has no observable signal that the request originated outside an interactive CC session.
+
+## What this means concretely
+
+| Setup | Today (split paused) | If a revised split ships |
+|---|---|---|
+| Direct Anthropic API with API key (Cline default, Aider default, your scripts) | Per-token API billing | Per-token API billing (unchanged) |
+| Proxy that forwards `claude -p` / Agent SDK request shape unchanged | Subscription pool | **Separate $20–200/mo Agent-SDK credit, then per-token API** |
+| **dario** | **Subscription pool** | **Subscription pool (request rewritten as interactive CC)** |
+| Claude Code itself (you, sitting at a terminal) | Subscription pool | Subscription pool (unchanged) |
+
+No config change is needed on the user side, split or no split — same install, same `localhost:3456`, same `ANTHROPIC_BASE_URL=http://localhost:3456` env var. The wire-rewrite has been doing this job in production for months.
+
+## The tripwire: how you'd know the day it returns
+
+You don't have to watch Anthropic's Help Center. dario runs a **daily billing-classifier canary** ([`cc-billing-classifier-canary.yml`](../.github/workflows/cc-billing-classifier-canary.yml)) that fires one live request and asserts the `representative-claim` header still maps to a subscription bucket. A revived split — or any silent classifier change that reclassifies dario's traffic — surfaces as a canary failure and an auto-opened issue within a day, not on a surprise invoice. It's one of [three drift watchers](../README.md#how-it-works-and-how-it-stays-working) that keep the wire-rewrite current against a moving target.
+
+You can run the same check by hand at any time:
+
+### Verify the rate-limit headers
+
+```bash
+# 1. Direct claude -p, no dario.
+unset ANTHROPIC_BASE_URL ANTHROPIC_API_KEY
+claude -p "say hi" 2>&1 | grep -i 'rate-limit\|representative'
+
+# 2. The same prompt through dario.
+export ANTHROPIC_BASE_URL=http://localhost:3456
+export ANTHROPIC_API_KEY=dario
+claude -p "say hi" 2>&1 | grep -i 'rate-limit\|representative'
+```
+
+What to look for:
+- Both calls should reference `five_hour` or `seven_day` — subscription-billing accounting buckets — because the split is paused and `claude -p` bills subscription directly too. See [Discussion #1](https://github.com/askalf/dario/discussions/1) for the full breakdown of subscription rate-limit headers.
+- If a revised split ships, the **direct** call would move to an Agent-SDK / credit bucket while the **dario** call should stay in `five_hour` / `seven_day`. If dario's path ever lands in an agent-credit or `overage` bucket, file an issue — that's the upstream classifier drift the live template extractor and the [drift detector](../scripts/capture-full-body.mjs) exist to catch.
+
+### Verify via dario doctor
+
+```bash
+dario doctor          # template drift + OAuth + runtime/TLS
+dario doctor --usage  # also fires one request and prints the live billing bucket
+```
+
+A clean `dario doctor` report is the per-machine equivalent of the rate-limit-header check above.
+
+## What this doesn't promise
+
+1. **dario doesn't multiply your subscription.** It routes through the plan you have. Beyond the subscription cap, Anthropic still rate-limits; [multi-account pool mode](./multi-account-pool.md) is the answer for hitting the cap on a single account, and it's orthogonal to the billing-split question.
+2. **No claim about competitor products specifically.** The tables above refer to architectural patterns (`proxy that forwards request shape unchanged`), not named tools. If a particular tool also implements wire-fidelity replay, it gets the same outcome dario does. This doc exists because most subscription-billing proxies don't — they extract OAuth tokens and forward the raw client request, which is exactly the shape a revived split would reclassify.
+3. **Anthropic terms of service still apply.** This project is independent, unofficial, third-party — see [DISCLAIMER.md](../DISCLAIMER.md). Whether any particular use complies with Anthropic's current terms is between you and Anthropic.
+
+## If you're coming from another proxy
+
+1. `npm install -g @askalf/dario` (or pull `ghcr.io/askalf/dario:latest` — see [`docker.md`](./docker.md))
+2. `dario login` — if you have Claude Code installed and logged in, this picks up existing credentials. Otherwise it runs its own OAuth flow. For SSH / headless setups, `dario login --manual`.
+3. `dario proxy` — starts the local proxy on `localhost:3456`
+4. Point your tools' `ANTHROPIC_BASE_URL` at `http://localhost:3456` and `ANTHROPIC_API_KEY` at `dario` (literal string `dario` on loopback; a real `DARIO_API_KEY` if you bind to `0.0.0.0`)
+5. `dario doctor` — confirms everything is wired correctly
+
+Backends other than the Claude subscription (OpenAI, Groq, OpenRouter, Ollama, etc.) are configured separately via `dario backend add` — see the [README](../README.md).
+
+## Related reading
+
+- [`wire-fidelity.md`](./wire-fidelity.md) — the wire-rewrite axes that make this possible
+- [`returning.md`](./returning.md) — if you used dario before and are coming back
+- [`multi-account-pool.md`](./multi-account-pool.md) — running multiple subscriptions in a pool
+- [Discussion #1](https://github.com/askalf/dario/discussions/1) — rate-limit header reference for subscription billing

package/docs/wire-fidelity.md

@@ -0,0 +1,16 @@
+# Wire-fidelity axes
+
+Between v3.22 and v3.28, dario's Claude backend closed six axes along which a proxy can diverge from real Claude Code. Each is a separate knob, each ships with its own test suite, each is surfaced through `dario doctor` where the axis has something to report. Defaults are chosen so existing setups don't regress.
+
+| Axis | Release | What it does | How to tune |
+|---|---|---|---|
+| **Request body key order** | v3.22 | Top-level JSON key order of the outbound `/v1/messages` body is captured from CC's wire serialization and replayed byte-for-byte. Schema bumped v2 → v3; stale caches quarantined. | Automatic once a live capture exists. The baked fallback carries a v2.1.112 snapshot. |
+| **Runtime / TLS ClientHello** | v3.23 | Classifies the runtime as `bun-match` / `bun-ja3-unverified` / `bun-bypassed` / `node-only` and surfaces the class + hint in `dario doctor`. Bun yields the BoringSSL ClientHello CC presents; Node yields OpenSSL's (distinct JA3). Being on Bun is necessary but not sufficient — only Bun ≥ v1.3.14 is measured to reproduce CC's JA3, so an older Bun is flagged `bun-ja3-unverified` rather than green (#813). | `--strict-tls` (or `DARIO_STRICT_TLS=1`) refuses to start proxy mode unless `bun-match`. `DARIO_QUIET_TLS=1` silences the startup banner in known-fine environments. |
+| **Inter-request timing** | v3.24 | Replaces the hardcoded 500 ms floor with a configurable floor + uniform jitter. A fixed 500 ms minimum-inter-arrival is an observable edge at scale; jitter dissolves the edge. | `--pace-min=MS`, `--pace-jitter=MS`, or `DARIO_PACE_MIN_MS` / `DARIO_PACE_JITTER_MS`. Legacy `DARIO_MIN_INTERVAL_MS` still honored. |
+| **Stream-consumption shape** | v3.25 | When a downstream client disconnects mid-stream, CC keeps reading SSE to EOF. Dario now offers the same: drain upstream to completion even when the consumer has left. Default off — don't silently burn tokens. | `--drain-on-close` / `DARIO_DRAIN_ON_CLOSE=1`. Bounded by the existing 5-minute upstream timeout. |
+| **Session-ID lifecycle** | v3.28 | Generalizes the v3.19 hardcoded 15-minute idle rotation into a tunable `SessionRegistry` with jitter, max-age, and per-client bucketing. Fixes a v3.27 body/header rotation race as a side effect. | `--session-idle-rotate=MS` (default 900000), `--session-rotate-jitter=MS`, `--session-max-age=MS`, `--session-per-client`. Env mirrors `DARIO_SESSION_*`. Defaults are bit-identical to v3.27. |
+| **MCP / sub-agent reach** | v3.26 + v3.27 | Not a wire axis — a *surface* axis. CC-aware tools can now address dario directly (sub-agent from inside CC, MCP server for any MCP client), so operators don't have to switch terminals to introspect the proxy. Read-only by design. | `dario subagent install` / `dario mcp`. See [`mcp-server.md`](./mcp-server.md) and [`sub-agent.md`](./sub-agent.md). |
+
+| **Client identity headers** | v5.4.19 | On the passthrough path `isGenuineCCClient` has already established the caller *is* Claude Code, so its own identity headers (`user-agent`, `x-app`, `x-stainless-*`, `x-claude-code-*`, `x-client-*`) are forwarded unchanged instead of being replaced with template values. The template exists to synthesise CC's shape for clients that are not CC; where the genuine article is in hand, forwarding beats imitating. Measured before the change: of 13 identity headers a real client sent, 12 were replaced and 1 dropped — 0 forwarded (#885). Auth, session id and the merged beta set stay dario's. | Automatic on the genuine-CC path; nothing to tune. Non-CC clients are unaffected, and the gate reads the request **body**, so headers cannot self-authorise. |
+
+The original six-direction roadmap is complete; the axes below it are later findings. Note that header **order** is deliberately absent as an axis: `orderHeadersForOutbound` builds the captured sequence, but `fetch()` re-normalises it before the wire, and on Bun you cannot have both CC's JA3 and raw header control in one process (#813). The honest framing of the whole table is byte-identical **body**, structurally close **headers** — not packet-identical.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "5.4.16",
+  "version": "5.4.19",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {
@@ -16,13 +16,15 @@
   },
   "files": [
     "dist",
+    "docs",
+    "!docs/recovery.md",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc && cp src/cc-template-data.json dist/",
     "test": "node --test --test-concurrency=8 test/all.test.mjs",
-    "test:serial": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/tool-schema-contract.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/analytics-billing-bucket.mjs && node test/failover-429.mjs && node test/pool-sticky.mjs && node test/live-fingerprint.mjs && node test/proxy-header-order.mjs && node test/proxy-body-order.mjs && node test/runtime-fingerprint.mjs && node test/pacing.mjs && node test/stream-drain.mjs && node test/subagent.mjs && node test/mcp-protocol.mjs && node test/mcp-tools.mjs && node test/mcp-e2e.mjs && node test/session-rotation.mjs && node test/drift-detection.mjs && node test/cc-authorize-probe-classifier.mjs && node test/compat-range.mjs && node test/doctor-formatter.mjs && node test/doctor-identity-drift.mjs && node test/atomic-write.mjs && node test/account-refresh-singleflight.mjs && node test/durable-token-persist.mjs && node test/streaming-edge-cases.mjs && node test/client-detection.mjs && node test/manual-oauth-flow.mjs && node test/scrub-template.mjs && node test/context-bleed.mjs && node test/capture-provenance.mjs && node test/sanitize-messages.mjs && node test/platform-tools.mjs && node test/strict-template-flags.mjs && node test/request-queue.mjs && node test/effort-flag.mjs && node test/template-invariants.mjs",
+    "test:serial": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/tool-schema-contract.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/analytics-billing-bucket.mjs && node test/failover-429.mjs && node test/pool-sticky.mjs && node test/live-fingerprint.mjs && node test/proxy-header-order.mjs && node test/proxy-body-order.mjs && node test/runtime-fingerprint.mjs && node test/pacing.mjs && node test/stream-drain.mjs && node test/subagent.mjs && node test/mcp-protocol.mjs && node test/mcp-tools.mjs && node test/mcp-e2e.mjs && node test/session-rotation.mjs && node test/drift-detection.mjs && node test/cc-authorize-probe-classifier.mjs && node test/compat-range.mjs && node test/doctor-formatter.mjs && node test/doctor-identity-drift.mjs && node test/atomic-write.mjs && node test/account-refresh-singleflight.mjs && node test/durable-token-persist.mjs && node test/streaming-edge-cases.mjs && node test/client-detection.mjs && node test/manual-oauth-flow.mjs && node test/scrub-template.mjs && node test/context-bleed.mjs && node test/passthrough-header-forwarding.mjs && node test/capture-provenance.mjs && node test/sanitize-messages.mjs && node test/platform-tools.mjs && node test/strict-template-flags.mjs && node test/request-queue.mjs && node test/effort-flag.mjs && node test/template-invariants.mjs",
     "audit": "npm audit --production --audit-level=high",
     "prepublishOnly": "npm run build",
     "start": "node dist/cli.js",