@askalf/dario 6.6.3 → 6.6.4

package/dist/doctor-core.d.ts

@@ -52,6 +52,33 @@ export declare function continuationReadiness(input: {
     status: CheckStatus;
     detail: string;
 };
+/**
+ * Ledger readiness (v6.6.4). The ledger is a file the proxy writes a few
+ * seconds after each request; the number it feeds (`dario usage`, the TUI's
+ * API-equivalent row) only ever moves if that write lands. A bind mount that
+ * came up read-only, a home directory the proxy cannot create, a file a
+ * root-owned rig left behind — each of these looks exactly like "no traffic"
+ * from the outside. This row says whether the file can be written, when it
+ * last was, and what it holds. File and configuration only: the proxy's own
+ * unflushed records are not visible here.
+ */
+export declare function ledgerReadiness(input: {
+    enabled: boolean;
+    path: string;
+    exists: boolean;
+    writable: boolean;
+    /** Why the file could not be parsed, when it exists and could not be. */
+    parseError?: string;
+    /** Epoch ms of the file's `updated` stamp, when it parsed. */
+    updatedAtMs?: number;
+    requests?: number;
+    apiEquivalentCost?: number;
+    since?: string;
+    nowMs?: number;
+}): {
+    status: CheckStatus;
+    detail: string;
+};
 export declare function failoverReadiness(input: {
     chain: readonly string[];
     codexAccounts: number;

package/dist/doctor-core.js

@@ -64,6 +64,50 @@ export function continuationReadiness(input) {
                 : 'the chain has nowhere to go for a second hop (see Failover)'),
     };
 }
+/**
+ * Ledger readiness (v6.6.4). The ledger is a file the proxy writes a few
+ * seconds after each request; the number it feeds (`dario usage`, the TUI's
+ * API-equivalent row) only ever moves if that write lands. A bind mount that
+ * came up read-only, a home directory the proxy cannot create, a file a
+ * root-owned rig left behind — each of these looks exactly like "no traffic"
+ * from the outside. This row says whether the file can be written, when it
+ * last was, and what it holds. File and configuration only: the proxy's own
+ * unflushed records are not visible here.
+ */
+export function ledgerReadiness(input) {
+    if (!input.enabled) {
+        return { status: 'info', detail: 'off — no lifetime API-equivalent numbers (unset DARIO_LEDGER / drop --no-ledger)' };
+    }
+    if (!input.exists) {
+        return input.writable
+            ? { status: 'ok', detail: `no file yet at ${input.path} — it appears after the first request through the proxy` }
+            : { status: 'warn', detail: `cannot write ${input.path} — the ledger will never record anything (check the directory's owner and mount)` };
+    }
+    if (input.parseError) {
+        return { status: 'warn', detail: `${input.path} is unreadable (${input.parseError}) — the proxy moves it aside and starts fresh on its next start; the history in it is lost` };
+    }
+    const now = input.nowMs ?? Date.now();
+    const age = typeof input.updatedAtMs === 'number' ? Math.max(0, now - input.updatedAtMs) : null;
+    const ageText = age === null ? 'last write unknown' : `last write ${describeAge(age)} ago`;
+    const usd = typeof input.apiEquivalentCost === 'number' ? `$${input.apiEquivalentCost >= 100 ? Math.round(input.apiEquivalentCost).toLocaleString('en-US') : input.apiEquivalentCost.toFixed(2)}` : '$?';
+    const body = `${(input.requests ?? 0).toLocaleString('en-US')} requests since ${(input.since ?? '').slice(0, 10) || '?'}, ${usd} API-equivalent; ${ageText}`;
+    if (!input.writable) {
+        return { status: 'warn', detail: `${body} — file is read-only now, so nothing since then is being saved (${input.path})` };
+    }
+    return { status: 'ok', detail: `${body} (${input.path})` };
+}
+function describeAge(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h}h`;
+    return `${Math.round(h / 24)}d`;
+}
 export function failoverReadiness(input) {
     const { chain, codexAccounts, backends } = input;
     const hasCodex = codexAccounts > 0;
@@ -1200,6 +1244,54 @@ export async function runChecks(opts = {}) {
     catch (err) {
         checks.push({ status: 'warn', label: 'Failover', detail: `check failed: ${err.message}` });
     }
+    // ---- Ledger (v6.6.4) — see ledgerReadiness() for the why. The default
+    // port's file; DARIO_LEDGER_PATH is honoured like the proxy honours it.
+    try {
+        const { resolveLedgerPath, ledgerDisabledByEnv, readLedgerFile, summarizeLedger } = await import('./ledger.js');
+        const { access, constants } = await import('node:fs/promises');
+        const path = resolveLedgerPath(3456);
+        const enabled = !ledgerDisabledByEnv();
+        let exists = false;
+        let writable = false;
+        try {
+            await access(path, constants.F_OK);
+            exists = true;
+        }
+        catch { /* no file yet */ }
+        // The proxy creates missing directories on its first flush, so test the
+        // nearest ancestor that exists — a fresh install has no ~/.dario yet.
+        let probe = exists ? path : dirname(path);
+        while (!exists) {
+            try {
+                await access(probe, constants.F_OK);
+                break;
+            }
+            catch { /* climb */ }
+            const up = dirname(probe);
+            if (up === probe)
+                break;
+            probe = up;
+        }
+        try {
+            await access(probe, constants.W_OK);
+            writable = true;
+        }
+        catch { /* not writable */ }
+        const { file, error } = exists ? await readLedgerFile(path) : { file: null, error: undefined };
+        const summary = file ? summarizeLedger(file, path) : null;
+        const verdict = ledgerReadiness({
+            enabled, path, exists, writable,
+            parseError: error,
+            updatedAtMs: file ? Date.parse(file.updated) : undefined,
+            requests: summary?.requests,
+            apiEquivalentCost: summary?.apiEquivalentCost,
+            since: summary?.since,
+        });
+        checks.push({ status: verdict.status, label: 'Ledger', detail: verdict.detail });
+    }
+    catch (err) {
+        checks.push({ status: 'warn', label: 'Ledger', detail: `check failed: ${err.message}` });
+    }
     // ---- CC sub-agent (v3.26, direction #2)
     try {
         const { loadSubagentStatus } = await import('./subagent.js');

package/docs/api-equivalent-spend.md

@@ -60,6 +60,18 @@ is never overwritten in place. Days past 730 roll off the front.
 The test suite pins `DARIO_LEDGER_PATH` to a temp directory, so a suite run
 does not add stub traffic to the operator's file.
 
+`dario doctor` has a **Ledger** row (6.6.4): whether the default port's file
+(or `DARIO_LEDGER_PATH`) can be written, when it was last written, and what
+it holds. A bind mount that came up read-only, a home the proxy cannot
+create, a file a root-owned rig left behind — from the outside each looks
+exactly like "no traffic", and the number stops moving without a word. The
+row reads the file only; records the proxy has not flushed yet are not in it.
+
+```
+  [ OK ]  Ledger  160 requests since 2026-09-12, $1.74 API-equivalent; last write 3s ago (/home/dario/.dario/ledger.json)
+  [WARN]  Ledger  cannot write /home/dario/.dario/ledger.json — the ledger will never record anything (check the directory's owner and mount)
+```
+
 ## Reading it
 
 ```

package/package.json

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