@askalf/dario 4.8.75 → 4.8.77

package/README.md

@@ -200,9 +200,9 @@ The tool doesn't know. The backend doesn't know. dario is the seam.
 
 ## Overage guard
 
-A subscriber should never see a single `representative-claim: overage` response during normal operation. One means something is wrong — wire-shape drift, a classifier change, an account misconfig — and continuing to forward requests in the same shape bleeds real money (accounts with extra-usage enabled) or returns a wall of rejections (accounts without it). The first hit is the signal; the second through hundredth are damage.
+A subscriber should never see a single response billed outside their subscription pool during normal operation. One means something is wrong — wire-shape drift, a classifier change, an account misconfig — and continuing to forward requests in the same shape bleeds real money (accounts with extra-usage enabled) or returns a wall of rejections (accounts without it). The first hit is the signal; the second through hundredth are damage.
 
-So the moment any upstream response carries `representative-claim: overage`, dario **halts the proxy**. Every subsequent request returns `503` with an Anthropic-shaped error body the client surfaces verbatim, until you run `dario resume`, press `R` on the TUI, or the cooldown clears (default 30 min). The halt is visible across the TUI's Status, Hits, and Analytics tabs, fires a best-effort native OS notification, and emits named SSE events.
+So the moment any upstream response bills to something other than your subscription pool — `representative-claim: overage`, `api`, or a new credit/SDK bucket like the one the 2026-06-15 Agent-SDK split introduces — dario **halts the proxy**. The check is an allow-list, not a match on `overage`: anything that isn't a known subscription claim (`five_hour`/`seven_day` and their fallbacks) and isn't the `unknown` no-header sentinel trips it, so a credit-bucket claim dario has never seen still halts. Every subsequent request returns `503` with an Anthropic-shaped error body the client surfaces verbatim, until you run `dario resume`, press `R` on the TUI, or the cooldown clears (default 30 min). The halt is visible across the TUI's Status, Hits, and Analytics tabs, fires a best-effort native OS notification, and emits named SSE events. (In `--upstream-api-key` passthrough mode the guard is off — `api` billing is the point there, not a failure.)
 
 ```
 ┌─ dario ─────────────────────────────[ q quit · Tab next · ? help ]──┐
@@ -368,26 +368,27 @@ Follow [@ask_alf](https://x.com/ask_alf) for drift bulletins as they happen.
 
 MIT — see [LICENSE](LICENSE) and [DISCLAIMER.md](DISCLAIMER.md).
 
-## Also by askalf
+## Own Your Stack
 
-| Project | What it does |
-|---|---|
-| [askalf platform](https://askalf.org) | Self-hosted AI workforce — agents that run real business + life work. Uses dario as its LLM substrate. *Early access at [askalf.org](https://askalf.org).* |
-| [hands](https://github.com/askalf/hands) | Cross-platform computer-use agent — your LLM on your mouse, keyboard, and screen. Routes through dario or any Anthropic-compat. |
-| [deepdive](https://github.com/askalf/deepdive) | Local research agent. One command, cited answer. Plan → search → headless fetch → extract → synthesize. |
-| [agent](https://github.com/askalf/agent) | Connect any device to an askalf fleet — runs the shell or Claude Code tasks the fleet dispatches. |
-| [browser-bridge](https://github.com/askalf/browser-bridge) | Stealth headless Chromium in a container, CDP on 9222. Playwright / Puppeteer / MCP-compatible. |
-| [claude-sync](https://github.com/askalf/claude-sync) | Sync Claude Code sessions across machines via a portable `.ccsync` file. |
-| [pgflex](https://github.com/askalf/pgflex) | One Postgres API, two modes — real PostgreSQL for production, PGlite (WASM) for dev. |
-| [redisflex](https://github.com/askalf/redisflex) | One Redis API, two modes — ioredis for production, in-process for dev. Includes a BullMQ-shaped in-memory queue. |
+dario is the routing layer of **[Own Your Stack](https://github.com/askalf)** — open tools for owning your AI infrastructure instead of renting it by the token. One subscription. Your box. Your terms.
 
+| Tool | |
+|---|---|
+| **[dario](https://github.com/askalf/dario)** | own your routing — your subscription, in any tool *(you are here)* |
+| **[deepdive](https://github.com/askalf/deepdive)** | own your research — local agent, cited answers |
+| **[hands](https://github.com/askalf/hands)** | own your computer-use — your LLM on your own mouse & keyboard |
+| **[agent](https://github.com/askalf/agent)** | own your fleet — connect any device, dispatch real work |
+| **[browser-bridge](https://github.com/askalf/browser-bridge)** | own your browser — stealth headless Chromium, your CDP endpoint |
+| **[claude-sync](https://github.com/askalf/claude-sync)** | own your sessions — sync Claude Code across machines |
+| **[askalf platform](https://askalf.org)** | own your operation — the self-hosted AI workforce, running on this stack |
 
 ---
 
-## Built by Sprayberry Labs
+## Built by Thomas Sprayberry
 
-This is one of the open-source building blocks from **[Sprayberry Labs](https://sprayberrylabs.com)** — an independent studio (Atlanta, GA) that ships bespoke software and **fixed-price code & security audits**, delivered with the AI workforce these tools are part of.
+dario is part of **Own Your Stack** — the open toolkit behind **[Sprayberry Labs](https://sprayberrylabs.com)**, an independent studio (Atlanta, GA) that ships bespoke software with the autonomous AI workforce these tools are part of.
 
-Part of the [askalf](https://askalf.org) ecosystem — a self-hosted AI workforce platform, now in early access.
+Built in the open, scars included. Follow the build → **[@ask_alf](https://x.com/ask_alf)** · **[sprayberrylabs.com/own-your-stack](https://sprayberrylabs.com/own-your-stack)**
 
-**Got a codebase that needs an expert read?** → **[Scan a repo — free mini-audit](https://sprayberrylabs.com)**, or see the **$1,500 fixed-price Audit** and build Sprints. · [sprayberrylabs.com](https://sprayberrylabs.com) · hello@sprayberrylabs.com
+---
+Part of **[Own Your Stack](https://github.com/askalf)** — own your AI infrastructure instead of renting it. Built by Thomas Sprayberry.

package/dist/analytics.d.ts

@@ -55,6 +55,34 @@ export type BillingBucket = 'subscription' | 'subscription_fallback' | 'extra_us
  * billing bucket. Pure function; no state; safe to call from any context.
  */
 export declare function billingBucketFromClaim(claim: string | null | undefined): BillingBucket;
+/**
+ * The `representative-claim` values that mean "billed against the subscription
+ * pool" — the place dario exists to keep traffic. `five_hour`/`seven_day` and
+ * their server-side `_fallback` variants are all subscription billing (see
+ * `billingBucketFromClaim` + discussion #1). Anything else is either a
+ * non-subscription billing classification or the `unknown` sentinel below.
+ */
+export declare const SUBSCRIPTION_CLAIMS: ReadonlySet<string>;
+/**
+ * The sentinel `claim` dario assigns when a response carried no rate-limit
+ * header at all (non-200s, stream aborts, early rejects — see `pool.ts`
+ * `parseRateLimits` / `EMPTY_SNAPSHOT`). It is NOT a billing classification,
+ * so the overage-guard must never halt on it.
+ */
+export declare const NO_BILLING_CLAIM = "unknown";
+/**
+ * True when a claim represents real *non-subscription* billing — the
+ * condition the overage-guard halts on (see `overage-guard.ts`, #288).
+ *
+ * Deliberately an allow-list, not `claim === 'overage'`: it halts on anything
+ * that is NOT a known subscription claim AND NOT the `unknown` sentinel. That
+ * catches `overage` and `api` as before, but ALSO any new credit/SDK bucket
+ * string Anthropic introduces — e.g. the 2026-06-15 Agent-SDK/headless split,
+ * whose credit-bucket claim dario has never observed (it keeps traffic in the
+ * pool) and so cannot hardcode. `unknown` is exempt: halting on it would halt
+ * the proxy on every transient non-200/stream-abort.
+ */
+export declare function isNonSubscriptionBilling(claim: string | null | undefined): boolean;
 export declare class Analytics extends EventEmitter {
     private records;
     private maxRecords;

package/dist/analytics.js

@@ -37,6 +37,43 @@ export function billingBucketFromClaim(claim) {
             return 'unknown';
     }
 }
+/**
+ * The `representative-claim` values that mean "billed against the subscription
+ * pool" — the place dario exists to keep traffic. `five_hour`/`seven_day` and
+ * their server-side `_fallback` variants are all subscription billing (see
+ * `billingBucketFromClaim` + discussion #1). Anything else is either a
+ * non-subscription billing classification or the `unknown` sentinel below.
+ */
+export const SUBSCRIPTION_CLAIMS = new Set([
+    'five_hour',
+    'seven_day',
+    'five_hour_fallback',
+    'seven_day_fallback',
+]);
+/**
+ * The sentinel `claim` dario assigns when a response carried no rate-limit
+ * header at all (non-200s, stream aborts, early rejects — see `pool.ts`
+ * `parseRateLimits` / `EMPTY_SNAPSHOT`). It is NOT a billing classification,
+ * so the overage-guard must never halt on it.
+ */
+export const NO_BILLING_CLAIM = 'unknown';
+/**
+ * True when a claim represents real *non-subscription* billing — the
+ * condition the overage-guard halts on (see `overage-guard.ts`, #288).
+ *
+ * Deliberately an allow-list, not `claim === 'overage'`: it halts on anything
+ * that is NOT a known subscription claim AND NOT the `unknown` sentinel. That
+ * catches `overage` and `api` as before, but ALSO any new credit/SDK bucket
+ * string Anthropic introduces — e.g. the 2026-06-15 Agent-SDK/headless split,
+ * whose credit-bucket claim dario has never observed (it keeps traffic in the
+ * pool) and so cannot hardcode. `unknown` is exempt: halting on it would halt
+ * the proxy on every transient non-200/stream-abort.
+ */
+export function isNonSubscriptionBilling(claim) {
+    if (!claim || claim === NO_BILLING_CLAIM)
+        return false;
+    return !SUBSCRIPTION_CLAIMS.has(claim);
+}
 // Anthropic pricing (per 1M tokens, USD). Not authoritative — used for
 // rough burn-rate display in the /analytics summary.
 const PRICING = {

package/dist/cch.d.ts

@@ -0,0 +1,18 @@
+/** Verified per-release seeds, keyed on `major.minor.patch`. */
+export declare const CCH_SEEDS: Record<string, bigint>;
+/** Canonical xxHash64 of `data` with a 64-bit `seed`. */
+export declare function xxh64(data: Uint8Array, seed: bigint): bigint;
+/**
+ * Deterministic 5-hex cch for a serialized body under an EXPLICIT seed, or
+ * null if the body carries no `cch=XXXXX` token. Used by `scripts/cch-
+ * calibrate.mjs` to test candidate seeds against a live capture without going
+ * through the version table.
+ */
+export declare function cchWithSeed(bodyText: string, seed: bigint): string | null;
+/**
+ * Deterministic 5-hex `cch` for a serialized request body, or null when:
+ *  - `version` (major.minor.patch) has no known seed, or
+ *  - the body carries no `cch=XXXXX` billing token to stamp.
+ * A null return means the caller should keep its random placeholder.
+ */
+export declare function cchForBody(bodyText: string, version: string): string | null;

package/dist/cch.js

@@ -0,0 +1,139 @@
+// Deterministic Claude Code request-integrity hash (`cch`) — dario#528.
+//
+// Claude Code stamps each /v1/messages request with a 5-hex `cch` token inside
+// the `x-anthropic-billing-header` system block. It is NOT random: it is an
+// xxHash64 over a canonical PROJECTION of the request body, masked to 20 bits.
+// Reverse-engineered by lwsh123k (dario#528) and verified here against live
+// captures on Claude Code 2.1.177:
+//
+//   material = the serialized body, transformed by:
+//     1. reset the `cch=XXXXX` token to `cch=00000`
+//     2. blank the "model" VALUE (keep the key)
+//     3. delete "fallbacks", "fallback_credit_token", "max_tokens"
+//     4. re-serialize as compact JSON (JSON.stringify)
+//   cch = ( xxHash64(material, SEED[version]) & 0xFFFFF ) as zero-padded 5-hex
+//
+// The excluded fields are exactly the ones a routing proxy rewrites (model,
+// fallbacks, max_tokens), so the value is STABLE across dario's rewrites — the
+// upstream re-derives the same projection from whatever we send and recomputes
+// the identical hash. dario therefore only has to hash its own final body.
+//
+// The seed rotates per Claude Code release and is keyed on major.minor.patch
+// (the build-tag suffix, e.g. ".e2d" vs ".dd9", does NOT change it — verified
+// against two captures with different suffixes, same 2.1.177 seed). An unknown
+// version returns null so the caller falls back to a random value (the
+// pre-dario#528 behavior) rather than emitting a confident-but-wrong hash that
+// a validating server could single out.
+/** Verified per-release seeds, keyed on `major.minor.patch`. */
+export const CCH_SEEDS = {
+    '2.1.177': 0x4d659218e32a3268n,
+};
+const MASK = 0xfffffn;
+const U64 = (1n << 64n) - 1n;
+// xxHash64 primes.
+const P1 = 0x9e3779b185ebca87n;
+const P2 = 0xc2b2ae3d27d4eb4fn;
+const P3 = 0x165667b19e3779f9n;
+const P4 = 0x85ebca77c2b2ae63n;
+const P5 = 0x27d4eb2f165667c5n;
+const rotl = (x, r) => ((x << r) | (x >> (64n - r))) & U64;
+function round(acc, input) {
+    acc = (acc + input * P2) & U64;
+    acc = rotl(acc, 31n);
+    return (acc * P1) & U64;
+}
+function mergeRound(acc, val) {
+    const r = round(0n, val);
+    acc = (acc ^ r) & U64;
+    return (acc * P1 + P4) & U64;
+}
+/** Canonical xxHash64 of `data` with a 64-bit `seed`. */
+export function xxh64(data, seed) {
+    const len = data.length;
+    const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let h;
+    let i = 0;
+    if (len >= 32) {
+        let v1 = (seed + P1 + P2) & U64;
+        let v2 = (seed + P2) & U64;
+        let v3 = seed & U64;
+        let v4 = (seed - P1) & U64;
+        const limit = len - 32;
+        while (i <= limit) {
+            v1 = round(v1, dv.getBigUint64(i, true));
+            i += 8;
+            v2 = round(v2, dv.getBigUint64(i, true));
+            i += 8;
+            v3 = round(v3, dv.getBigUint64(i, true));
+            i += 8;
+            v4 = round(v4, dv.getBigUint64(i, true));
+            i += 8;
+        }
+        h = (rotl(v1, 1n) + rotl(v2, 7n) + rotl(v3, 12n) + rotl(v4, 18n)) & U64;
+        h = mergeRound(h, v1);
+        h = mergeRound(h, v2);
+        h = mergeRound(h, v3);
+        h = mergeRound(h, v4);
+    }
+    else {
+        h = (seed + P5) & U64;
+    }
+    h = (h + BigInt(len)) & U64;
+    while (i + 8 <= len) {
+        const k1 = round(0n, dv.getBigUint64(i, true));
+        h = (h ^ k1) & U64;
+        h = (rotl(h, 27n) * P1 + P4) & U64;
+        i += 8;
+    }
+    if (i + 4 <= len) {
+        h = (h ^ ((BigInt(dv.getUint32(i, true)) * P1) & U64)) & U64;
+        h = (rotl(h, 23n) * P2 + P3) & U64;
+        i += 4;
+    }
+    while (i < len) {
+        h = (h ^ ((BigInt(data[i]) * P5) & U64)) & U64;
+        h = (rotl(h, 11n) * P1) & U64;
+        i += 1;
+    }
+    h = (h ^ (h >> 33n)) & U64;
+    h = (h * P2) & U64;
+    h = (h ^ (h >> 29n)) & U64;
+    h = (h * P3) & U64;
+    h = (h ^ (h >> 32n)) & U64;
+    return h;
+}
+const CCH_RE = /cch=[0-9a-fA-F]{5}/;
+/** Build the canonical cch pre-image bytes from a serialized request body. */
+function cchMaterial(bodyText) {
+    const zeroed = bodyText.replace(CCH_RE, 'cch=00000'); // first occurrence only
+    const body = JSON.parse(zeroed);
+    body.model = '';
+    delete body.fallbacks;
+    delete body.fallback_credit_token;
+    delete body.max_tokens;
+    return new TextEncoder().encode(JSON.stringify(body));
+}
+/**
+ * Deterministic 5-hex cch for a serialized body under an EXPLICIT seed, or
+ * null if the body carries no `cch=XXXXX` token. Used by `scripts/cch-
+ * calibrate.mjs` to test candidate seeds against a live capture without going
+ * through the version table.
+ */
+export function cchWithSeed(bodyText, seed) {
+    if (!CCH_RE.test(bodyText))
+        return null;
+    const h = xxh64(cchMaterial(bodyText), seed) & MASK;
+    return h.toString(16).padStart(5, '0');
+}
+/**
+ * Deterministic 5-hex `cch` for a serialized request body, or null when:
+ *  - `version` (major.minor.patch) has no known seed, or
+ *  - the body carries no `cch=XXXXX` billing token to stamp.
+ * A null return means the caller should keep its random placeholder.
+ */
+export function cchForBody(bodyText, version) {
+    const seed = CCH_SEEDS[version];
+    if (seed === undefined)
+        return null;
+    return cchWithSeed(bodyText, seed);
+}

package/dist/live-fingerprint.d.ts

@@ -282,7 +282,7 @@ export declare function _resetInstalledVersionProbeForTest(): void;
  */
 export declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.177";
+    readonly maxTested: "2.1.178";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/live-fingerprint.js

@@ -786,7 +786,7 @@ export function _resetInstalledVersionProbeForTest() {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.177',
+    maxTested: '2.1.178',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/overage-guard.d.ts

@@ -1,18 +1,25 @@
 /**
- * Overage-guard — halt the proxy on the first `representative-claim: overage`
- * response to prevent silent API-rate bleed.
+ * Overage-guard — halt the proxy the first time a response bills to anything
+ * other than the subscription pool, to prevent silent API-rate bleed.
  *
- * Subscribers should never see a single overage hit during normal
+ * Subscribers should never see a single non-subscription hit during normal
  * operation. One means something is wrong (wire-shape drift, classifier
  * change, account misconfig, billing-flip after a CC release) and
  * continuing to forward requests bleeds against per-token billing.
  *
  * The guard subscribes to the Analytics record stream — every completed
  * request emits a record carrying its `claim` (raw representative-claim
- * value). When `claim === 'overage'` lands, the guard transitions to a
- * halted state and emits a `'halt'` event. The HTTP request path checks
- * `isHalted()` on every incoming request and returns 503 with an
- * Anthropic-shaped error body when halted.
+ * value). When a non-subscription claim lands — `overage`, `api`, or any
+ * new credit/SDK-bucket string (the 2026-06-15 Agent-SDK split) — the guard
+ * transitions to a halted state and emits a `'halt'` event. The detection is
+ * an allow-list (`isNonSubscriptionBilling`): it fires on anything that is
+ * not a known subscription claim and not the `unknown` sentinel (which means
+ * "no rate-limit header" — a transient non-200/abort, not a billing flip).
+ * The HTTP request path checks `isHalted()` on every incoming request and
+ * returns 503 with an Anthropic-shaped error body when halted.
+ *
+ * The name predates the broadening (it caught only `overage` through v4.8.x,
+ * #288); the issue lineage + `dario_overage_guard` error type are kept stable.
  *
  * Resume paths:
  *   - explicit:  `dario resume` CLI → POST /admin/resume → `clear('manual')`
@@ -26,7 +33,7 @@
  * See dario#288.
  */
 import { EventEmitter } from 'node:events';
-import type { Analytics, RequestRecord } from './analytics.js';
+import { type Analytics, type RequestRecord } from './analytics.js';
 export interface HaltState {
     since: number;
     cooldownUntil: number;
@@ -58,9 +65,11 @@ export declare class OverageGuard extends EventEmitter {
     private analyticsListener;
     constructor(opts: OverageGuardOptions);
     /**
-     * Subscribe to an Analytics instance. Every record emitted with
-     * `claim === 'overage'` triggers halt (when behavior === 'halt') or a
-     * warn-only event (when behavior === 'warn').
+     * Subscribe to an Analytics instance. Every record whose claim is a
+     * non-subscription billing classification (`isNonSubscriptionBilling` —
+     * `overage`, `api`, or a new credit/SDK bucket) triggers halt (when
+     * behavior === 'halt') or a warn-only event (when behavior === 'warn').
+     * Subscription claims and the `unknown` sentinel are ignored.
      *
      * Idempotent — calling attach() a second time replaces the listener
      * rather than stacking; useful for tests.

package/dist/overage-guard.js

@@ -1,18 +1,25 @@
 /**
- * Overage-guard — halt the proxy on the first `representative-claim: overage`
- * response to prevent silent API-rate bleed.
+ * Overage-guard — halt the proxy the first time a response bills to anything
+ * other than the subscription pool, to prevent silent API-rate bleed.
  *
- * Subscribers should never see a single overage hit during normal
+ * Subscribers should never see a single non-subscription hit during normal
  * operation. One means something is wrong (wire-shape drift, classifier
  * change, account misconfig, billing-flip after a CC release) and
  * continuing to forward requests bleeds against per-token billing.
  *
  * The guard subscribes to the Analytics record stream — every completed
  * request emits a record carrying its `claim` (raw representative-claim
- * value). When `claim === 'overage'` lands, the guard transitions to a
- * halted state and emits a `'halt'` event. The HTTP request path checks
- * `isHalted()` on every incoming request and returns 503 with an
- * Anthropic-shaped error body when halted.
+ * value). When a non-subscription claim lands — `overage`, `api`, or any
+ * new credit/SDK-bucket string (the 2026-06-15 Agent-SDK split) — the guard
+ * transitions to a halted state and emits a `'halt'` event. The detection is
+ * an allow-list (`isNonSubscriptionBilling`): it fires on anything that is
+ * not a known subscription claim and not the `unknown` sentinel (which means
+ * "no rate-limit header" — a transient non-200/abort, not a billing flip).
+ * The HTTP request path checks `isHalted()` on every incoming request and
+ * returns 503 with an Anthropic-shaped error body when halted.
+ *
+ * The name predates the broadening (it caught only `overage` through v4.8.x,
+ * #288); the issue lineage + `dario_overage_guard` error type are kept stable.
  *
  * Resume paths:
  *   - explicit:  `dario resume` CLI → POST /admin/resume → `clear('manual')`
@@ -26,6 +33,7 @@
  * See dario#288.
  */
 import { EventEmitter } from 'node:events';
+import { isNonSubscriptionBilling } from './analytics.js';
 export class OverageGuard extends EventEmitter {
     opts;
     halted = null;
@@ -39,9 +47,11 @@ export class OverageGuard extends EventEmitter {
         this.opts = opts;
     }
     /**
-     * Subscribe to an Analytics instance. Every record emitted with
-     * `claim === 'overage'` triggers halt (when behavior === 'halt') or a
-     * warn-only event (when behavior === 'warn').
+     * Subscribe to an Analytics instance. Every record whose claim is a
+     * non-subscription billing classification (`isNonSubscriptionBilling` —
+     * `overage`, `api`, or a new credit/SDK bucket) triggers halt (when
+     * behavior === 'halt') or a warn-only event (when behavior === 'warn').
+     * Subscription claims and the `unknown` sentinel are ignored.
      *
      * Idempotent — calling attach() a second time replaces the listener
      * rather than stacking; useful for tests.
@@ -57,7 +67,7 @@ export class OverageGuard extends EventEmitter {
             return;
         }
         this.analyticsListener = (r) => {
-            if (r.claim === 'overage') {
+            if (isNonSubscriptionBilling(r.claim)) {
                 this.onOverageDetected(r);
             }
         };
@@ -113,7 +123,7 @@ export class OverageGuard extends EventEmitter {
         if (this.opts.notifyOs && this.opts.notifier) {
             try {
                 const title = this.opts.behavior === 'halt' ? 'dario halted' : 'dario warning';
-                const msg = `Request classified as 'overage' (per-token billing)${this.opts.behavior === 'halt' ? '. Proxy halted. Run `dario resume` to continue.' : ''}`;
+                const msg = `Request classified as '${r.claim}' (non-subscription billing)${this.opts.behavior === 'halt' ? '. Proxy halted. Run `dario resume` to continue.' : ''}`;
                 this.opts.notifier(title, msg);
             }
             catch {
@@ -180,10 +190,10 @@ export function buildHaltErrorBody(state) {
         error: {
             type: 'dario_overage_guard',
             message: `dario halted to prevent API-rate bleed. A request was classified ` +
-                `as 'overage' (per-token billing) instead of your subscription pool. ` +
-                `To resume: run \`dario resume\` in another terminal, or wait until ` +
-                `${isoCooldown} for the cooldown to auto-clear. ` +
-                `Details: github.com/askalf/dario/issues/288`,
+                `as '${state.request.claim}' (non-subscription billing) instead of ` +
+                `your subscription pool. To resume: run \`dario resume\` in another ` +
+                `terminal, or wait until ${isoCooldown} for the cooldown to ` +
+                `auto-clear. Details: github.com/askalf/dario/issues/288`,
         },
     };
 }

package/dist/proxy.d.ts

@@ -321,11 +321,13 @@ interface ProxyOptions {
      */
     upstreamApiKey?: string;
     /**
-     * Overage-guard — halt the proxy on the first response carrying
-     * `representative-claim: overage`. Subscribers should never see a
-     * single overage hit during normal operation; one means something
-     * is wrong (wire-shape drift, classifier change, account misconfig)
-     * and continuing to forward bleeds against per-token billing.
+     * Overage-guard — halt the proxy on the first response that bills to
+     * anything other than the subscription pool (`overage`, `api`, or a new
+     * credit/SDK bucket — the 2026-06-15 split). Subscribers should never see
+     * a single non-subscription hit during normal operation; one means
+     * something is wrong (wire-shape drift, classifier change, account
+     * misconfig) and continuing to forward bleeds against per-token billing.
+     * Auto-disabled in upstream-API-key passthrough mode (see proxy setup).
      *
      * Default: enabled, halt behavior, 30-min cooldown, OS-notify on.
      * See dario#288.

package/dist/proxy.js

@@ -9,6 +9,7 @@ import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 import { buildHealthResponse } from './health-response.js';
 import { buildCCRequest, applyCcPromptCaching, parseEffortSuffix, reverseMapResponse, createStreamingReverseMapper, orderHeadersForOutbound, CC_TEMPLATE } from './cc-template.js';
+import { cchForBody } from './cch.js';
 import { describeTemplate, detectDrift, checkCCCompat } from './live-fingerprint.js';
 import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs } from './pool.js';
 import { Analytics, billingBucketFromClaim } from './analytics.js';
@@ -44,7 +45,16 @@ function computeBuildTag(userMessage, version) {
     const chars = [4, 7, 20].map(i => userMessage[i] || '0').join('');
     return createHash('sha256').update(`${BILLING_SEED}${chars}${version}`).digest('hex').slice(0, 3);
 }
-// Per-request cch: random 5-char hex value each request (Claude Code does the same).
+// Per-request cch PLACEHOLDER. Claude Code's cch is a deterministic xxHash64
+// over a projection of the request body (see src/cch.ts, dario#528). We can
+// only compute the real value once the final body is assembled, so we seed the
+// billing tag with a random 5-hex token here and overwrite it in place with the
+// deterministic value at serialize time (the `cchForBody` call near the
+// JSON.stringify of the outbound body). For Claude Code versions whose seed we
+// haven't reverse-engineered, `cchForBody` returns null and this random value
+// is what ships — same behavior as before dario#528, and a better tell than a
+// confident-but-wrong deterministic hash. Operators can force the random path
+// on every request with DARIO_CCH=random.
 function computeCch() {
     return randomBytes(3).toString('hex').slice(0, 5);
 }
@@ -807,8 +817,15 @@ export async function startProxy(opts = {}) {
     // defaults (enabled=true, behavior='halt', cooldown=30min, notifyOs=true)
     // so an opts-less proxy still gets protection. The notifier is wired
     // separately below once notify.ts is loaded.
+    //
+    // Disabled in upstream-API-key passthrough mode: there the operator
+    // explicitly opted into the per-token API pool, so responses legitimately
+    // bill as `api`. The guard now halts on ANY non-subscription claim (incl.
+    // `api`), so leaving it on would false-halt the whole passthrough path
+    // (e.g. the self-hosted compat workflow). The subscription-protection
+    // premise doesn't apply when there's no subscription to protect.
     const overageGuard = new OverageGuard({
-        enabled: opts.overageGuardEnabled ?? true,
+        enabled: (opts.overageGuardEnabled ?? true) && !upstreamApiKey,
         behavior: opts.overageGuardBehavior ?? 'halt',
         cooldownMs: opts.overageGuardCooldownMs ?? 30 * 60 * 1000,
         notifyOs: opts.overageGuardNotifyOs ?? true,
@@ -820,10 +837,10 @@ export async function startProxy(opts = {}) {
     // a TUI attached. -v / --verbose is not required — this is loud by
     // design.
     overageGuard.on('halt', (state) => {
-        console.error(`[dario] OVERAGE-GUARD HALTED: ${state.request.model} on account=${state.request.account} returned representative-claim=overage at ${new Date(state.request.timestamp).toISOString()}. Returning 503 to new requests until \`dario resume\` or cooldown expires (${new Date(state.cooldownUntil).toISOString()}). See dario#288.`);
+        console.error(`[dario] OVERAGE-GUARD HALTED: ${state.request.model} on account=${state.request.account} returned representative-claim=${state.request.claim} at ${new Date(state.request.timestamp).toISOString()}. Returning 503 to new requests until \`dario resume\` or cooldown expires (${new Date(state.cooldownUntil).toISOString()}). See dario#288.`);
     });
     overageGuard.on('warn', (state) => {
-        console.error(`[dario] OVERAGE-GUARD WARN: ${state.request.model} on account=${state.request.account} returned representative-claim=overage at ${new Date(state.request.timestamp).toISOString()}. Behavior=warn — proxy continuing to forward; investigate before bill bleeds. See dario#288.`);
+        console.error(`[dario] OVERAGE-GUARD WARN: ${state.request.model} on account=${state.request.account} returned representative-claim=${state.request.claim} at ${new Date(state.request.timestamp).toISOString()}. Behavior=warn — proxy continuing to forward; investigate before bill bleeds. See dario#288.`);
     });
     overageGuard.on('resume', (info) => {
         console.error(`[dario] overage-guard resumed (${info.reason}). Normal request handling restored.`);
@@ -1749,7 +1766,21 @@ export async function startProxy(opts = {}) {
                             oc.effort = bestSupportedEffort(supportedEfforts);
                         }
                     }
-                    finalBody = Buffer.from(JSON.stringify(r));
+                    // dario#528: overwrite the random cch placeholder with the real
+                    // deterministic value for Claude Code versions whose seed we've
+                    // reverse-engineered. cchForBody hashes a projection of THIS final
+                    // body, so it must run after every mutation above. It returns null
+                    // for unknown versions (keep the random placeholder) or bodies with
+                    // no billing token. Only the template-replay path is stamped —
+                    // passthrough / count_tokens forward the client's body (and its own
+                    // cch) verbatim. Reversible kill-switch: DARIO_CCH=random.
+                    let outboundText = JSON.stringify(r);
+                    if (!passthrough && !isCountTokens && process.env.DARIO_CCH !== 'random') {
+                        const realCch = cchForBody(outboundText, cliVersion);
+                        if (realCch)
+                            outboundText = outboundText.replace(/cch=[0-9a-fA-F]{5}/, `cch=${realCch}`);
+                    }
+                    finalBody = Buffer.from(outboundText);
                 }
                 catch { /* not JSON, send as-is */ }
             }

package/dist/tui/tabs/hits.js

@@ -25,7 +25,7 @@
  */
 import { fg, dim, brand, inverse, BOX, pad, truncate } from '../render.js';
 import { renderKvRow } from '../layout.js';
-import { billingBucketFromClaim } from '../../analytics.js';
+import { billingBucketFromClaim, isNonSubscriptionBilling } from '../../analytics.js';
 const MAX_BUFFER = 5000;
 export const HitsTab = {
     id: 'hits',
@@ -143,7 +143,7 @@ export const HitsTab = {
         if (state.halt) {
             const since = formatTimestamp(state.halt.since);
             const cooldown = formatRemaining(state.halt.cooldownUntil - Date.now());
-            const line1 = `  ${fg('red', '⚠ HALTED')}  overage detected at ${since} on ${state.halt.request.model}  (account=${state.halt.request.account})`;
+            const line1 = `  ${fg('red', '⚠ HALTED')}  ${state.halt.request.claim} detected at ${since} on ${state.halt.request.model}  (account=${state.halt.request.account})`;
             const line2 = `  ${dim('→ New /v1/messages requests return 503 until')} ${fg('cyan', 'R')} ${dim('here, or')} ${fg('cyan', 'dario resume')}${dim(' from any shell. Auto-resume in')} ${cooldown}${dim('.')}`;
             lines.push(line1);
             lines.push(line2);
@@ -158,9 +158,12 @@ export const HitsTab = {
             pad('st', colStatus)));
         for (let i = startIdx; i < endIdx; i++) {
             const r = newestFirst[i];
-            const isOverage = r.claim === 'overage';
+            // Flag any non-subscription billing red — the same condition the
+            // overage-guard halts on (overage, api, or a credit/SDK bucket), not
+            // just literal `overage`. See isNonSubscriptionBilling (#288).
+            const isNonSub = isNonSubscriptionBilling(r.claim);
             const marker = i === state.selectedIdx ? fg('cyan', '▎')
-                : isOverage ? fg('red', '!')
+                : isNonSub ? fg('red', '!')
                     : ' ';
             const row = marker + ' ' +
                 pad(formatTime(r.timestamp), colTime) +
@@ -169,12 +172,12 @@ export const HitsTab = {
                 pad(formatTokens(r.outputTokens), colOut) +
                 pad(formatLatency(r.latencyMs), colLat) +
                 pad(formatStatus(r.status), colStatus);
-            // Overage rows render in red even when unselected; selection still
-            // wins via the inverse() wrapper so the user can drill into one.
+            // Non-subscription rows render in red even when unselected; selection
+            // still wins via the inverse() wrapper so the user can drill into one.
             let styled;
             if (i === state.selectedIdx)
                 styled = inverse(truncate(row, w - 2));
-            else if (isOverage)
+            else if (isNonSub)
                 styled = fg('red', truncate(row, w - 2));
             else
                 styled = truncate(row, w - 2);

package/dist/tui/tabs/status.js

@@ -115,7 +115,7 @@ export const StatusTab = {
                 const remainingMs = Math.max(0, s.cooldownUntil - Date.now());
                 const remaining = formatDuration(remainingMs);
                 // Red banner header — this is the loud surface when halted
-                lines.push('  ' + fg('red', '⚠ HALTED') + '  ' + dim(`overage detected ${formatAgo(s.since)} ago`));
+                lines.push('  ' + fg('red', '⚠ HALTED') + '  ' + dim(`${s.request.claim} detected ${formatAgo(s.since)} ago`));
                 lines.push('  ' + renderKvRow('Request', `${s.request.model}  ${dim('account=' + s.request.account)}`, w - 4));
                 lines.push('  ' + renderKvRow('Cause', `representative-claim = ${fg('red', s.request.claim)}`, w - 4));
                 lines.push('  ' + renderKvRow('Auto-resume in', remaining === '0s' ? fg('yellow', 'now (cooldown elapsed)') : remaining, w - 4));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.75",
+  "version": "4.8.77",
   "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": {
@@ -32,6 +32,7 @@
     "compat": "node test/compat.mjs",
     "lint:pkg": "node scripts/check-package-json.mjs",
     "drift:sdk": "node scripts/check-sdk-drift.mjs",
+    "cch:calibrate": "node scripts/cch-calibrate.mjs",
     "fix:pkg": "node -e \"const fs=require('fs');fs.writeFileSync('package.json',JSON.stringify(JSON.parse(fs.readFileSync('package.json','utf-8')),null,2)+'\\n')\""
   },
   "keywords": [