@askalf/dario 4.8.135 → 4.8.137

package/dist/analytics.js

@@ -25,6 +25,16 @@ export function billingBucketFromClaim(claim) {
     switch (claim) {
         case 'five_hour':
         case 'seven_day':
+        // `*_overage_included` — the plan's INCLUDED overage credit, observed live
+        // 2026-07-05 on a Max account at 7d 82% with the `7d_oi` bucket at 99%:
+        // fable answered normally (genuine model echo, stop_reason end_turn),
+        // status=allowed_warning, overage-utilization 0 — $0 out of pocket, so it
+        // is subscription billing, not extra usage. Real paid overage still
+        // arrives as `overage` and still halts the guard. Pre-classification the
+        // guard's halt-on-unknown design 503'd the proxy on every such claim
+        // (30-min cooldown loops) exactly when the weekly window tightens.
+        case 'five_hour_overage_included':
+        case 'seven_day_overage_included':
             return 'subscription';
         case 'five_hour_fallback':
         case 'seven_day_fallback':
@@ -49,6 +59,8 @@ export const SUBSCRIPTION_CLAIMS = new Set([
     'seven_day',
     'five_hour_fallback',
     'seven_day_fallback',
+    'five_hour_overage_included',
+    'seven_day_overage_included',
 ]);
 /**
  * The sentinel `claim` dario assigns when a response carried no rate-limit

package/dist/cc-template.d.ts

@@ -56,12 +56,33 @@ export declare const CC_TOOL_DEFINITIONS: {
     description: string;
     input_schema: Record<string, unknown>;
 }[];
+/** The UNFILTERED bundled union — every tool the bake knows across platforms
+ *  (PLATFORM_ONLY_TOOLS keeps the bundle a superset). The identity-mapping,
+ *  detection, and advertise paths intersect with what the CLIENT declared,
+ *  and the client's declaration already encodes its platform — a Linux CC
+ *  never declares PowerShell. Filtering those paths by the PROXY HOST's
+ *  process.platform (pre-v4.8.136) made a Linux-hosted dario treat a win32
+ *  client's PowerShell/Glob/Grep as non-native: PowerShell fell to the
+ *  unmapped round-robin, and all three were dropped from the advertised
+ *  array (Glob/Grep translated via lowercase aliases but were never sent
+ *  upstream). Host-filtered CC_TOOL_DEFINITIONS stays correct for the paths
+ *  with no client declaration to mirror: the full-template fallback, the
+ *  merge-mode base array, and Fable's no-tools shape. */
+export declare const CC_TOOL_DEFINITIONS_UNION: {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}[];
+export declare const CC_NATIVE_NAMES_UNION: Set<string>;
 /** CC's own tool names, EXACT case ("Read", "Bash", "Agent", …). A CC client's
  *  tools identity-map to themselves and OVERRIDE TOOL_MAP — whose lowercase
  *  cross-client aliases ('read' → {path}/{filePath}) would otherwise mistranslate
  *  a CC tool (Read's file_path → path). Exact case is the discriminator: CC sends
  *  PascalCase, the {path}-style clients send lowercase/snake, so a non-CC `read`
- *  still routes through TOOL_MAP. Tracks the live bundle (refreshed each bake). */
+ *  still routes through TOOL_MAP. Tracks the live bundle (refreshed each bake).
+ *  HOST-filtered — the routing, detection, and advertise paths use the
+ *  _UNION variants below so a client on a different platform than the proxy
+ *  host still identity-maps (v4.8.136). */
 export declare const CC_NATIVE_NAMES: Set<string>;
 /** MCP tools attached to a CC session are namespaced `mcp__<server>__<tool>`.
  *  Real CC advertises them VERBATIM after its built-ins — the schemas are

package/dist/cc-template.js

@@ -66,12 +66,29 @@ export const INTERACTIVE_ONLY_TOOLS = new Set([
 ]);
 /** CC's exact tool definitions for the current platform — filtered from the bundled union. */
 export const CC_TOOL_DEFINITIONS = filterToolsForPlatform(TEMPLATE.tools, process.platform);
+/** The UNFILTERED bundled union — every tool the bake knows across platforms
+ *  (PLATFORM_ONLY_TOOLS keeps the bundle a superset). The identity-mapping,
+ *  detection, and advertise paths intersect with what the CLIENT declared,
+ *  and the client's declaration already encodes its platform — a Linux CC
+ *  never declares PowerShell. Filtering those paths by the PROXY HOST's
+ *  process.platform (pre-v4.8.136) made a Linux-hosted dario treat a win32
+ *  client's PowerShell/Glob/Grep as non-native: PowerShell fell to the
+ *  unmapped round-robin, and all three were dropped from the advertised
+ *  array (Glob/Grep translated via lowercase aliases but were never sent
+ *  upstream). Host-filtered CC_TOOL_DEFINITIONS stays correct for the paths
+ *  with no client declaration to mirror: the full-template fallback, the
+ *  merge-mode base array, and Fable's no-tools shape. */
+export const CC_TOOL_DEFINITIONS_UNION = TEMPLATE.tools;
+export const CC_NATIVE_NAMES_UNION = new Set(TEMPLATE.tools.map((t) => String(t.name)));
 /** CC's own tool names, EXACT case ("Read", "Bash", "Agent", …). A CC client's
  *  tools identity-map to themselves and OVERRIDE TOOL_MAP — whose lowercase
  *  cross-client aliases ('read' → {path}/{filePath}) would otherwise mistranslate
  *  a CC tool (Read's file_path → path). Exact case is the discriminator: CC sends
  *  PascalCase, the {path}-style clients send lowercase/snake, so a non-CC `read`
- *  still routes through TOOL_MAP. Tracks the live bundle (refreshed each bake). */
+ *  still routes through TOOL_MAP. Tracks the live bundle (refreshed each bake).
+ *  HOST-filtered — the routing, detection, and advertise paths use the
+ *  _UNION variants below so a client on a different platform than the proxy
+ *  host still identity-maps (v4.8.136). */
 export const CC_NATIVE_NAMES = new Set(CC_TOOL_DEFINITIONS.map((t) => String(t.name)));
 /** MCP tools attached to a CC session are namespaced `mcp__<server>__<tool>`.
  *  Real CC advertises them VERBATIM after its built-ins — the schemas are
@@ -551,7 +568,9 @@ export function detectNonCCByTools(clientTools) {
         // routing agree. An ALL-mcp surface now scores ratio 0 and stays in default
         // mode — safe, because the advertise path sends an mcp-only declaration
         // verbatim rather than falling back to the full CC template.
-        if (!TOOL_MAP[rawName.toLowerCase()] && !CC_NATIVE_NAMES.has(rawName) && !isMcpToolName(rawName))
+        // Union set, not the host-filtered one: a win32 client's PowerShell is
+        // native regardless of the platform dario itself runs on (v4.8.136).
+        if (!TOOL_MAP[rawName.toLowerCase()] && !CC_NATIVE_NAMES_UNION.has(rawName) && !isMcpToolName(rawName))
             unmapped++;
     }
     const ratio = unmapped / clientTools.length;
@@ -1360,7 +1379,10 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
             // Exact case is the discriminator (CC sends PascalCase; {path}-style clients
             // send lowercase/snake) so a genuine non-CC `read` still routes via TOOL_MAP.
             // Tracks the live bundle, so future CC tools are covered after the next bake.
-            const mapping = CC_NATIVE_NAMES.has(tool.name) || isMcpToolName(tool.name)
+            // UNION set: identity must hold for a win32 client's PowerShell/Glob/Grep
+            // even when dario itself runs on Linux (v4.8.136) — the exact-case check
+            // still keeps a non-CC lowercase `glob`/`grep` on its TOOL_MAP alias.
+            const mapping = CC_NATIVE_NAMES_UNION.has(tool.name) || isMcpToolName(tool.name)
                 ? { ccTool: tool.name, translateArgs: (a) => a, translateBack: (a) => a }
                 : TOOL_MAP[name];
             if (mapping) {
@@ -1398,8 +1420,8 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
         const CC_FALLBACK_TOOLS = ['Bash', 'Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
         for (const tool of clientTools) {
             const name = (tool.name || '').toLowerCase();
-            if (CC_NATIVE_NAMES.has(tool.name) || isMcpToolName(tool.name) || TOOL_MAP[name])
-                continue; // CC-native / MCP (identity in pass 1) or mapped
+            if (CC_NATIVE_NAMES_UNION.has(tool.name) || isMcpToolName(tool.name) || TOOL_MAP[name])
+                continue; // CC-native (union) / MCP (identity in pass 1) or mapped
             unmappedTools.push(tool.name);
             if (opts.hybridTools)
                 continue; // dropped — see comment above
@@ -1592,7 +1614,11 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
             const clientToolNames = new Set(clientTools
                 .map((t) => t.name?.toLowerCase())
                 .filter((n) => Boolean(n)));
-            const availableCC = CC_TOOL_DEFINITIONS.filter((t) => clientToolNames.has(t.name.toLowerCase()));
+            // Intersect against the UNION, not the host-filtered set: the client's
+            // declaration encodes the client's platform, so a win32 CC declaring
+            // PowerShell/Glob/Grep gets their canonical defs even from a Linux-hosted
+            // dario. The host filter only governs the no-declaration fallbacks.
+            const availableCC = CC_TOOL_DEFINITIONS_UNION.filter((t) => clientToolNames.has(t.name.toLowerCase()));
             const mcpTools = clientTools.filter((t) => isMcpToolName(t.name));
             ccRequest.tools = availableCC.length > 0 || mcpTools.length > 0
                 ? [...availableCC, ...mcpTools]

package/dist/notify.d.ts

@@ -22,6 +22,22 @@
  *
  * See dario#288 — overage-guard.
  */
+/**
+ * Spawn a detached, output-ignored child and swallow EVERY failure mode.
+ *
+ * The subtle one: a missing binary does NOT throw from `spawn()` — it
+ * surfaces as an ASYNC `'error'` event on the ChildProcess, and with no
+ * handler attached that's an uncaught exception that kills the whole
+ * process. Seen live 2026-07-05 (#672): `spawn notify-send` ENOENT inside
+ * the Docker image crashed the proxy on every overage-guard event — the
+ * guard fired, notify killed the process, docker restarted it, ~15s of
+ * refused connections per event. The existing try/catch only covered the
+ * sync-throw path (EMFILE etc.), which is also kept here.
+ *
+ * Exported for test/notify.mjs, which spawns a guaranteed-nonexistent
+ * binary and asserts the process survives the async error event.
+ */
+export declare function spawnFireAndForget(cmd: string, args: string[]): void;
 /**
  * Fire a native notification. Returns immediately — the underlying spawn
  * is fire-and-forget. Errors (missing binary, permission denied, no

package/dist/notify.js

@@ -24,6 +24,32 @@
  */
 import { spawn } from 'node:child_process';
 import { platform } from 'node:os';
+/**
+ * Spawn a detached, output-ignored child and swallow EVERY failure mode.
+ *
+ * The subtle one: a missing binary does NOT throw from `spawn()` — it
+ * surfaces as an ASYNC `'error'` event on the ChildProcess, and with no
+ * handler attached that's an uncaught exception that kills the whole
+ * process. Seen live 2026-07-05 (#672): `spawn notify-send` ENOENT inside
+ * the Docker image crashed the proxy on every overage-guard event — the
+ * guard fired, notify killed the process, docker restarted it, ~15s of
+ * refused connections per event. The existing try/catch only covered the
+ * sync-throw path (EMFILE etc.), which is also kept here.
+ *
+ * Exported for test/notify.mjs, which spawns a guaranteed-nonexistent
+ * binary and asserts the process survives the async error event.
+ */
+export function spawnFireAndForget(cmd, args) {
+    try {
+        const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        // Sync throw path (EMFILE and friends); silent — same contract as
+        // the notification itself: best-effort, never load-bearing.
+    }
+}
 /**
  * Fire a native notification. Returns immediately — the underlying spawn
  * is fire-and-forget. Errors (missing binary, permission denied, no
@@ -47,46 +73,38 @@ export function notify(title, message) {
     const safeTitle = sanitize(title);
     const safeMessage = sanitize(message);
     const plat = platform();
-    try {
-        if (plat === 'darwin') {
-            // AppleScript single-quote inside the script body would need
-            // escaping; sanitize() strips them so the literal substitution
-            // below stays safe. Spawned via array argv to avoid a shell
-            // entirely.
-            spawn('osascript', [
-                '-e',
-                `display notification "${safeMessage}" with title "${safeTitle}"`,
-            ], { detached: true, stdio: 'ignore' }).unref();
-        }
-        else if (plat === 'linux') {
-            spawn('notify-send', [safeTitle, safeMessage], {
-                detached: true,
-                stdio: 'ignore',
-            }).unref();
-        }
-        else if (plat === 'win32') {
-            // BurntToast is the cleanest path — single-line PowerShell, real
-            // Windows toast notification. If BurntToast isn't installed the
-            // command fails silently (stdio: ignore swallows the error
-            // output), which is the desired behavior.
-            //
-            // We don't probe-then-spawn; the cost of one failed BurntToast
-            // attempt is the same as one probe attempt, and probing makes the
-            // hot path slower for the success case.
-            const ps = `try { Import-Module BurntToast -ErrorAction Stop; New-BurntToastNotification -Text '${safeTitle}', '${safeMessage}' } catch { exit 1 }`;
-            spawn('powershell.exe', [
-                '-NoProfile',
-                '-NonInteractive',
-                '-Command',
-                ps,
-            ], { detached: true, stdio: 'ignore' }).unref();
-        }
-        // freebsd / openbsd / aix / sunos / android — BEL only. There's no
-        // single "right" native notification on these platforms.
+    if (plat === 'darwin') {
+        // AppleScript single-quote inside the script body would need
+        // escaping; sanitize() strips them so the literal substitution
+        // below stays safe. Spawned via array argv to avoid a shell
+        // entirely.
+        spawnFireAndForget('osascript', [
+            '-e',
+            `display notification "${safeMessage}" with title "${safeTitle}"`,
+        ]);
     }
-    catch {
-        // spawn() itself can throw on EMFILE or similar; silent.
+    else if (plat === 'linux') {
+        spawnFireAndForget('notify-send', [safeTitle, safeMessage]);
+    }
+    else if (plat === 'win32') {
+        // BurntToast is the cleanest path — single-line PowerShell, real
+        // Windows toast notification. If BurntToast isn't installed the
+        // command fails silently (stdio: ignore swallows the error
+        // output), which is the desired behavior.
+        //
+        // We don't probe-then-spawn; the cost of one failed BurntToast
+        // attempt is the same as one probe attempt, and probing makes the
+        // hot path slower for the success case.
+        const ps = `try { Import-Module BurntToast -ErrorAction Stop; New-BurntToastNotification -Text '${safeTitle}', '${safeMessage}' } catch { exit 1 }`;
+        spawnFireAndForget('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            ps,
+        ]);
     }
+    // freebsd / openbsd / aix / sunos / android — BEL only. There's no
+    // single "right" native notification on these platforms.
 }
 /**
  * Strip characters that would break the embedded shell/AppleScript

package/dist/proxy.js

@@ -13,7 +13,7 @@ import { buildCCRequest, applyCcPromptCaching, parseEffortSuffix, reverseMapResp
 import { stampCch, hasCchSeed } from './cch.js';
 import { describeTemplate, detectDrift, checkCCCompat } from './live-fingerprint.js';
 import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs, reconcilePoolAccounts } from './pool.js';
-import { Analytics, billingBucketFromClaim } from './analytics.js';
+import { Analytics, billingBucketFromClaim, SUBSCRIPTION_CLAIMS } from './analytics.js';
 import { OverageGuard, buildHaltErrorBody } from './overage-guard.js';
 import { notify as osNotify } from './notify.js';
 import { loadAllAccounts, loadAccount, refreshAccountToken, resyncLoginFromCredentialsIfStale, ensureLoginCredentialsInPool } from './accounts.js';
@@ -2897,10 +2897,10 @@ export async function startProxy(opts = {}) {
                     if (overageUtil !== null) {
                         overagePct = `${Math.round(parseFloat(overageUtil) * 100)}%`;
                     }
-                    else if (billingClaim === 'five_hour'
-                        || billingClaim === 'five_hour_fallback'
-                        || billingClaim === 'seven_day'
-                        || billingClaim === 'seven_day_fallback') {
+                    else if (billingClaim && SUBSCRIPTION_CLAIMS.has(billingClaim)) {
+                        // Any subscription-side claim (incl. *_overage_included) with no
+                        // overage-utilization header means $0 extra usage — same sync
+                        // source as the guard so this list can't drift again.
                         overagePct = '0%';
                     }
                     else {

package/package.json

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