@askalf/dario 6.11.0 → 6.11.1

package/README.md

@@ -64,7 +64,7 @@ Prefer Docker? `ghcr.io/askalf/dario:latest` — multi-arch (`amd64` + `arm64`),
 - **Every tool, one URL.** No per-tool keys and no second bill: anything with a base-URL setting runs on the plan you already pay for. [Per-tool setup](docs/tools.md)
 - **Either plan, either wire shape.** Your ChatGPT plan behind Claude Code and the Anthropic SDKs; Codex CLI on your Claude plan. [Two plans](docs/two-plans.md)
 - **Failover that finishes the answer.** A 429 on one plan is re-served by the other, and a stream that dies mid-answer is completed on the same model first. [Failover](docs/two-plans.md#failover-between-subscriptions)
-- **Many seats, one endpoint.** Per-model headroom routing, session-sticky prompt cache, in-flight 429 failover across every seat you hold. [The pool](docs/pool-keys-and-analytics.md)
+- **Many seats, one endpoint.** Per-model headroom routing, session-sticky prompt cache, in-flight 429 failover across every seat you hold. New conversations go to the seat with the most headroom by default; `--pool-strategy=fill-first` fills seats in alias order and `expiring-first` spends the seat whose weekly window resets soonest. The active strategy shows in the startup banner, `GET /status`, `dario doctor` and `dario accounts list`. [The pool](docs/pool-keys-and-analytics.md)
 - **One key per developer.** Named keys with a preferred seat, a model allowlist and a daily budget. [Keys](docs/pool-keys-and-analytics.md#one-key-per-developer)
 - **Knows what it saved you.** A ledger prices every request at API rates; see it in the TUI, `/analytics`, Prometheus `/metrics` and a per-request timing split. [Analytics](docs/pool-keys-and-analytics.md#what-it-would-have-cost)
 - **Tracks Claude Code on its own.** Eleven unattended watchers catch wire-shape drift and ship the fix, usually the same day. [Drift](docs/tracking-claude-code.md)

package/dist/cli.js

@@ -52,7 +52,7 @@ function readBudgetFlags(args) {
     return budget;
 }
 import { loadAllAccounts as loadAllAccountsForIdentity, regenerateClientIdentity } from './accounts.js';
-import { maskEmail, parsePoolHeadroomFloor } from './pool.js';
+import { maskEmail, parsePoolHeadroomFloor, configuredPoolRouting, describePoolStrategy } from './pool.js';
 import { realpathSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -1344,6 +1344,11 @@ async function accounts() {
         const loaded = await loadAllAccounts();
         const now = Date.now();
         console.log(`  Pool of ${aliases.length} (${aliases.length === 1 ? '1 account' : aliases.length + ' accounts'})`);
+        {
+            const { loadConfig } = await import('./config-file.js');
+            const routing = configuredPoolRouting(loadConfig().config.pool);
+            console.log(`  Routing: ${describePoolStrategy(routing.strategy, routing.headroomFloor)}`);
+        }
         if (aliases.length === 1) {
             console.log('  (A pool of one — add another with `dario accounts add <alias>` to load-balance.)');
         }

package/dist/doctor-core.js

@@ -1132,8 +1132,13 @@ export async function runChecks(opts = {}) {
             // (v5.0): it confirms the sole account is eligible, not rejected.
             if (aliases.length >= 1) {
                 try {
-                    const { AccountPool } = await import('./pool.js');
-                    const pool = new AccountPool();
+                    const { AccountPool, configuredPoolRouting, describePoolStrategy } = await import('./pool.js');
+                    const { loadConfig } = await import('./config-file.js');
+                    // The preview must use the strategy the proxy will run, not the
+                    // default: `new AccountPool()` here always predicted a max-headroom
+                    // pick, which is the wrong seat on a fill-first pool.
+                    const routing = configuredPoolRouting(loadConfig().config.pool);
+                    const pool = new AccountPool(routing.strategy, routing.headroomFloor);
                     for (const acc of loaded) {
                         pool.add(acc.alias, {
                             accessToken: acc.accessToken,
@@ -1148,9 +1153,10 @@ export async function runChecks(opts = {}) {
                     checks.push({
                         status: 'info',
                         label: 'Pool routing',
-                        detail: next
-                            ? `next: ${next.alias}  (max-headroom select; ${ps.healthy}/${ps.accounts} healthy)`
-                            : `no eligible account — all rejected or near-expiry (${ps.exhausted}/${ps.accounts} exhausted)`,
+                        detail: (next
+                            ? `next: ${next.alias}  (${ps.healthy}/${ps.accounts} healthy)`
+                            : `no eligible account — all rejected or near-expiry (${ps.exhausted}/${ps.accounts} exhausted)`)
+                            + ` · ${describePoolStrategy(routing.strategy, routing.headroomFloor)} (env/config; a running proxy's --pool-strategy flag shows in GET /status)`,
                     });
                 }
                 catch (err) {

package/dist/pool.d.ts

@@ -369,6 +369,10 @@ export declare function isProbeable(account: PoolAccount, now?: number, family?:
  */
 export declare function accountAction(account: PoolAccount, now?: number): 'none' | 'wait' | 'regrant';
 export interface PoolStatus {
+    /** The routing strategy in force for new conversations. */
+    strategy: PoolStrategy;
+    /** Headroom at/below which a seat counts as drained (ratio). */
+    headroomFloor: number;
     accounts: number;
     healthy: number;
     exhausted: number;
@@ -413,6 +417,27 @@ export type PoolStrategy = 'headroom' | 'fill-first' | 'expiring-first';
  * in this codebase (see resolveSessionRotationConfig).
  */
 export declare function resolvePoolStrategy(explicit?: string | null, env?: NodeJS.ProcessEnv): PoolStrategy;
+/**
+ * One line saying where new conversations go, for every surface that names the
+ * strategy (startup banner, `dario doctor`, `dario accounts list`). The running
+ * strategy used to be invisible: the banner printed it only when it was NOT the
+ * default, and nothing else reported it, so a deployment whose compose file
+ * overrode the default ran that way unnoticed (fleet box, 2026-09-22).
+ */
+export declare function describePoolStrategy(strategy: PoolStrategy, floor?: number): string;
+/**
+ * The strategy and floor a proxy started with no flags would run with, for
+ * commands that do not run the proxy (`doctor`, `accounts list`): env first,
+ * then the config file, then the defaults — the proxy's own order minus the
+ * CLI flag, which only the running process knows (GET /status reports it).
+ */
+export declare function configuredPoolRouting(file: {
+    strategy?: string;
+    headroomFloor?: number;
+} | undefined, env?: NodeJS.ProcessEnv): {
+    strategy: PoolStrategy;
+    headroomFloor: number;
+};
 /**
  * Which wire buckets bind which model family, when the wire does not say it
  * by name. `7d_sonnet` names its family; `7d_oi` does not — it is the plan's
@@ -576,7 +601,7 @@ export declare function resolvePoolHeadroomFloor(explicit?: string | number | nu
  */
 export declare function seatExpiry(account: PoolAccount, now?: number): number;
 export declare class AccountPool {
-    private readonly strategy;
+    readonly strategy: PoolStrategy;
     /** Headroom at/below which a seat counts as drained — see DEFAULT_POOL_HEADROOM_FLOOR. */
     readonly headroomFloor: number;
     private accounts;

package/dist/pool.js

@@ -428,6 +428,36 @@ export function resolvePoolStrategy(explicit, env = process.env) {
     }
     return 'headroom';
 }
+/**
+ * One line saying where new conversations go, for every surface that names the
+ * strategy (startup banner, `dario doctor`, `dario accounts list`). The running
+ * strategy used to be invisible: the banner printed it only when it was NOT the
+ * default, and nothing else reported it, so a deployment whose compose file
+ * overrode the default ran that way unnoticed (fleet box, 2026-09-22).
+ */
+export function describePoolStrategy(strategy, floor = DEFAULT_POOL_HEADROOM_FLOOR) {
+    const pct = `${Math.round(floor * 100)}% floor`;
+    switch (strategy) {
+        case 'fill-first':
+            return `fill-first — new conversations fill the alphabetically-first seat until the ${pct}, then spill`;
+        case 'expiring-first':
+            return `expiring-first — new conversations fill the seat whose 7-day window resets soonest until the ${pct}, then spill`;
+        default:
+            return `headroom (default) — new conversations go to the seat with the most headroom; ${pct}`;
+    }
+}
+/**
+ * The strategy and floor a proxy started with no flags would run with, for
+ * commands that do not run the proxy (`doctor`, `accounts list`): env first,
+ * then the config file, then the defaults — the proxy's own order minus the
+ * CLI flag, which only the running process knows (GET /status reports it).
+ */
+export function configuredPoolRouting(file, env = process.env) {
+    return {
+        strategy: resolvePoolStrategy(env.DARIO_POOL_STRATEGY ?? file?.strategy, env),
+        headroomFloor: resolvePoolHeadroomFloor(env.DARIO_POOL_HEADROOM_FLOOR ?? file?.headroomFloor, env),
+    };
+}
 /**
  * Match `anthropic-ratelimit-unified-7d_<family>-utilization`. Generic on
  * `<family>` so a future `7d_opus` / `7d_haiku` (or anything Anthropic
@@ -1264,6 +1294,8 @@ export class AccountPool {
         const avgHeadroom = headrooms.length > 0 ? headrooms.reduce((a, b) => a + b, 0) / headrooms.length : 0;
         const best = this.select();
         return {
+            strategy: this.strategy,
+            headroomFloor: this.headroomFloor,
             accounts: all.length,
             healthy: healthy.length,
             exhausted: all.length - healthy.length,

package/dist/proxy.js

@@ -13,7 +13,7 @@ import { CC_TOOL_DEFINITIONS_UNADVERTISABLE, CC_TEMPLATE_PROMPT_BYTES, resolveMa
 import { stampCch, hasCchSeed } from './cch.js';
 import { foldTiming, timingHeaders, timingLogFields } from './timing.js';
 import { describeTemplate, detectDrift, checkCCCompat, probeInstalledCCVersion } from './live-fingerprint.js';
-import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs, accountIneligibility, reportedAccountStatus, activeParkedBuckets, reconcilePoolAccounts, resolvePoolStrategy, resolvePoolHeadroomFloor, DEFAULT_POOL_HEADROOM_FLOOR, utilFreshness, rateLimitWindow, accountAction, accountPeers, distinctAccounts, describeRejection, maskEmail, isAccountEligible } from './pool.js';
+import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs, accountIneligibility, reportedAccountStatus, activeParkedBuckets, reconcilePoolAccounts, resolvePoolStrategy, resolvePoolHeadroomFloor, describePoolStrategy, DEFAULT_POOL_HEADROOM_FLOOR, utilFreshness, rateLimitWindow, accountAction, accountPeers, distinctAccounts, describeRejection, maskEmail, isAccountEligible } from './pool.js';
 import { backfillIdentity } from './accounts.js';
 import { PoolSync, DEFAULT_POOL_SYNC_INTERVAL_MS } from './pool-sync.js';
 import { Analytics, billingBucketFromClaim, costOfTokens, formatUsageLogLine, SUBSCRIPTION_CLAIMS, consumerFromHeader, consumerFromBody, CONSUMER_HEADER, CODEX_CLAIM } from './analytics.js';
@@ -1521,10 +1521,9 @@ export async function startProxy(opts = {}) {
     if (opts.poolSharedState && !poolSync) {
         console.error('[dario] --pool-shared-state needs DARIO_REFRESH_LOCK_URL (the lock service carries the shared state) — running with this instance\'s own state');
     }
-    if (poolStrategy !== 'headroom') {
-        const order = poolStrategy === 'expiring-first' ? 'the seat whose 7-day window resets soonest' : 'the alphabetically-first seat';
-        console.log(`  Pool strategy: ${poolStrategy} (new conversations fill ${order}, spill at the ${Math.round(pool.headroomFloor * 100)}% floor)`);
-    }
+    // Always named, the default included: a deployment that overrides the
+    // default should be visible at a glance, and one that does not should say so.
+    console.log(`  Pool strategy: ${describePoolStrategy(poolStrategy, pool.headroomFloor)}`);
     if (poolSync) {
         console.log(`  Pool shared state: on (instance ${poolSync.instance}, via ${lockUrl}, pulling peers every ${poolSync.intervalMs}ms; fails open)`);
         poolSync.start();
@@ -2680,7 +2679,14 @@ export async function startProxy(opts = {}) {
             // Version for auto-update checks (#640) — /status is key-gated (loopback
             // or DARIO_API_KEY), so no public-disclosure concern like /health has.
             res.writeHead(200, JSON_HEADERS);
-            res.end(JSON.stringify({ version: darioVersion(), ...s }));
+            res.end(JSON.stringify({
+                version: darioVersion(),
+                ...s,
+                // The routing the running process uses — the only surface that can
+                // report a --pool-strategy flag (doctor and `accounts list` read env
+                // and config). null with no pool.
+                pool: pool.size > 0 ? { strategy: pool.strategy, headroomFloor: pool.headroomFloor, accounts: pool.size } : null,
+            }));
             return;
         }
         // Pool status endpoint — shows loaded accounts, headroom, and the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.11.0",
+  "version": "6.11.1",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {