@adhdev/daemon-standalone 1.0.56-rc.18 → 1.0.56-rc.19

package/dist/index.js

@@ -36053,7 +36053,9 @@ var require_dist3 = __commonJS({
           onDependencyFailure: "block"
         };
         DEFAULT_QUOTA_ROUTING_POLICY = {
-          staleAfterMs: 30 * 60 * 1e3,
+          // ★Must stay equal to quota/refresh.ts QUOTA_ROUTABLE_MAX_AGE_MS —
+          // quota-routing-staleness-agreement.test.ts fails on drift.
+          staleAfterMs: 60 * 60 * 1e3,
           sessionMinRemainingPercent: 10,
           sessionResetImminentMs: 5 * 60 * 1e3,
           weeklyMinRemainingPercent: 15,
@@ -36620,10 +36622,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "b9573edba3daff309b1cef96ba7654b64306288a" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "b9573edb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.18" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-20T12:57:51.521Z" : void 0);
+      const commit = readInjected(true ? "6d9cfa28a604d36d2b29cf1cdd21499c13171ab4" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "6d9cfa28" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.19" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-20T17:59:03.306Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -41126,6 +41128,26 @@ child.on('exit', () => process.exit(0));
         }
       };
     }
+    function stampFetchedAt(quota, now) {
+      return { ...quota, metadata: { ...quota.metadata, fetchedAt: now } };
+    }
+    function lastAttemptAt(entry) {
+      if (!entry) return void 0;
+      const fetchedAt = Number(entry.metadata?.fetchedAt);
+      if (Number.isFinite(fetchedAt) && fetchedAt > 0) return fetchedAt;
+      const updatedAt = Number(entry.updatedAt);
+      return Number.isFinite(updatedAt) && updatedAt > 0 ? updatedAt : void 0;
+    }
+    function isDueByAxisTtl(provider, now = Date.now(), ttlTable = QUOTA_AXIS_TTL_MS) {
+      const ttl = ttlTable[provider];
+      if (!Number.isFinite(ttl)) return false;
+      const attemptedAt = lastAttemptAt(cache.get(provider));
+      if (attemptedAt === void 0) return true;
+      return now - attemptedAt >= ttl;
+    }
+    function isDueBySwrTtl(provider, now = Date.now()) {
+      return isDueByAxisTtl(provider, now, QUOTA_SWR_TTL_MS);
+    }
     function readQuotaCache() {
       if (cache.size === 0) return void 0;
       return Object.fromEntries(cache);
@@ -41166,8 +41188,9 @@ child.on('exit', () => process.exit(0));
       const retryAtMs = entry.metadata?.retryAtMs;
       return typeof retryAtMs === "number" && retryAtMs > now;
     }
-    async function refreshQuotaCacheOnce(fetchers = REFRESHERS, isEnabled) {
-      const enabled = isEnabled ? fetchers.filter(({ provider }) => isEnabled(provider)) : fetchers;
+    async function refreshQuotaCacheOnce(fetchers = REFRESHERS, isEnabled, options = {}) {
+      const selected = options.probeOnly ? fetchers.filter(({ provider }) => options.probeOnly.has(provider)) : fetchers;
+      const enabled = isEnabled ? selected.filter(({ provider }) => isEnabled(provider)) : selected;
       if (isEnabled) {
         for (const { provider } of fetchers) {
           if (!isEnabled(provider)) {
@@ -41182,17 +41205,21 @@ child.on('exit', () => process.exit(0));
         active.map(async ({ provider, fetch: fetch2 }) => {
           try {
             const fresh = toWireQuota(await fetch2());
-            cache.set(provider, carryForwardLastGoodWindows(cache.get(provider), fresh));
+            cache.set(
+              provider,
+              stampFetchedAt(carryForwardLastGoodWindows(cache.get(provider), fresh), Date.now())
+            );
             hydratedOnly.delete(provider);
           } catch (e) {
+            const now = Date.now();
             cache.set(provider, {
               provider,
               status: "error",
               session: null,
               weekly: null,
-              updatedAt: Date.now(),
+              updatedAt: now,
               error: `Quota fetch threw: ${e?.message || e}`,
-              metadata: { failureKind: "unknown" }
+              metadata: { failureKind: "unknown", fetchedAt: now }
             });
             hydratedOnly.delete(provider);
           }
@@ -41264,6 +41291,7 @@ child.on('exit', () => process.exit(0));
     function startQuotaRefreshLoop(options) {
       const intervalMs = options.intervalMs ?? QUOTA_REFRESH_INTERVAL_MS;
       const fetchers = options.fetchers ?? REFRESHERS;
+      if (options.isEnabled) ambientIsEnabled = options.isEnabled;
       let running = false;
       const timer = setInterval(() => {
         if (running) return;
@@ -41273,15 +41301,22 @@ child.on('exit', () => process.exit(0));
         } catch {
           active = false;
         }
-        const needsBackfill = options.isEnabled ? fetchers.some(({ provider }) => options.isEnabled(provider) && (!cache.has(provider) || isFailureRetryDue(provider) || isSnapshotStaleForRouting(provider))) : false;
-        if (!active && !needsBackfill) return;
+        const backfillDue = (provider) => !!options.isEnabled && (!cache.has(provider) || isFailureRetryDue(provider) || isSnapshotStaleForRouting(provider));
+        const due = fetchers.filter(({ provider }) => {
+          if (options.isEnabled && !options.isEnabled(provider)) return false;
+          if (backfillDue(provider)) return true;
+          return active && isDueByAxisTtl(provider);
+        });
+        const needsPrune = !!options.isEnabled && fetchers.some(({ provider }) => !options.isEnabled(provider) && cache.has(provider));
+        if (due.length === 0 && !needsPrune) return;
         running = true;
-        void refreshQuotaCacheOnce(fetchers, options.isEnabled).catch((e) => LOG2.warn("Quota", `Quota refresh tick error: ${e?.message || e}`)).finally(() => {
+        const probeOnly = new Set(due.map(({ provider }) => provider));
+        void refreshQuotaCacheOnce(fetchers, options.isEnabled, { probeOnly }).catch((e) => LOG2.warn("Quota", `Quota refresh tick error: ${e?.message || e}`)).finally(() => {
           running = false;
         });
       }, intervalMs);
       if (typeof timer.unref === "function") timer.unref();
-      LOG2.info("Quota", `Quota refresh loop started (interval ${intervalMs}ms, idle machines skipped)`);
+      LOG2.info("Quota", `Quota refresh loop started (interval ${intervalMs}ms, per-axis TTL, idle machines skipped)`);
       return {
         stop() {
           clearInterval(timer);
@@ -41329,10 +41364,87 @@ child.on('exit', () => process.exit(0));
         }
       };
     }
+    function readQuotaCacheWithRevalidate(now = Date.now()) {
+      const snapshot = readQuotaCache();
+      try {
+        scheduleStaleRevalidate(now);
+      } catch (e) {
+        LOG2.warn("Quota", `Quota revalidate scheduling failed: ${e?.message || e}`);
+      }
+      return snapshot;
+    }
+    function scheduleStaleRevalidate(now) {
+      const due = REFRESHERS.filter(({ provider }) => {
+        if (ambientIsEnabled && !ambientIsEnabled(provider)) return false;
+        if (revalidateInFlight.has(provider)) return false;
+        if (isRateLimitedCooldownActive(cache.get(provider), now)) return false;
+        return isDueBySwrTtl(provider, now);
+      });
+      if (due.length === 0) return;
+      for (const { provider } of due) revalidateInFlight.add(provider);
+      const probeOnly = new Set(due.map(({ provider }) => provider));
+      void refreshQuotaCacheOnce(REFRESHERS, ambientIsEnabled, { probeOnly }).catch((e) => LOG2.warn("Quota", `Quota revalidate failed: ${e?.message || e}`)).finally(() => {
+        for (const { provider } of due) revalidateInFlight.delete(provider);
+      });
+    }
+    async function forceRefreshQuota2(providers, now = Date.now()) {
+      const requested = providers && providers.length > 0 ? providers.map((p) => String(p).trim()).filter(Boolean) : REFRESHERS.map(({ provider }) => provider);
+      const entries = [];
+      const probe = [];
+      for (const name of requested) {
+        const refresher = REFRESHERS.find(({ provider: provider2 }) => provider2 === name);
+        if (!refresher) {
+          entries.push({
+            provider: name,
+            outcome: "unsupported",
+            reason: `'${name}' does not report quota on this machine`
+          });
+          continue;
+        }
+        const provider = refresher.provider;
+        if (ambientIsEnabled && !ambientIsEnabled(provider)) {
+          entries.push({
+            provider,
+            outcome: "disabled",
+            reason: `${provider} is disabled on this machine (or its quota probe is turned off)`
+          });
+          continue;
+        }
+        const entry = cache.get(provider);
+        if (isRateLimitedCooldownActive(entry, now)) {
+          const retryAtMs = Number(entry?.metadata?.retryAtMs);
+          const seconds = Math.max(0, Math.ceil((retryAtMs - now) / 1e3));
+          entries.push({
+            provider,
+            outcome: "cooldown",
+            retryAtMs,
+            reason: `${provider} hit its provider's rate limit \u2014 not re-probed for another ${formatDuration(seconds)}. The numbers shown are the last good reading.`
+          });
+          continue;
+        }
+        probe.push(provider);
+      }
+      if (probe.length > 0) {
+        await refreshQuotaCacheOnce(REFRESHERS, ambientIsEnabled, { probeOnly: new Set(probe) }).catch((e) => LOG2.warn("Quota", `Force quota refresh failed: ${e?.message || e}`));
+        for (const provider of probe) entries.push({ provider, outcome: "refreshed" });
+      }
+      entries.sort((a, b) => a.provider.localeCompare(b.provider));
+      return { entries, quota: readQuotaCache() };
+    }
+    function formatDuration(seconds) {
+      if (seconds < 60) return `${seconds}s`;
+      const minutes = Math.floor(seconds / 60);
+      const rest = seconds % 60;
+      return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+    }
     var QUOTA_REFRESH_INTERVAL_MS;
     var QUOTA_ACTIVITY_WINDOW_MS;
+    var QUOTA_AXIS;
+    var QUOTA_AXIS_TTL_MS;
+    var QUOTA_SWR_TTL_MS;
     var REFRESHERS;
     var cache;
+    var ambientIsEnabled;
     var hydratedOnly;
     var hydrated;
     var QUOTA_FAILURE_MAX_RETRIES;
@@ -41342,6 +41454,7 @@ child.on('exit', () => process.exit(0));
     var bootRefreshInFlight;
     var QUOTA_EVENT_REFRESH_DEBOUNCE_MS;
     var QUOTA_REFRESH_EVENTS;
+    var revalidateInFlight;
     var init_refresh = __esm2({
       "src/quota/refresh.ts"() {
         "use strict";
@@ -41356,6 +41469,30 @@ child.on('exit', () => process.exit(0));
         init_persist();
         QUOTA_REFRESH_INTERVAL_MS = 15 * 60 * 1e3;
         QUOTA_ACTIVITY_WINDOW_MS = 20 * 60 * 1e3;
+        QUOTA_AXIS = {
+          "antigravity-cli": "network",
+          "claude-cli": "file",
+          "codex-cli": "file",
+          "grok-cli": "network",
+          "kimi": "network",
+          "opencode": "file"
+        };
+        QUOTA_AXIS_TTL_MS = {
+          "antigravity-cli": Number.POSITIVE_INFINITY,
+          "claude-cli": 6e4,
+          "codex-cli": 6e4,
+          "grok-cli": Number.POSITIVE_INFINITY,
+          "kimi": Number.POSITIVE_INFINITY,
+          "opencode": 5 * 60 * 1e3
+        };
+        QUOTA_SWR_TTL_MS = {
+          "antigravity-cli": 10 * 60 * 1e3,
+          "claude-cli": QUOTA_AXIS_TTL_MS["claude-cli"],
+          "codex-cli": QUOTA_AXIS_TTL_MS["codex-cli"],
+          "grok-cli": 10 * 60 * 1e3,
+          "kimi": 10 * 60 * 1e3,
+          "opencode": QUOTA_AXIS_TTL_MS["opencode"]
+        };
         REFRESHERS = [
           { provider: "antigravity-cli", fetch: () => fetchAntigravityQuota2() },
           { provider: "claude-cli", fetch: () => fetchClaudeQuota2() },
@@ -41369,7 +41506,7 @@ child.on('exit', () => process.exit(0));
         hydrated = false;
         QUOTA_FAILURE_MAX_RETRIES = 4;
         failureRetries = /* @__PURE__ */ new Map();
-        QUOTA_ROUTABLE_MAX_AGE_MS = 30 * 60 * 1e3;
+        QUOTA_ROUTABLE_MAX_AGE_MS = 60 * 60 * 1e3;
         WORKING_STATUSES = /* @__PURE__ */ new Set([
           "generating",
           "waiting_approval",
@@ -41383,6 +41520,7 @@ child.on('exit', () => process.exit(0));
         bootRefreshInFlight = false;
         QUOTA_EVENT_REFRESH_DEBOUNCE_MS = 6e4;
         QUOTA_REFRESH_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
+        revalidateInFlight = /* @__PURE__ */ new Set();
       }
     });
     var import_session_host_core3;
@@ -84699,6 +84837,8 @@ ${e?.stderr || ""}`;
       ProviderChannelStore: () => ProviderChannelStore,
       ProviderInstanceManager: () => ProviderInstanceManager,
       ProviderLoader: () => ProviderLoader,
+      QUOTA_AXIS: () => QUOTA_AXIS,
+      QUOTA_AXIS_TTL_MS: () => QUOTA_AXIS_TTL_MS,
       RECENT_MAGI_CAP: () => RECENT_MAGI_CAP,
       RECENT_TERMINAL_REFINE_CAP: () => RECENT_TERMINAL_REFINE_CAP,
       RawTerminalAttachment: () => RawTerminalAttachment,
@@ -84858,6 +84998,7 @@ ${e?.stderr || ""}`;
       findTasksOrphanedBySessionStop: () => findTasksOrphanedBySessionStop,
       flattenMessageParts: () => flattenMessageParts,
       foldUsageRecords: () => foldUsageRecords,
+      forceRefreshQuota: () => forceRefreshQuota2,
       formatManifestValidationIssues: () => formatManifestValidationIssues,
       formatMeshTaskModeViolations: () => formatMeshTaskModeViolations,
       forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance2,
@@ -85039,6 +85180,7 @@ ${e?.stderr || ""}`;
       printClaudeUninstallResult: () => printClaudeUninstallResult2,
       printQuota: () => printQuota2,
       printQuotaInstallError: () => printQuotaInstallError2,
+      printQuotaRefreshOutcome: () => printQuotaRefreshOutcome2,
       probeCdpPort: () => probeCdpPort,
       projectGraphPublicPolicy: () => projectGraphPublicPolicy,
       pruneOperatingNotes: () => pruneOperatingNotes,
@@ -99464,8 +99606,40 @@ ${marker}`,
           providerChannelStaleness: ctx.deps.providerLoader?.getChannelStalenessSnapshot?.() ?? null
         };
       },
+      /**
+       * ★FORCE REFRESH — the single entry point for "read my quota again, now".
+       *
+       * Every surface funnels here: `adhdev quota --refresh` (over local IPC), a
+       * dashboard refresh button, an MCP caller. One entry point rather than
+       * several is what keeps the 429 cooldown, the enable gate and the
+       * carry-forward from being re-implemented (and quietly weakened) per
+       * surface.
+       *
+       * ★It runs INSIDE the daemon, so it warms the cache that routing and every
+       * dashboard read consume. This is the difference from `adhdev quota codex`,
+       * which calls a fetcher in a separate CLI process: that prints a number and
+       * leaves the daemon exactly as stale as it was.
+       *
+       * ★It does not bypass the 429 cooldown. A cooling-down provider comes back
+       * with outcome 'cooldown' + retryAtMs, and the caller is expected to SAY so
+       * — see forceRefreshQuota for why overriding on user request is the wrong
+       * behaviour here.
+       */
+      refresh_provider_quota: async (_ctx, args) => {
+        const raw = args?.providers ?? args?.provider;
+        const providers = Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : typeof raw === "string" && raw.trim() ? [raw.trim()] : void 0;
+        const { entries, quota } = await forceRefreshQuota2(providers);
+        return {
+          success: true,
+          refreshed: entries,
+          // Same "omit rather than send undefined" contract as the reads above.
+          ...quota ? { quota } : {},
+          machineNickname: loadConfig2().machineNickname,
+          timestamp: Date.now()
+        };
+      },
       get_machine_runtime_stats: async (_ctx, _args) => {
-        const quota = readQuotaCache();
+        const quota = readQuotaCacheWithRevalidate();
         return {
           success: true,
           machine: {
@@ -99498,7 +99672,7 @@ ${marker}`,
         const launchInfo = adapter && typeof adapter.getLaunchInfo === "function" ? adapter.getLaunchInfo() : void 0;
         const providerType = target?.providerType || coord?.cliType || "";
         const providerMetaForSession = providerType ? ctx.deps.providerLoader.resolve?.(providerType) || ctx.deps.providerLoader.getMeta(providerType) : void 0;
-        const quota = readQuotaCache();
+        const quota = readQuotaCacheWithRevalidate();
         return {
           success: true,
           session: {
@@ -133753,6 +133927,32 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       }
       console.log();
     }
+    function printQuotaRefreshOutcome2(entries) {
+      console.log();
+      if (entries.length === 0) {
+        console.log(import_chalk2.default.gray("  Nothing to refresh."));
+        console.log();
+        return;
+      }
+      const refreshed = entries.filter((e) => e.outcome === "refreshed");
+      if (refreshed.length > 0) {
+        console.log(import_chalk2.default.green(`\u2713 Refreshed ${refreshed.map((e) => e.provider).join(", ")}`));
+      }
+      for (const entry of entries) {
+        if (entry.outcome === "refreshed") continue;
+        if (entry.outcome === "cooldown") {
+          console.log(import_chalk2.default.yellow(`\u2022 ${entry.provider}: rate-limited \u2014 not re-probed`));
+          if (typeof entry.retryAtMs === "number" && Number.isFinite(entry.retryAtMs)) {
+            console.log(import_chalk2.default.gray(`  Retrying no earlier than ${formatRelative(entry.retryAtMs)}.`));
+          }
+          console.log(import_chalk2.default.gray("  The numbers shown are the last good reading."));
+          console.log(import_chalk2.default.gray("  Re-probing now would extend the provider's own throttle."));
+          continue;
+        }
+        console.log(import_chalk2.default.gray(`\u2022 ${entry.provider}: ${entry.reason || entry.outcome}`));
+      }
+      console.log();
+    }
     function printClaudeInstallResult2(result) {
       console.log();
       console.log(
@@ -134175,6 +134375,7 @@ async function proxySessionHostAttach(target, options = {}) {
 var import_daemon_core2 = __toESM(require_dist3());
 var QUOTA_HELP_TEXT = `
 Usage: adhdev quota <provider>
+       adhdev quota refresh [providers...]
        adhdev quota claude:install | claude:uninstall | claude:status
 
 Providers:
@@ -134184,6 +134385,12 @@ Providers:
   grok      Show Grok CLI plan usage (queries the xAI billing API live)
   kimi      Show Kimi Code plan usage (queries the Kimi API live)
 
+Refresh:
+  refresh   Re-read quota now. Providers that recently returned HTTP 429 are
+            NOT re-probed \u2014 the cooldown is reported with the time it lifts,
+            because re-hitting the endpoint extends the provider's own throttle.
+            Local-file providers (claude, codex) have no cooldown.
+
 Claude Code setup (antigravity/codex/grok/kimi need no setup \u2014 they query live):
   claude:install     Set up Claude Code quota reporting by wrapping your statusline
   claude:uninstall   Remove Claude Code quota reporting and restore your original statusline
@@ -134208,6 +134415,11 @@ async function runQuotaCommand(args) {
     case "kimi":
       (0, import_daemon_core2.printQuota)("Kimi Code", await (0, import_daemon_core2.fetchKimiQuota)());
       return 0;
+    case "refresh": {
+      const { entries } = await (0, import_daemon_core2.forceRefreshQuota)(args.slice(1));
+      (0, import_daemon_core2.printQuotaRefreshOutcome)(entries);
+      return entries.some((e) => e.outcome === "unsupported") ? 1 : 0;
+    }
     case "claude:install":
     case "claude-install": {
       try {