@askalf/dario 5.2.7 → 5.2.8

package/dist/doctor.js

@@ -805,6 +805,26 @@ export async function runChecks(opts = {}) {
     catch (err) {
         checks.push({ status: 'warn', label: 'Pool', detail: `check failed: ${err.message}` });
     }
+    // ---- Live session state (only observable from a running proxy)
+    // Session/sticky counts live in the proxy's memory, so — unlike the
+    // local-state checks above — this reads them off /health (internal-disclosure
+    // caller, so it must reach dario on loopback). Silent skip when no proxy is
+    // up: the counts don't exist, and doctor is often run because it's down.
+    try {
+        const darioBase = process.env.DARIO_TEST_URL || 'http://127.0.0.1:3456';
+        const healthRes = await fetch(`${darioBase}/health`, { signal: AbortSignal.timeout(800) });
+        if (healthRes.ok) {
+            const health = (await healthRes.json().catch(() => null));
+            const sx = health?.sessions;
+            if (sx && typeof sx.mode === 'string') {
+                const detail = sx.mode === 'pool'
+                    ? `${sx.stickyBindings ?? 0} sticky binding${sx.stickyBindings === 1 ? '' : 's'} — conversation→account affinity, lazily reaped (6h idle TTL, cap 2000)`
+                    : `${sx.active ?? 0} active session id${sx.active === 1 ? '' : 's'} — lazily reaped (LRU cap 1024, no background sweeper)`;
+                checks.push({ status: 'info', label: 'Sessions', detail });
+            }
+        }
+    }
+    catch { /* proxy not running — live session state unavailable, skip */ }
     // ---- Identity drift (pool account snapshot vs live ~/.claude.json)
     try {
         const { detectClaudeIdentity, listAccountAliases, loadAllAccounts } = await import('./accounts.js');

package/dist/health-response.d.ts

@@ -22,6 +22,18 @@ export interface HealthStatusLike {
     lastRefreshError?: string;
     /** dario's package version, surfaced to internal callers on /health (#640). */
     version?: string;
+    /**
+     * Live session-tracking counts, surfaced to internal callers only. Both
+     * structures reap lazily (no background sweeper — see session-rotation.ts),
+     * so this raw in-memory size also reveals whether lazy cleanup keeps up.
+     */
+    sessions?: {
+        mode: 'pool';
+        stickyBindings: number;
+    } | {
+        mode: 'single';
+        active: number;
+    };
 }
 export interface HealthResponse {
     httpStatus: number;

package/dist/health-response.js

@@ -81,6 +81,7 @@ export function buildHealthResponse(s, requestCount, includeInternal) {
             oauth: s.status,
             expiresIn: s.expiresIn,
             requests: requestCount,
+            ...(s.sessions ? { sessions: s.sessions } : {}),
             ...(s.refreshFailures ? { refreshFailures: s.refreshFailures } : {}),
         }
         : liveness;

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

package/dist/live-fingerprint.js

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

package/dist/pool.d.ts

@@ -192,7 +192,7 @@ export declare class AccountPool {
      *
      * Also performs lazy cleanup of expired bindings (TTL or size cap).
      */
-    selectSticky(stickyKey: string | null, family?: string | null): PoolAccount | null;
+    selectSticky(stickyKey: string | null, family?: string | null, now?: number): PoolAccount | null;
     /**
      * Rebind a sticky key to a different account — called by proxy after an
      * in-request 429 failover moves to the next-best account. Without this

package/dist/pool.js

@@ -157,7 +157,7 @@ export function computeHeadroom(snapshot, family) {
     }
     return 1 - Math.max(...utils);
 }
-const STICKY_TTL_MS = 6 * 60 * 60 * 1000; // 6h
+const STICKY_IDLE_TTL_MS = 6 * 60 * 60 * 1000; // reap a binding 6h after its LAST use, not its creation
 const STICKY_MAX_ENTRIES = 2_000; // lazy cleanup cap
 const STICKY_CLEANUP_INTERVAL_MS = 30_000; // amortize the O(n) TTL/orphan sweep
 /**
@@ -334,25 +334,28 @@ export class AccountPool {
      *
      * Also performs lazy cleanup of expired bindings (TTL or size cap).
      */
-    selectSticky(stickyKey, family) {
+    selectSticky(stickyKey, family, now = Date.now()) {
         if (!stickyKey)
             return this.select(family);
-        this.cleanupSticky();
+        this.cleanupSticky(now);
         const binding = this.sticky.get(stickyKey);
         if (binding) {
             const bound = this.accounts.get(binding.alias);
-            const now = Date.now();
             if (bound
                 && bound.rateLimit.status !== 'rejected'
                 && bound.expiresAt > now + 30_000
                 && !isInAuthCooldown(bound, now)
                 && computeHeadroom(bound.rateLimit, family) > POOL_HEADROOM_FLOOR) {
+                // Refresh the idle timer. A session that keeps taking turns must never
+                // be reaped or rebound while active — that would strand its warm prompt
+                // cache — so the TTL is re-based to now on every hit.
+                binding.lastUsedAt = now;
                 return bound;
             }
         }
         const picked = this.select(family);
         if (picked) {
-            this.sticky.set(stickyKey, { alias: picked.alias, boundAt: Date.now() });
+            this.sticky.set(stickyKey, { alias: picked.alias, boundAt: now, lastUsedAt: now });
         }
         return picked;
     }
@@ -367,7 +370,8 @@ export class AccountPool {
             return;
         if (!this.accounts.has(alias))
             return;
-        this.sticky.set(stickyKey, { alias, boundAt: Date.now() });
+        const now = Date.now();
+        this.sticky.set(stickyKey, { alias, boundAt: now, lastUsedAt: now });
     }
     /**
      * Drop any binding that points at an account no longer in the pool, any
@@ -375,8 +379,7 @@ export class AccountPool {
      * entries until we're back under. O(n) but n is small (capped at 2k)
      * and this only runs on selectSticky, not on every method.
      */
-    cleanupSticky() {
-        const now = Date.now();
+    cleanupSticky(now = Date.now()) {
         // TTL/orphan sweep is O(n); amortize it — run at most once per
         // STICKY_CLEANUP_INTERVAL_MS instead of on every selectSticky (#642-audit).
         // Stale bindings are never wrongly USED meanwhile: selectSticky re-validates
@@ -384,17 +387,22 @@ export class AccountPool {
         if (now - this.lastStickyCleanup >= STICKY_CLEANUP_INTERVAL_MS) {
             this.lastStickyCleanup = now;
             for (const [key, b] of this.sticky) {
-                if (!this.accounts.has(b.alias) || now - b.boundAt > STICKY_TTL_MS) {
+                // Reap orphans (account gone) and bindings idle past the TTL. Idle is
+                // measured from lastUsedAt, which selectSticky refreshes every turn, so
+                // an actively-running conversation is never reaped here.
+                if (!this.accounts.has(b.alias) || now - b.lastUsedAt > STICKY_IDLE_TTL_MS) {
                     this.sticky.delete(key);
                 }
             }
         }
         // Hard size cap always enforced (bounds memory). Batch-evict down to 80% so
         // the O(n log n) sort amortizes over many inserts rather than firing on every
-        // new conversation at the cap (#642-audit).
+        // new conversation at the cap (#642-audit). Evict least-recently-USED first
+        // (true LRU): a binding's only value is its warm prompt cache, and the ones
+        // untouched longest are the coldest — least worth keeping.
         if (this.sticky.size > STICKY_MAX_ENTRIES) {
             const target = Math.floor(STICKY_MAX_ENTRIES * 0.8);
-            const sorted = [...this.sticky.entries()].sort((a, b) => a[1].boundAt - b[1].boundAt);
+            const sorted = [...this.sticky.entries()].sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
             const toDrop = sorted.slice(0, this.sticky.size - target);
             for (const [key] of toDrop)
                 this.sticky.delete(key);

package/dist/proxy.js

@@ -1643,7 +1643,15 @@ export async function startProxy(opts = {}) {
                 loopback: isLoopbackAddr(req.socket?.remoteAddress),
                 viaCfRay: req.headers['cf-ray'] !== undefined,
             });
-            const { httpStatus, body } = buildHealthResponse({ ...s, version: darioVersion() }, requestCount, includeInternal);
+            const { httpStatus, body } = buildHealthResponse({
+                ...s,
+                version: darioVersion(),
+                // pool.size === 0 is single-account mode (session-id registry drives
+                // the SESSION_ID slot); a loaded pool routes via sticky bindings.
+                sessions: pool.size === 0
+                    ? { mode: 'single', active: sessionRegistry.size() }
+                    : { mode: 'pool', stickyBindings: pool.stickyCount() },
+            }, requestCount, includeInternal);
             res.writeHead(httpStatus, JSON_HEADERS);
             res.end(JSON.stringify(body));
             return;

package/package.json

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