quotacap 0.0.33 → 0.0.34

package/dist/adapters/codex.js

@@ -52,6 +52,12 @@ function parseFiveReset(raw, now) {
 }
 export function parseCodexTui(text, now = new Date()) {
     const cleaned = stripAnsi(text);
+    if (/refresh token was already used|please log out and sign in again|access token could not be refreshed/i.test(cleaned)) {
+        throw new Error("codex: your access token could not be refreshed because your refresh token was already used. Please log out and sign in again.");
+    }
+    if (/Limits:\s*refresh requested/i.test(cleaned)) {
+        throw new Error("codex: limits refresh requested, run /status again shortly");
+    }
     let weeklyLeft = null;
     let fiveLeft = null;
     let weeklyRaw = null;
@@ -146,7 +152,7 @@ export const codexAdapter = {
             // Complete on the /status panel only. The startup statusline footer
             // ("· 5h N% left · weekly N% left") carries no reset timestamps and
             // would otherwise win the race, forcing a drifting now+7d estimate.
-            completionRegex: /Weekly limit:/i,
+            completionRegex: /Weekly limit:|Limits:\s*refresh requested|refresh token was already used|log out and sign in again/i,
             abortOn: /Do you trust|Trust.*folder|trust the files in this folder/i,
             timeoutMs: 12000,
             maxBytes: 256 * 1024,

package/dist/adapters/muse.js

@@ -14,6 +14,9 @@ export function parseMuseTui(text, now = new Date()) {
     // After ANSI stripping the panel is ONE line (cursor-addressed, no
     // newlines), so no pattern here may anchor on ^, $ or \n.
     const cleaned = stripAnsi(text);
+    if (/currently unavailable|subscriptions aren't currently available|subscription_unavailable/i.test(cleaned)) {
+        throw new Error("muse: subscription currently unavailable in TUI output");
+    }
     const weekly = cleaned.match(/Weekly\s+(\d+)%\s+used/i);
     if (!weekly)
         throw new Error("muse: weekly usage not found in TUI output");

package/dist/cli/runtime.d.ts

@@ -31,4 +31,12 @@ export interface WebLaunchOptions {
     open?: boolean;
 }
 export declare function launchWeb(o: WebLaunchOptions, deps?: RuntimeCommandDeps): Promise<void>;
+export declare function waitForInitialPoll(port: number, opts?: {
+    createClient?: (opts: {
+        port: number;
+        timeoutMs: number;
+    }) => any;
+    sleep?: SleepFn;
+    timeoutMs?: number;
+}): Promise<void>;
 export declare function registerRuntimeCommands(program: Command, deps?: RuntimeCommandDeps): void;

package/dist/cli/runtime.js

@@ -55,16 +55,25 @@ export async function launchWeb(o, deps = {}) {
     if (health?.ok) {
         const skew = checkSkew(health, VERSION, process.execPath);
         if (skew === "match") {
+            if (health.polling === "in-progress" && !health.lastCompletedPollAt) {
+                await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
+            }
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
         }
         if (skew === "exec-only") {
             console.error(execSkewWarning(String(health.exec)));
+            if (health.polling === "in-progress" && !health.lastCompletedPollAt) {
+                await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
+            }
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
         }
         if (skew === "cli-older") {
             console.error(olderCliWarning(String(health.version ?? "unknown")));
+            if (health.polling === "in-progress" && !health.lastCompletedPollAt) {
+                await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
+            }
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
         }
@@ -86,6 +95,7 @@ export async function launchWeb(o, deps = {}) {
                 exit(1);
                 return;
             }
+            await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
         }
@@ -106,6 +116,7 @@ export async function launchWeb(o, deps = {}) {
         }
         // Unmanaged successor: foreground-start the new daemon and open it.
         const started = await start(o.port ? { port } : undefined);
+        await waitForInitialPoll(started.port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
         await openDashboard(`http://127.0.0.1:${started.port}`, openBrowser);
         return;
     }
@@ -144,6 +155,7 @@ export async function launchWeb(o, deps = {}) {
                     detail = `not ready within ${Math.round(readyTimeoutMs / 1000)}s`;
             }
             if (!detail) {
+                await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
                 await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
                 return;
             }
@@ -155,8 +167,28 @@ export async function launchWeb(o, deps = {}) {
     if (!foregroundOnly && !attemptedServiceStart && supported()) {
         console.error("for a background service that survives terminal closes, run 'quotacap service install'");
     }
+    await waitForInitialPoll(started.port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
     await openDashboard(`http://127.0.0.1:${started.port}`, openBrowser);
 }
+export async function waitForInitialPoll(port, opts = {}) {
+    const createClient = opts.createClient ?? createServiceClient;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const timeoutMs = opts.timeoutMs ?? 5000;
+    const deadline = Date.now() + timeoutMs;
+    const client = createClient({ port, timeoutMs: 1000 });
+    while (Date.now() < deadline) {
+        await sleep(250);
+        try {
+            const h = await client.get("/health");
+            if (!h?.ok || h?.polling !== "in-progress" || h?.lastCompletedPollAt) {
+                return;
+            }
+        }
+        catch {
+            return;
+        }
+    }
+}
 async function defaultOpenBrowser(url) {
     const cmd = process.platform === "darwin"
         ? "open"

package/dist/diagnostics/failure.d.ts

@@ -1,5 +1,5 @@
 import type { FailureCategory } from "../store/attempts.js";
-export type DiagnosticCode = "terminal_error" | "auth" | "command_not_found" | "trust_prompt" | "parse_error" | "rate_limit" | "timeout" | "network" | "unknown";
+export type DiagnosticCode = "terminal_error" | "auth" | "command_not_found" | "trust_prompt" | "parse_error" | "rate_limit" | "service_unavailable" | "timeout" | "network" | "unknown";
 export interface FailureEvidence {
     source: "pty" | "exec";
     checkpoint?: "spawn" | "before ready" | "during settle" | "before input" | "before completion" | "ready timeout" | "completion timeout" | "abort" | "trust prompt" | "write" | "transcript overflow";

package/dist/diagnostics/failure.js

@@ -20,6 +20,8 @@ export function formatProviderName(provider) {
             return "Antigravity";
         case "agy:3p":
             return "Antigravity (3rd-party)";
+        case "muse":
+            return "Muse";
         case "all":
             return "QuotaCap service";
         default:
@@ -134,6 +136,12 @@ function matchPrecedence(evidence, errorName, errorCode, text) {
     if (/\bexpired credentials?\b/i.test(text) || /\bexpired token\b/i.test(text) || /\bexpired api key\b/i.test(text)) {
         return { code: "auth", phrase: "expired credentials" };
     }
+    if (/\brefresh token was already used\b/i.test(text) ||
+        /\blog out and sign in again\b/i.test(text) ||
+        /\baccess token could not be refreshed\b/i.test(text) ||
+        /\bsign in again\b/i.test(text)) {
+        return { code: "auth", phrase: "login required" };
+    }
     if (/\bauthentication failed\b/i.test(text) ||
         /\bauthentication required\b/i.test(text) ||
         /\bmissing authentication\b/i.test(text)) {
@@ -216,6 +224,14 @@ function matchPrecedence(evidence, errorName, errorCode, text) {
     if (/\bno weekly bucket\b/i.test(text)) {
         return { code: "parse_error", phrase: "no weekly bucket" };
     }
+    // Order 8b: service_unavailable — subscription or service currently unavailable
+    if (/\b(?:subscription|service|usage)\s+currently\s+unavailable\b/i.test(text) ||
+        /\bsubscriptions aren't currently available\b/i.test(text)) {
+        return { code: "service_unavailable", phrase: "subscription currently unavailable" };
+    }
+    if (/\blimits refresh requested\b/i.test(text) || /\brefresh requested\b/i.test(text)) {
+        return { code: "service_unavailable", phrase: "limits refresh requested" };
+    }
     // Order 9: timeout — Remaining explicit timeout or timed out errors
     if (/\btimed out\b/i.test(text) || /\btimeout\b/i.test(text)) {
         return { code: "timeout", phrase: "timed out" };
@@ -386,6 +402,7 @@ function mapCategory(code) {
         case "command_not_found":
         case "trust_prompt":
         case "rate_limit":
+        case "service_unavailable":
         case "unknown":
         default:
             return "unknown";
@@ -423,6 +440,11 @@ function getSummaryAndAction(code, providerName) {
                 summary: `${providerName} rate limited`,
                 action: `Wait before retrying. While the service is running, QuotaCap will try again on its next scheduled poll.`,
             };
+        case "service_unavailable":
+            return {
+                summary: `${providerName} usage currently unavailable`,
+                action: `${providerName} reported that subscription usage is currently unavailable. Send a prompt in ${providerName} to refresh its session limits, or wait for the next scheduled poll.`,
+            };
         case "timeout":
             return {
                 summary: `${providerName} took too long to respond`,

package/dist/version.js

@@ -1,2 +1,2 @@
 // generated by scripts/build-embed.mjs — do not edit
-export const VERSION = "0.0.33";
+export const VERSION = "0.0.34";

package/dist/web/src/App.js

@@ -63,13 +63,11 @@ function App() {
     useEffect(() => {
         void load();
     }, [load]);
-    // While the daemon reports a non-idle poll state, keep re-reading until it
-    // settles. Without this the pill ("Polling", "Cooling down") sticks forever
-    // on the single post-refresh snapshot, which is always mid-cooldown.
+    // While the daemon reports an active poll, keep re-reading until it settles.
     useEffect(() => {
-        if (!snapshot || snapshot.runtime.polling === "idle")
+        if (!snapshot || snapshot.runtime.polling !== "in-progress")
             return;
-        const t = setInterval(() => void load(), 5000);
+        const t = setInterval(() => void load(), 1000);
         return () => clearInterval(t);
     }, [snapshot, load]);
     const refresh = useCallback(async () => {
@@ -81,7 +79,7 @@ function App() {
                 setNotice(result.message);
             }
             else if (result.raw?.cooldown === true) {
-                setNotice("Refresh cooling down — showing last readings.");
+                setNotice("Already up to date — showing latest readings.");
             }
             await load();
         }
@@ -116,7 +114,7 @@ function App() {
                                 border: i === 0 ? "1px solid var(--rec)" : "1px solid var(--line)",
                                 borderRadius: 8,
                                 marginBottom: 8,
-                            } }, i))) })), error?.kind === "service-unavailable" && !snapshot && (_jsx(UnavailablePanel, { endpoint: daemonEndpoint(), lastGood: snapshot, onRetry: () => void load() })), error?.kind === "http-error" && !snapshot && (_jsx(HttpErrorPanel, { status: error.status, message: error.message, lastGood: snapshot, onRetry: () => void load() })), error && snapshot && (_jsxs("div", { "data-testid": "state-stale-error", role: "alert", children: [error.kind === "http-error" ? `Request failed (HTTP ${error.status}): ` : "Service unavailable: ", error.message, " Showing last readings (", ageLabel(snapshot.asOf), ").", " ", _jsx("button", { type: "button", onClick: () => void load(), children: "Retry" })] })), snapshot && (_jsx(FaultBanner, { providers: snapshot.providers, onRepoll: () => void refresh(), repolling: refreshing })), snapshot && (_jsx(ReadyView, { snapshot: snapshot, onSelectProvider: (id) => {
+                            } }, i))) })), error?.kind === "service-unavailable" && !snapshot && (_jsx(UnavailablePanel, { endpoint: daemonEndpoint(), lastGood: snapshot, onRetry: () => void load() })), error?.kind === "http-error" && !snapshot && (_jsx(HttpErrorPanel, { status: error.status, message: error.message, lastGood: snapshot, onRetry: () => void load() })), error && snapshot && (_jsxs("div", { "data-testid": "state-stale-error", role: "alert", children: [error.kind === "http-error" ? `Request failed (HTTP ${error.status}): ` : "Service unavailable: ", error.message, " Showing last readings (", ageLabel(snapshot.asOf), ").", " ", _jsx("button", { type: "button", onClick: () => void load(), children: "Retry" })] })), snapshot && (_jsx(FaultBanner, { providers: snapshot.providers, onRepoll: () => void refresh(), repolling: refreshing, polling: snapshot.runtime.polling })), snapshot && (_jsx(ReadyView, { snapshot: snapshot, onSelectProvider: (id) => {
                             setAdviceOpen(false);
                             setSelectedProvider(id);
                         }, onViewAdvice: () => {

package/dist/web/src/components/FaultBanner.d.ts

@@ -10,8 +10,9 @@ export interface Repair {
  * service-unavailable panel when the daemon itself is down.
  */
 export declare function repairFor(provider: ProviderView): Repair;
-export declare function FaultBanner({ providers, onRepoll, repolling, }: {
+export declare function FaultBanner({ providers, onRepoll, repolling, polling, }: {
     providers: ProviderView[];
     onRepoll: () => void;
     repolling: boolean;
+    polling?: "idle" | "in-progress" | "degraded" | string;
 }): React.JSX.Element | null;

package/dist/web/src/components/FaultBanner.js

@@ -53,8 +53,16 @@ function bannerVerb(provider) {
             return "needs attention";
     }
 }
-export function FaultBanner({ providers, onRepoll, repolling, }) {
-    const faulted = providers.filter((p) => p.enabled && p.exclusionReason !== null);
+export function FaultBanner({ providers, onRepoll, repolling, polling, }) {
+    const isPolling = repolling || polling === "in-progress";
+    const faulted = providers.filter((p) => {
+        if (!p.enabled || p.exclusionReason === null)
+            return false;
+        if (isPolling && (p.exclusionReason === "stale" || p.exclusionReason === "not-reporting")) {
+            return false;
+        }
+        return true;
+    });
     if (faulted.length === 0)
         return null;
     return (_jsx("div", { children: faulted.map((p) => {

package/dist/web/src/components/Header.d.ts

@@ -2,9 +2,9 @@ import React from "react";
 import type { RuntimeView } from "../state.js";
 export type PillState = "live" | "polling" | "unreachable" | "not-ready";
 /**
- * Header pill from runtime fields. Unreachable is red, polling/cooldown is
- * amber, ready plus idle is green. Not-ready and unknown-version surface as
- * their own explicit state, never as green.
+ * Header pill from runtime fields. Unreachable is red, active polling is
+ * amber, ready is green (including during refresh cooldown). Not-ready and
+ * unknown-version surface as their own explicit state, never as green.
  */
 export declare function pillFor(runtime: {
     available: boolean;

package/dist/web/src/components/Header.js

@@ -1,14 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ThemeToggle } from "../Theme.js";
 /**
- * Header pill from runtime fields. Unreachable is red, polling/cooldown is
- * amber, ready plus idle is green. Not-ready and unknown-version surface as
- * their own explicit state, never as green.
+ * Header pill from runtime fields. Unreachable is red, active polling is
+ * amber, ready is green (including during refresh cooldown). Not-ready and
+ * unknown-version surface as their own explicit state, never as green.
  */
 export function pillFor(runtime) {
     if (!runtime.available)
         return "unreachable";
-    if (runtime.polling === "in-progress" || runtime.polling === "cooldown")
+    if (runtime.polling === "in-progress")
         return "polling";
     if (!runtime.ready)
         return "not-ready";
@@ -29,7 +29,7 @@ function pillText(pill, runtime) {
         case "live":
             return "daemon live";
         case "polling":
-            return runtime?.polling === "cooldown" ? "Cooling down" : "Polling";
+            return "Polling";
         case "unreachable":
             return "Daemon unreachable";
         case "not-ready":