quotacap 0.0.35 → 0.0.37

package/README.md

@@ -23,9 +23,9 @@ QuotaCap helps you get more from the AI coding subscriptions you already pay for
 | Codex | `pty` — `codex --no-alt-screen` then `/status`, parse `Weekly/5h limit: X% left` | Live |
 | Kimi Code | `pty` — `kimi` then `/usage`, parse `Weekly/5h limit: Y% used` | Live |
 | Grok | `pty` — `grok` then `/usage`, parse `Weekly limit (plan)` + `Credits: $X` | Live |
-| Muse Code | `pty` — `muse --trust-workspace` then `/usage`, parse `Subscription · Muse Code <plan>` + `Weekly/Current N% used` | Live |
+| Muse Code | `pty` — `muse --trust-workspace` then `/usage`, parse `Subscription · Muse Code <plan>` + `Weekly/Current N% used`; on `Currently unavailable`, up to three headless `muse exec` warm turns and re-reads inside the poll | Live |
 
-Exec adapters run via `execFile` with an argv list. PTY adapters run via `node-pty` (`src/adapters/pty.ts`). They are TUI-fragile: a vendor text change breaks the parser and the row degrades fail-closed until the regex is fixed. Poll latency is 2–10 s per PTY provider (settle plus completion). It dominates `POST /api/refresh` and the first poll, not the steady-state 15 m timer.
+Exec adapters run via `execFile` with an argv list. PTY adapters run via `node-pty` (`src/adapters/pty.ts`). They are TUI-fragile: a vendor text change breaks the parser and the row degrades fail-closed until the regex is fixed. Poll latency is 2–10 s per PTY provider (settle plus completion); `muse` can reach about 75 s when it has to warm an unavailable subscription. It dominates `POST /api/refresh` and the first poll, not the steady-state 15 m timer.
 
 Live adapters invoke the CLIs you already logged into. No API keys. No token files are read.
 

package/dist/adapters/index.js

@@ -21,7 +21,7 @@ const ADAPTER_TIMEOUTS = {
     kimi: 8000,
     grok: 14000,
     agy: 20000,
-    muse: 14000,
+    muse: 90000,
 };
 export async function pollAll(enabled, opts) {
     const rawJobs = enabled.map(id => {

package/dist/adapters/muse.d.ts

@@ -1,4 +1,32 @@
 import type { ParsedQuota } from "./types.js";
+/** Canonical unavailability error: parseMuseTui throws it, poll() recognises it
+ *  to start recovery, and failure.ts classifies its text as service_unavailable. */
+export declare const MUSE_UNAVAILABLE_MESSAGE = "muse: subscription currently unavailable in TUI output";
+export declare const WARM_ATTEMPTS = 3;
+export declare const WARM_SETTLE_MS = 3000;
+export declare const WARM_EXEC_TIMEOUT_MS = 20000;
+export declare const FALLBACK_BUDGET_MS = 60000;
+export interface RecoveryDeps {
+    unavailable: Error;
+    usagePass: (timeoutMs: number) => Promise<ParsedQuota>;
+    warmTurn: (timeoutMs: number) => Promise<void>;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+    aborted?: () => boolean;
+    log?: (message: string) => void;
+    attempts?: number;
+    settleMs?: number;
+    budgetMs?: number;
+}
+/**
+ * Recovery loop for an unavailable subscription, entered only on
+ * MUSE_UNAVAILABLE_MESSAGE. Attempt = settle, headless warm turn, settle,
+ * /usage re-read. The budget is checked before every step, and the warm turn,
+ * sleep and readiness/completion waits are clamped to what remains; the
+ * adapter's 90 s timeout is the backstop for the fixed per-pass overheads.
+ * Exhaustion rethrows the last unavailability error.
+ */
+export declare function recoverSubscription(deps: RecoveryDeps): Promise<ParsedQuota>;
 export declare function museProbeDir(): string;
 export declare function parseMuseTui(text: string, now?: Date): ParsedQuota;
 export declare const museAdapter: {

package/dist/adapters/muse.js

@@ -3,7 +3,71 @@ import os from "node:os";
 import path from "node:path";
 import { parseResetText } from "./parse.js";
 import { runPty, stripAnsi } from "./pty.js";
-import { adapterSignal } from "../runtime/spawn.js";
+import { adapterSignal, trackedExecFile } from "../runtime/spawn.js";
+/** Canonical unavailability error: parseMuseTui throws it, poll() recognises it
+ *  to start recovery, and failure.ts classifies its text as service_unavailable. */
+export const MUSE_UNAVAILABLE_MESSAGE = "muse: subscription currently unavailable in TUI output";
+export const WARM_ATTEMPTS = 3;
+export const WARM_SETTLE_MS = 3000;
+export const WARM_EXEC_TIMEOUT_MS = 20000;
+export const FALLBACK_BUDGET_MS = 60000;
+const USAGE_TIMEOUT_MS = 14000;
+const MIN_STEP_MS = 1000;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Recovery loop for an unavailable subscription, entered only on
+ * MUSE_UNAVAILABLE_MESSAGE. Attempt = settle, headless warm turn, settle,
+ * /usage re-read. The budget is checked before every step, and the warm turn,
+ * sleep and readiness/completion waits are clamped to what remains; the
+ * adapter's 90 s timeout is the backstop for the fixed per-pass overheads.
+ * Exhaustion rethrows the last unavailability error.
+ */
+export async function recoverSubscription(deps) {
+    const sleep = deps.sleep ?? delay;
+    const now = deps.now ?? Date.now;
+    const aborted = deps.aborted ?? (() => adapterSignal("muse")?.aborted === true);
+    const log = deps.log ?? ((message) => console.warn(`[quotacap] muse: ${message}`));
+    const attempts = deps.attempts ?? WARM_ATTEMPTS;
+    const settleMs = deps.settleMs ?? WARM_SETTLE_MS;
+    const deadline = now() + (deps.budgetMs ?? FALLBACK_BUDGET_MS);
+    const remaining = () => deadline - now();
+    let unavailable = deps.unavailable;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        if (remaining() < MIN_STEP_MS)
+            break;
+        await sleep(Math.min(settleMs, remaining()));
+        if (remaining() < MIN_STEP_MS)
+            break;
+        try {
+            await deps.warmTurn(Math.min(WARM_EXEC_TIMEOUT_MS, remaining()));
+        }
+        catch (warmError) {
+            if (aborted())
+                throw warmError;
+            log(`warm attempt ${attempt} failed: ${warmError?.message}`);
+            continue;
+        }
+        if (remaining() < MIN_STEP_MS)
+            break;
+        await sleep(Math.min(settleMs, remaining()));
+        if (remaining() < MIN_STEP_MS)
+            break;
+        try {
+            const quota = await deps.usagePass(Math.min(USAGE_TIMEOUT_MS, remaining()));
+            log(`subscription unavailable; recovered after ${attempt} warm prompt(s)`);
+            return quota;
+        }
+        catch (readError) {
+            if (readError?.message !== MUSE_UNAVAILABLE_MESSAGE)
+                throw readError;
+            unavailable = readError;
+        }
+    }
+    log("subscription still unavailable; warm recovery exhausted");
+    throw unavailable;
+}
 // QuotaCap-owned empty probe dir, beside the config and database. Muse loads
 // project-local skills, rules, hooks and plugin config from cwd, so the probe
 // never runs in $HOME or a user project — an empty dir grants nothing.
@@ -15,7 +79,7 @@ export function parseMuseTui(text, now = new Date()) {
     // 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");
+        throw new Error(MUSE_UNAVAILABLE_MESSAGE);
     }
     const weekly = cleaned.match(/Weekly\s+(\d+)%\s+used/i);
     if (!weekly)
@@ -60,40 +124,67 @@ export function parseMuseTui(text, now = new Date()) {
         raw: cleaned.slice(0, 4096),
     };
 }
+/** One `/usage` read: the TUI scrape, shared by the first attempt and every
+ *  recovery re-read. */
+async function usagePass(timeoutMs = USAGE_TIMEOUT_MS) {
+    const cwd = museProbeDir();
+    fs.mkdirSync(cwd, { recursive: true });
+    const transcript = await runPty({
+        file: "muse",
+        args: ["--trust-workspace"],
+        cwd,
+        // Without this, a missing binary triggers a foreground 248 MB download
+        // on every poll; with it the launcher dies fast with a clear message.
+        env: { MUSE_NO_AUTO_UPDATE: "1" },
+        cols: 140,
+        rows: 50,
+        readyRegex: /muse-spark|Muse Code \d/,
+        readyTimeoutMs: 8000,
+        settleDelayMs: 1000,
+        // Two-phase submit: "/usage" first, CR 1500ms later. A single combined
+        // write is swallowed by the slash-command autocomplete and never runs.
+        input: "/usage",
+        submitInput: "\r",
+        submitAfterMs: 1500,
+        completionRegex: /Subscription/i,
+        // Trust prompt and the accidental-turn guard stay fail-closed. The
+        // unavailable-subscription message is deliberately not here: parseMuseTui
+        // owns detection so the poll can recover from it.
+        abortOn: /Do you trust this workspace|Working \(\d+s/,
+        timeoutMs,
+        respondToQueries: true,
+        maxBytes: 256 * 1024,
+        signal: adapterSignal("muse"),
+        label: "muse",
+    });
+    return parseMuseTui(transcript);
+}
 export const museAdapter = {
     id: "muse",
     requiresAuth: "muse login (CLI owns credentials)",
     async poll() {
-        const cwd = museProbeDir();
-        fs.mkdirSync(cwd, { recursive: true });
-        const transcript = await runPty({
-            file: "muse",
-            args: ["--trust-workspace"],
-            cwd,
-            // Without this, a missing binary triggers a foreground 248 MB download
-            // on every poll; with it the launcher dies fast with a clear message.
-            env: { MUSE_NO_AUTO_UPDATE: "1" },
-            cols: 140,
-            rows: 50,
-            readyRegex: /muse-spark|Muse Code \d/,
-            readyTimeoutMs: 8000,
-            settleDelayMs: 1000,
-            // Two-phase submit: "/usage" first, CR 1500ms later. A single combined
-            // write is swallowed by the slash-command autocomplete and never runs.
-            input: "/usage",
-            submitInput: "\r",
-            submitAfterMs: 1500,
-            completionRegex: /Subscription/i,
-            // Trust prompt (in case a future Muse ignores the flag), an accidental
-            // model turn from a mistimed Enter, and the unavailable-subscription
-            // fast-fail — every one aborts to a degraded row, never a 14s timeout.
-            abortOn: /Do you trust this workspace|Working \(\d+s|Subscriptions aren't currently available|subscription_unavailable/,
-            timeoutMs: 14000,
-            respondToQueries: true,
-            maxBytes: 256 * 1024,
-            signal: adapterSignal("muse"),
-            label: "muse",
-        });
-        return parseMuseTui(transcript);
+        // Captured before the first pass: pollAll clears the adapter signal map
+        // entry in a microtask when its gate rejects, but clearing the map does
+        // not reset the signal object, so the loop can still observe the abort.
+        const signal = adapterSignal("muse");
+        try {
+            return await usagePass();
+        }
+        catch (e) {
+            if (e?.message !== MUSE_UNAVAILABLE_MESSAGE)
+                throw e;
+            return recoverSubscription({
+                unavailable: e,
+                usagePass: (timeoutMs) => usagePass(timeoutMs),
+                warmTurn: async (timeoutMs) => {
+                    await trackedExecFile("muse", "muse", ["exec", "hi"], {
+                        cwd: museProbeDir(),
+                        env: { ...process.env, MUSE_NO_AUTO_UPDATE: "1" },
+                        timeout: timeoutMs,
+                    });
+                },
+                aborted: () => signal?.aborted === true,
+            });
+        }
     },
 };

package/dist/diagnostics/failure.js

@@ -408,7 +408,7 @@ function mapCategory(code) {
             return "unknown";
     }
 }
-function getSummaryAndAction(code, providerName) {
+function getSummaryAndAction(code, providerName, provider) {
     switch (code) {
         case "terminal_error":
             return {
@@ -443,7 +443,9 @@ function getSummaryAndAction(code, providerName) {
         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.`,
+                action: provider === "muse"
+                    ? `${providerName} reported that subscription usage is currently unavailable. QuotaCap already retried automatically with a warm-up prompt. If this persists, send a prompt in ${providerName}, or wait for the next scheduled poll.`
+                    : `${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 {
@@ -473,7 +475,7 @@ export function classifyFailure(provider, reason) {
     }
     const category = mapCategory(diag.diagnosticCode);
     const pName = formatProviderName(provider);
-    const { summary, action } = getSummaryAndAction(diag.diagnosticCode, pName);
+    const { summary, action } = getSummaryAndAction(diag.diagnosticCode, pName, provider);
     return {
         diagnosticCode: diag.diagnosticCode,
         errorDetail: diag.errorDetail,

package/dist/version.js

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