@askalf/dario 4.8.130 → 4.8.132

package/dist/cc-template.d.ts

@@ -365,9 +365,10 @@ export declare function parseEffortSuffix(model: string): {
  * — high/xhigh/max → end_turn, zero refusals. So the clamp + the fable-only
  * default are gone: fable now takes the general path (no clamp), matching how
  * dario treats opus. The general default is `high` (see resolveEffort below) —
- * a clean-room 2.1.199 capture shows CC sends `high` on every family; earlier
- * `xhigh` sightings were from configured captures. `model` is retained in the
- * signature in case a future model needs per-family effort handling again.
+ * Claude Code's out-of-box default. Effort is a user-adjustable knob, so no
+ * single value is "the" value; `high` is the safe unconfigured baseline.
+ * `model` is retained in the signature in case a future model needs per-family
+ * effort handling again.
  *
  * Exported for tests.
  */

package/dist/cc-template.js

@@ -1114,24 +1114,22 @@ function normalizeEffortForWire(effort) {
  * — high/xhigh/max → end_turn, zero refusals. So the clamp + the fable-only
  * default are gone: fable now takes the general path (no clamp), matching how
  * dario treats opus. The general default is `high` (see resolveEffort below) —
- * a clean-room 2.1.199 capture shows CC sends `high` on every family; earlier
- * `xhigh` sightings were from configured captures. `model` is retained in the
- * signature in case a future model needs per-family effort handling again.
+ * Claude Code's out-of-box default. Effort is a user-adjustable knob, so no
+ * single value is "the" value; `high` is the safe unconfigured baseline.
+ * `model` is retained in the signature in case a future model needs per-family
+ * effort handling again.
  *
  * Exported for tests.
  */
 export function resolveEffort(flag, clientBody, model) {
     void model; // no per-family effort handling at present (see FABLE CLAMP note above)
-    // Match real CC's wire value. A clean-room capture (fresh HOME, no config) of
-    // CC 2.1.199 sends `effort: high` on every adaptive-thinking model (opus-4-8,
-    // sonnet-5, fable-5, opus-4-6, sonnet-4-6 — verified 2026-07-03). The prior
-    // default `'max'` was the reasoning ceiling and diverged from CC on two
-    // counts: it's not what CC sends, and `max` effort + unbounded adaptive
-    // thinking makes the model reason until it exhausts `max_tokens` — on prompts
-    // over ~5K input tokens the thinking phase consumes the entire budget, so the
-    // stream ends `stop_reason: max_tokens` with ZERO text blocks (dario#658). CC
-    // at `high` thinks proportionally and leaves room for text. Operators who
-    // want a higher tier still pin it via `--effort` / DARIO_EFFORT.
+    // `high` is Claude Code's out-of-box default effort. The prior default `'max'`
+    // was the reasoning ceiling: combined with unbounded adaptive thinking it makes
+    // the model reason until it exhausts `max_tokens` — on prompts over ~5K input
+    // tokens the thinking phase consumes the entire budget, so the stream ends
+    // `stop_reason: max_tokens` with ZERO text blocks (dario#658). `high` thinks
+    // proportionally and leaves room for the answer. Effort is a user-adjustable
+    // knob; operators who want a higher tier pin it via `--effort` / DARIO_EFFORT.
     const familyDefault = 'high';
     if (flag === undefined)
         return familyDefault;

package/dist/cch.d.ts

@@ -3,8 +3,8 @@ export declare const CCH_SEEDS: Record<string, bigint>;
 /**
  * Whether a calibrated cch seed exists for `version`. The proxy gates cch
  * EMISSION on this: with a seed it stamps the deterministic value, without
- * one it omits the token (matching CC 2.1.199+, which sends no cch). Keyed on
- * `major.minor.patch` — same key space as CCH_SEEDS.
+ * one it omits the token (matching current Claude Code, which sends no cch).
+ * Keyed on `major.minor.patch` — same key space as CCH_SEEDS.
  */
 export declare function hasCchSeed(version: string): boolean;
 /** Canonical xxHash64 of `data` with a 64-bit `seed`. */

package/dist/cch.js

@@ -24,14 +24,13 @@
 // version returns null; the caller then OMITS the cch token entirely rather
 // than stamping a random one (see hasCchSeed below).
 //
-// ⚠ Claude Code DROPPED the cch token between 2.1.177 and 2.1.199 (live
-// capture 2026-07-03, sdk-cli entrypoint — the entrypoint dario claims): the
-// billing block is now `cc_version=…; cc_entrypoint=sdk-cli;` with no `cch=`.
-// So "no seed" and "CC emits no cch" currently coincide, and gating cch
-// emission on seed availability keeps dario byte-aligned with real CC: we emit
-// cch only when we can emit the CORRECT deterministic value, and otherwise
-// send nothing — which is exactly what current CC sends. A random cch never
-// validates AND is a field genuine CC no longer carries: a 100%-vs-0% tell.
+// ⚠ Claude Code DROPPED the cch token in a recent release: newer versions send
+// the billing block as `cc_version=…; cc_entrypoint=sdk-cli;` with no `cch=`.
+// So "no seed" and "current Claude Code sends no cch" coincide, and gating cch
+// emission on seed availability keeps dario in step with it: emit cch only when
+// we hold the value to produce it correctly, and otherwise send nothing — which
+// is what current Claude Code sends. A stamped-but-wrong or random cch is worse
+// than none: it's a field current Claude Code no longer includes.
 /** Verified per-release seeds, keyed on `major.minor.patch`. */
 export const CCH_SEEDS = {
     '2.1.177': 0x4d659218e32a3268n,
@@ -39,8 +38,8 @@ export const CCH_SEEDS = {
 /**
  * Whether a calibrated cch seed exists for `version`. The proxy gates cch
  * EMISSION on this: with a seed it stamps the deterministic value, without
- * one it omits the token (matching CC 2.1.199+, which sends no cch). Keyed on
- * `major.minor.patch` — same key space as CCH_SEEDS.
+ * one it omits the token (matching current Claude Code, which sends no cch).
+ * Keyed on `major.minor.patch` — same key space as CCH_SEEDS.
  */
 export function hasCchSeed(version) {
     return CCH_SEEDS[version] !== undefined;

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.199";
+    readonly maxTested: "2.1.201";
 };
 /**
  * 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.199',
+    maxTested: '2.1.201',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/proxy.d.ts

@@ -3,18 +3,18 @@ import { type WriteStream } from 'node:fs';
 import { getAccessToken, getStatus } from './oauth.js';
 import { type EffortValue } from './cc-template.js';
 /**
- * Assemble the `x-anthropic-billing-header` system-block text, tracking real
- * Claude Code's wire shape:
- *   with cch:    `…; cc_entrypoint=sdk-cli; cch=<5hex>;`   (CC ≤ 2.1.177)
- *   without cch: `…; cc_entrypoint=sdk-cli;`               (CC 2.1.199+)
+ * Assemble the `x-anthropic-billing-header` system-block text, following
+ * Claude Code's format:
+ *   with cch:    `…; cc_entrypoint=sdk-cli; cch=<5hex>;`   (older releases)
+ *   without cch: `…; cc_entrypoint=sdk-cli;`               (current releases)
  *
  * `cch` is passed in rather than generated here so this stays a pure, testable
  * string builder: the caller gates on hasCchSeed(cliVersion) and passes
  * computeCch() (a placeholder stampCch later overwrites with the deterministic
  * value) when a seed exists, or null when it doesn't. Passing null omits the
- * token — never emit a cch we can't stand behind, and never emit one current
- * CC doesn't send. The cc_version build suffix is stable per config
- * (computeVersionSuffix), independent of the request. Exported for tests.
+ * token — never emit a cch we can't produce correctly, and never emit one
+ * current Claude Code doesn't send. The cc_version build suffix is stable per
+ * config (computeVersionSuffix), independent of the request. Exported for tests.
  */
 export declare function buildBillingTag(cliVersion: string, cch: string | null): string;
 /**
@@ -59,9 +59,7 @@ export declare const AFK_MODE_BETA = "afk-mode-2026-01-31";
 export declare const ADVISOR_TOOL_BETA = "advisor-tool-2026-03-01";
 export declare const CLAUDE_CODE_BETA = "claude-code-20250219";
 /**
- * Model-conditional anthropic-beta set, mirroring real CC 2.1.199 (live
- * captures 2026-07-03, this box, `--print --model <m> -p hi` — same
- * binary/account, deterministic across repeat trials). `base` is the captured
+ * Model-conditional anthropic-beta set for current Claude Code. `base` is the
  * opus/sonnet order (TEMPLATE.anthropic_beta); each family is a transform of
  * it, ORDER included:
  *
@@ -78,16 +76,16 @@ export declare const CLAUDE_CODE_BETA = "claude-code-20250219";
  * NOT send it for plain models. `skipContext1m` (dario#36) suppresses it when
  * the account's long-context billing was rejected.
  *
- * afk-mode-2026-01-31 is REMOTE-CONFIG controlled and flips within a CC version
- * (memory: rolled off 7/2, back on 7/3), so its presence is a property of the
- * captured `base`, not of this function — the live capture heals it. haiku
- * drops it regardless. The per-family shape here is correct whether or not the
- * base carries afk-mode: the anchor-relative inserts/moves degrade gracefully
+ * afk-mode-2026-01-31 is remote-config controlled and can flip within a Claude
+ * Code version, so its presence is a property of `base` (the loaded template),
+ * not of this function — the template refresh keeps it current. haiku drops it
+ * regardless. The per-family shape here is correct whether or not the base
+ * carries afk-mode: the anchor-relative inserts/moves degrade gracefully
  * (append / no-op) when an anchor is absent.
  *
  * Removing a beta can never provoke an upstream 400 (the runtime rejection
  * cache only ever needs to ADD strips), so the haiku omissions are safe; the
- * position fixes are pure wire-shape fidelity.
+ * position adjustments keep the per-family order correct.
  */
 export declare function betaForModel(base: string, model: string | null | undefined, skipContext1m?: boolean): string;
 /**

package/dist/proxy.js

@@ -52,26 +52,17 @@ function isLoopbackAddr(addr) {
 }
 // Concurrency control: see src/request-queue.ts for the bounded queue
 // (replaced the v3.30.x-and-earlier simple unbounded semaphore in dario#80).
-// Deterministic seed for the cc_version build suffix. Once reverse-engineered
-// as Claude Code's own value; it is now just dario's stable constant — CC's
-// real suffix algorithm has moved (see computeVersionSuffix).
+// Deterministic constant used to seed the cc_version build suffix
+// (computeVersionSuffix). Arbitrary — its only job is to make the suffix stable.
 const BILLING_SEED = '59cf53e54c78';
-// The `.<suffix>` on cc_version (e.g. `2.1.199.ef3`). A clean-room capture
-// (2026-07-03, fresh HOME with no CLAUDE.md / memory / project context) proved
-// this is NOT a function of the user message: every prompt — any content, any
-// length, bytes flipped at positions 0/4/7/20/29 — returned the SAME suffix,
-// and it shifted only when the injected SYSTEM CONTEXT changed. So CC derives
-// it from the system payload and it is STABLE for a given config. dario's old
-// `chars[4,7,20]`-of-user-message hash was doubly wrong: wrong input, and
-// per-request-varying where real CC is stable across requests.
-//
-// We can't reproduce CC's exact algorithm (it lives in the compiled binary,
-// same as the cch seed) and the value isn't population-discriminating — every
-// CC machine's suffix differs by its own context — so a STABLE, plausible 3-hex
-// derived from the template we replay is the faithful choice: it matches CC's
-// observable property (one stable suffix per config, like a single real
-// install) and changes only when the system payload changes (a template
-// rebake). Memoized — the inputs don't change within a process.
+// The `.<suffix>` on cc_version (e.g. `2.1.199.ef3`). This suffix is not a
+// function of the user message — it tracks the request's system context, so it
+// is stable for a given configuration and changes only when that context does.
+// dario's old `chars[4,7,20]`-of-user-message hash was wrong on both counts:
+// wrong input, and per-request-varying. We emit instead a STABLE, plausible
+// 3-hex derived from the loaded template — one stable value per config, which
+// changes only when the template does (a rebake). Memoized — the inputs don't
+// change within a process.
 let _versionSuffixCache = null;
 function computeVersionSuffix(version) {
     if (_versionSuffixCache && _versionSuffixCache.key === version)
@@ -88,27 +79,27 @@ function computeVersionSuffix(version) {
 // deterministic value at serialize time (the `stampCch` call near the
 // JSON.stringify of the outbound body).
 //
-// This placeholder is only emitted for CC versions we hold a calibrated seed
-// for — see buildBillingTag / hasCchSeed. Versions without a seed omit the cch
-// token entirely: current CC (2.1.199+) sends no cch at all, so a random
-// value would be a fingerprint, not cover. Operators can force the random
-// path on every seeded request with DARIO_CCH=random.
+// This placeholder is only emitted for versions we hold a calibrated seed for
+// — see buildBillingTag / hasCchSeed. Versions without a seed omit the cch
+// token entirely: current Claude Code sends no cch, so omitting is the correct
+// match. Operators can force the random path on every seeded request with
+// DARIO_CCH=random.
 function computeCch() {
     return randomBytes(3).toString('hex').slice(0, 5);
 }
 /**
- * Assemble the `x-anthropic-billing-header` system-block text, tracking real
- * Claude Code's wire shape:
- *   with cch:    `…; cc_entrypoint=sdk-cli; cch=<5hex>;`   (CC ≤ 2.1.177)
- *   without cch: `…; cc_entrypoint=sdk-cli;`               (CC 2.1.199+)
+ * Assemble the `x-anthropic-billing-header` system-block text, following
+ * Claude Code's format:
+ *   with cch:    `…; cc_entrypoint=sdk-cli; cch=<5hex>;`   (older releases)
+ *   without cch: `…; cc_entrypoint=sdk-cli;`               (current releases)
  *
  * `cch` is passed in rather than generated here so this stays a pure, testable
  * string builder: the caller gates on hasCchSeed(cliVersion) and passes
  * computeCch() (a placeholder stampCch later overwrites with the deterministic
  * value) when a seed exists, or null when it doesn't. Passing null omits the
- * token — never emit a cch we can't stand behind, and never emit one current
- * CC doesn't send. The cc_version build suffix is stable per config
- * (computeVersionSuffix), independent of the request. Exported for tests.
+ * token — never emit a cch we can't produce correctly, and never emit one
+ * current Claude Code doesn't send. The cc_version build suffix is stable per
+ * config (computeVersionSuffix), independent of the request. Exported for tests.
  */
 export function buildBillingTag(cliVersion, cch) {
     const fullVersion = `${cliVersion}.${computeVersionSuffix(cliVersion)}`;
@@ -327,9 +318,7 @@ function moveBetaBefore(flags, flag, anchor) {
     return i < 0 ? flags : [...without.slice(0, i), flag, ...without.slice(i)];
 }
 /**
- * Model-conditional anthropic-beta set, mirroring real CC 2.1.199 (live
- * captures 2026-07-03, this box, `--print --model <m> -p hi` — same
- * binary/account, deterministic across repeat trials). `base` is the captured
+ * Model-conditional anthropic-beta set for current Claude Code. `base` is the
  * opus/sonnet order (TEMPLATE.anthropic_beta); each family is a transform of
  * it, ORDER included:
  *
@@ -346,16 +335,16 @@ function moveBetaBefore(flags, flag, anchor) {
  * NOT send it for plain models. `skipContext1m` (dario#36) suppresses it when
  * the account's long-context billing was rejected.
  *
- * afk-mode-2026-01-31 is REMOTE-CONFIG controlled and flips within a CC version
- * (memory: rolled off 7/2, back on 7/3), so its presence is a property of the
- * captured `base`, not of this function — the live capture heals it. haiku
- * drops it regardless. The per-family shape here is correct whether or not the
- * base carries afk-mode: the anchor-relative inserts/moves degrade gracefully
+ * afk-mode-2026-01-31 is remote-config controlled and can flip within a Claude
+ * Code version, so its presence is a property of `base` (the loaded template),
+ * not of this function — the template refresh keeps it current. haiku drops it
+ * regardless. The per-family shape here is correct whether or not the base
+ * carries afk-mode: the anchor-relative inserts/moves degrade gracefully
  * (append / no-op) when an anchor is absent.
  *
  * Removing a beta can never provoke an upstream 400 (the runtime rejection
  * cache only ever needs to ADD strips), so the haiku omissions are safe; the
- * position fixes are pure wire-shape fidelity.
+ * position adjustments keep the per-family order correct.
  */
 export function betaForModel(base, model, skipContext1m = false) {
     const m = (model ?? '').toLowerCase();
@@ -2048,11 +2037,10 @@ export async function startProxy(opts = {}) {
                         // from CC's exact template and inject only the conversation content.
                         // The upstream sees a genuine CC request structure.
                         const userMsg = extractFirstUserMessage(r);
-                        // Emit a cch token only for CC versions we hold a calibrated seed
-                        // for (stampCch overwrites this placeholder with the deterministic
-                        // value at serialize time). Uncalibrated versions omit cch: current
-                        // CC (2.1.199+) sends none, so a random placeholder would be a
-                        // fingerprint rather than cover. dario#528 + 2026-07-03 drift.
+                        // Emit a cch token only for versions we hold a calibrated seed for
+                        // (stampCch overwrites this placeholder with the deterministic value
+                        // at serialize time). Uncalibrated versions omit cch, matching
+                        // current Claude Code, which sends none. dario#528.
                         const cch = hasCchSeed(cliVersion) ? computeCch() : null;
                         const billingTag = buildBillingTag(cliVersion, cch);
                         const CACHE_EPHEMERAL = { type: 'ephemeral' };
@@ -2215,8 +2203,8 @@ export async function startProxy(opts = {}) {
                     // anchored to the billing tag — never a cch quoted in conversation
                     // content. No-op for uncalibrated versions — but those also carry no
                     // cch token to begin with (buildBillingTag omits it without a seed,
-                    // matching CC 2.1.199+), so there is nothing to stamp and nothing
-                    // stale is shipped. Only the template-replay path is stamped —
+                    // matching current Claude Code), so there is nothing to stamp and
+                    // nothing stale is shipped. 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.130",
+  "version": "4.8.132",
   "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": {