quotacap 0.0.42 → 0.0.43

package/dist/adapters/claude.js

@@ -1,4 +1,5 @@
 import { trackedExecFile } from "../runtime/spawn.js";
+import { attachEvidence } from "../diagnostics/failure.js";
 import { parseResetText } from "./parse.js";
 export function parseClaudeUsage(result, now = new Date()) {
     const sessionMatch = result.match(/Current session:\s+(\d+)%\s+used/i);
@@ -26,9 +27,19 @@ export const claudeAdapter = {
         // --strict-mcp-config: a usage read needs no MCP servers. Without it every
         // poll boots the user's servers under the daemon's PATH, and their failures
         // are cached and hide those servers from the user's own sessions.
-        const { stdout } = await trackedExecFile("claude", bin, ["-p", "/usage", "--output-format", "json", "--strict-mcp-config"], { timeout: 8000 });
-        const parsed = JSON.parse(stdout);
-        const result = parsed.result ?? stdout;
-        return parseClaudeUsage(result);
+        // 15s matches the registry gate (ADAPTER_TIMEOUTS): cold starts measured
+        // 2-4.4s wall, and seven concurrent polls contend for the same CPU.
+        const { stdout } = await trackedExecFile("claude", bin, ["-p", "/usage", "--output-format", "json", "--strict-mcp-config"], { timeout: 15000 });
+        try {
+            const parsed = JSON.parse(stdout);
+            const result = parsed.result ?? stdout;
+            return parseClaudeUsage(result);
+        }
+        catch (e) {
+            // Side-channel only: the output a parse throw would discard, for
+            // failure bundles. The message is untouched.
+            attachEvidence(e, { source: "exec", stdout });
+            throw e;
+        }
     }
 };

package/dist/adapters/codex.d.ts

@@ -1,5 +1,6 @@
+import { type GridDims } from "./vt.js";
 import type { ParsedQuota } from "./types.js";
-export declare function parseCodexTui(text: string, now?: Date): ParsedQuota;
+export declare function parseCodexTui(text: string, now?: Date, dims?: Partial<GridDims>): ParsedQuota;
 export declare const codexAdapter: {
     id: string;
     requiresAuth: string;

package/dist/adapters/codex.js

@@ -1,6 +1,8 @@
 import os from "node:os";
-import { runPty, stripAnsi } from "./pty.js";
+import { runPty } from "./pty.js";
+import { parseScreens } from "./vt.js";
 import { adapterSignal } from "../runtime/spawn.js";
+import { attachEvidence } from "../diagnostics/failure.js";
 const MONTHS = {
     jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5,
     jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
@@ -59,8 +61,10 @@ function parseFiveReset(raw, now) {
     }
     return dt.toISOString();
 }
-export function parseCodexTui(text, now = new Date()) {
-    const cleaned = stripAnsi(text);
+export function parseCodexTui(text, now = new Date(), dims) {
+    return parseScreens(text, dims, (cleaned) => parseCodexCleaned(cleaned, now));
+}
+function parseCodexCleaned(cleaned, now) {
     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.");
     }
@@ -106,14 +110,13 @@ export function parseCodexTui(text, now = new Date()) {
     let estimated = false;
     if (weeklyRaw) {
         weeklyIso = parseWeeklyReset(weeklyRaw, now);
-        if (!weeklyIso)
-            throw new Error(`codex: bad weekly reset "${weeklyRaw}"`);
     }
     if (fiveRaw) {
         fiveIso = parseFiveReset(fiveRaw, now);
-        if (!fiveIso)
-            throw new Error(`codex: bad 5h reset "${fiveRaw}"`);
     }
+    // Degrade, don't fail (grok precedent): the percents are the critical
+    // fields; a garbled or reworded timestamp degrades to an estimate instead
+    // of failing the provider.
     if (!weeklyIso) {
         weeklyIso = new Date(now.getTime() + 7 * 86400000).toISOString();
         estimated = true;
@@ -168,6 +171,14 @@ export const codexAdapter = {
             signal: adapterSignal("codex"),
             label: "codex",
         });
-        return parseCodexTui(transcript);
+        try {
+            return parseCodexTui(transcript);
+        }
+        catch (e) {
+            // Side-channel only: the transcript a parse throw would discard, for
+            // failure bundles. The message is untouched.
+            attachEvidence(e, { source: "pty", stdout: transcript });
+            throw e;
+        }
     },
 };

package/dist/adapters/goldens.d.ts

@@ -0,0 +1,4 @@
+export declare const GOLDEN_CLI_VERSIONS: Record<string, string[]>;
+export declare function goldenFixtureDir(provider: string, version: string): string;
+/** Substring match: "grok 1.0.41 (4220f3b…)" covers "1.0.41". */
+export declare function isGoldenCovered(provider: string, cliVersion: string | null | undefined): boolean;

package/dist/adapters/goldens.js

@@ -0,0 +1,20 @@
+// Golden CLI-version coverage: every entry has a redacted real transcript at
+// tests/fixtures/golden/<provider>-<version>/transcript.txt plus expected.json,
+// exercised by tests/adapters/goldens.test.ts. When a vendor CLI updates,
+// capture its usage output, redact identifiers, add the fixture, and extend
+// the list. Failure bundles record whether the failing CLI was covered, so
+// an uncovered version is the first suspect when parsing breaks.
+export const GOLDEN_CLI_VERSIONS = {
+    claude: ["2.1.283"],
+    codex: ["0.157.1"],
+    grok: ["1.0.41"],
+};
+export function goldenFixtureDir(provider, version) {
+    return `${provider}-${version}`;
+}
+/** Substring match: "grok 1.0.41 (4220f3b…)" covers "1.0.41". */
+export function isGoldenCovered(provider, cliVersion) {
+    if (!cliVersion)
+        return false;
+    return (GOLDEN_CLI_VERSIONS[provider] ?? []).some((v) => cliVersion.includes(v));
+}

package/dist/adapters/grok.d.ts

@@ -1,5 +1,6 @@
+import { type GridDims } from "./vt.js";
 import type { ParsedQuota } from "./types.js";
-export declare function parseGrokTui(text: string, now?: Date): ParsedQuota;
+export declare function parseGrokTui(text: string, now?: Date, dims?: Partial<GridDims>): ParsedQuota;
 export declare const grokAdapter: {
     id: string;
     requiresAuth: string;

package/dist/adapters/grok.js

@@ -1,6 +1,8 @@
 import os from "node:os";
-import { runPty, stripAnsi } from "./pty.js";
+import { runPty } from "./pty.js";
+import { parseScreens } from "./vt.js";
 import { adapterSignal } from "../runtime/spawn.js";
+import { attachEvidence } from "../diagnostics/failure.js";
 const FULL_MONTHS = {
     january: 0, february: 1, march: 2, april: 3, may: 4, june: 5,
     july: 6, august: 7, september: 8, october: 9, november: 10, december: 11,
@@ -10,7 +12,10 @@ const ABBR_MONTHS = {
     jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
 };
 function parseGrokReset(raw, now) {
-    const m = raw.trim().match(/^([A-Za-z]+)\s+(\d{1,2}),\s*(\d{1,2}):(\d{2})$/);
+    // The month/day gap is optional: cursor repositioning can drop it
+    // ("Resets: October5, 10:22", observed 2026-09-28). Letters-meets-digits
+    // keeps the boundary unambiguous.
+    const m = raw.trim().match(/^([A-Za-z]+)\s*(\d{1,2}),\s*(\d{1,2}):(\d{2})$/);
     if (!m)
         return null;
     const monStr = m[1].toLowerCase();
@@ -38,8 +43,10 @@ function parseGrokReset(raw, now) {
 function validPct(v) {
     return Number.isFinite(v) && v >= 0 && v <= 100;
 }
-export function parseGrokTui(text, now = new Date()) {
-    const cleaned = stripAnsi(text);
+export function parseGrokTui(text, now = new Date(), dims) {
+    return parseScreens(text, dims, (cleaned) => parseGrokCleaned(cleaned, now));
+}
+function parseGrokCleaned(cleaned, now) {
     // The TUI writes "Weekly lim", repositions the cursor, then writes
     // "t (Tier)", so after ANSI stripping the header reads "Weekly limt".
     // The [i!l] class stays optional to keep tolerating past glitch variants.
@@ -111,7 +118,7 @@ export function parseGrokTui(text, now = new Date()) {
         if (Number.isFinite(v) && v >= 0)
             creditsUsd = v;
     }
-    const resetRe = /Resets:\s*([A-Za-z]+\s+\d+,\s*\d+:\d+)/gi;
+    const resetRe = /Resets:\s*([A-Za-z]+\s*\d+,\s*\d+:\d+)/gi;
     let resetsRaw = null;
     for (const m of cleaned.matchAll(resetRe))
         resetsRaw = m[1].trim();
@@ -119,13 +126,12 @@ export function parseGrokTui(text, now = new Date()) {
     let estimated = false;
     if (resetsRaw) {
         resetsAt = parseGrokReset(resetsRaw, now);
-        if (!resetsAt)
-            throw new Error(`grok: bad resets timestamp "${resetsRaw}"`);
-    }
-    else if (cleaned.match(/Resets:/i)) {
-        throw new Error("grok: bad resets timestamp");
     }
-    else {
+    if (!resetsAt) {
+        // Degrade, don't fail: the weekly percent is the critical field, and a
+        // garbled or reworded timestamp must not fail the provider. The estimate
+        // flag keeps advisory and scheduler honest (estimated resets are never
+        // used for pre-reset scheduling).
         resetsAt = new Date(now.getTime() + 7 * 86400000).toISOString();
         estimated = true;
     }
@@ -164,6 +170,14 @@ export const grokAdapter = {
             signal: adapterSignal("grok"),
             label: "grok",
         });
-        return parseGrokTui(transcript);
+        try {
+            return parseGrokTui(transcript);
+        }
+        catch (e) {
+            // Side-channel only: the transcript a parse throw would discard, for
+            // failure bundles. The message is untouched.
+            attachEvidence(e, { source: "pty", stdout: transcript });
+            throw e;
+        }
     },
 };

package/dist/adapters/index.d.ts

@@ -1,21 +1,35 @@
 import type { Adapter } from "./types.js";
 export declare const adapters: Record<string, Adapter>;
+export declare const ADAPTER_TIMEOUTS: Record<string, number>;
 export interface PollAllOptions {
     timeouts?: Record<string, number>;
+    /** Max concurrent adapter polls. Default 3: seven heavy CLI/TUI spawns at
+     * once starve each other into timeouts. */
+    maxConcurrency?: number;
+    /** Attempts per adapter including the first. Default 2 (one retry).
+     * 1 disables retry. */
+    maxAttempts?: number;
+    /** Delay between attempts. Default 1000. */
+    retryDelayMs?: number;
+    /** When aborted, in-flight attempts run out but no retry is started. */
+    signal?: AbortSignal;
 }
+/** Order-preserving concurrency-limited map. */
+export declare function mapWithConcurrency<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+export declare function isRetryableChildFailure(reason: unknown): boolean;
 export declare function pollAll(enabled: string[], opts?: PollAllOptions): Promise<({
+    provider: string;
+    status: "skipped";
+    reason: Error;
+    value?: undefined;
+} | {
     provider: string;
     status: "fulfilled";
     value: unknown;
     reason?: undefined;
-} | {
-    value?: undefined;
-    provider: string;
-    status: "skipped";
-    reason: any;
 } | {
     value?: undefined;
     provider: string;
     status: "rejected";
-    reason: any;
+    reason: unknown;
 })[]>;

package/dist/adapters/index.js

@@ -7,6 +7,7 @@ import { agyAdapter } from "./agy.js";
 import { museAdapter } from "./muse.js";
 import { opencodeGoAdapter } from "./opencode-go.js";
 import { installAdapterSignal, clearAdapterSignal } from "../runtime/spawn.js";
+import { classifyFailure } from "../diagnostics/failure.js";
 export const adapters = {
     claude: claudeAdapter,
     manual: manualAdapter,
@@ -17,8 +18,11 @@ export const adapters = {
     muse: museAdapter,
     "opencode-go": opencodeGoAdapter,
 };
-const ADAPTER_TIMEOUTS = {
-    claude: 8000,
+// Kept in sync with the per-adapter spawn/PTY timeouts: claude.ts exec 15s,
+// codex/grok/kimi/muse runPty timeouts match their entries here. The gate is
+// the outer bound; the inner spawn timeout should fire first.
+export const ADAPTER_TIMEOUTS = {
+    claude: 15000,
     codex: 12000,
     kimi: 8000,
     grok: 14000,
@@ -26,47 +30,102 @@ const ADAPTER_TIMEOUTS = {
     muse: 90000,
     "opencode-go": 8000,
 };
-export async function pollAll(enabled, opts) {
-    const rawJobs = enabled.map(id => {
-        const a = adapters[id];
-        if (!a)
-            return Promise.reject(new Error(`unknown adapter ${id}`));
-        // manual adapter has no poll capability — skip without degraded
-        if (id === "manual")
-            return Promise.reject(new Error("manual skipped"));
-        const timeout = opts?.timeouts?.[id] ?? ADAPTER_TIMEOUTS[id] ?? 8000;
-        // One controller per adapter: a timeout aborts only that adapter's
-        // children; the signal clears when its job settles.
-        const controller = new AbortController();
-        installAdapterSignal(id, controller.signal);
-        let p;
-        try {
-            p = Promise.resolve(a.poll());
-        }
-        catch (e) {
-            clearAdapterSignal(id);
-            throw e;
+/** Order-preserving concurrency-limited map. */
+export async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const workers = new Array(Math.min(Math.max(1, limit), items.length))
+        .fill(null)
+        .map(async () => {
+        while (next < items.length) {
+            const i = next++;
+            results[i] = await fn(items[i], i);
         }
-        const gated = new Promise((resolve, reject) => {
+    });
+    await Promise.all(workers);
+    return results;
+}
+// A child that ran and produced a diagnosable output problem is worth one
+// more attempt; a login wall, missing binary, trust prompt, or rate limit
+// will not clear in a second, and a mid-flight child death (killAll,
+// crash) must never respawn — especially during shutdown.
+const RETRYABLE_CODES = new Set(["parse_error", "network", "service_unavailable"]);
+export function isRetryableChildFailure(reason) {
+    return RETRYABLE_CODES.has(classifyFailure("Provider", reason).diagnosticCode);
+}
+async function pollOnceWithGate(id, adapter, timeout) {
+    // One controller per attempt: a timeout aborts only that attempt's
+    // children; the signal clears when the attempt settles.
+    const controller = new AbortController();
+    installAdapterSignal(id, controller.signal);
+    let p;
+    try {
+        p = Promise.resolve(adapter.poll());
+    }
+    catch (e) {
+        clearAdapterSignal(id);
+        return { ok: false, reason: e, timedOut: false };
+    }
+    // Identity-tagged: only this exact instance means our gate fired, never a
+    // child error that happens to mention timeouts.
+    const gateError = new Error(`timeout after ${timeout}ms`);
+    try {
+        const value = await new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 try {
                     controller.abort();
                 }
                 catch { }
-                reject(new Error(`timeout after ${timeout}ms`));
+                reject(gateError);
             }, timeout);
-            p.then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
+            p.then((v) => {
+                clearTimeout(timer);
+                resolve(v);
+            }, (e) => {
+                clearTimeout(timer);
+                reject(e);
+            });
         });
-        return gated.finally(() => clearAdapterSignal(id));
-    });
-    const settled = await Promise.allSettled(rawJobs);
-    return settled.map((s, i) => {
-        const id = enabled[i];
-        if (s.status === "fulfilled")
-            return { provider: id, status: "fulfilled", value: s.value };
-        const msg = String(s.reason?.message ?? s.reason);
-        if (msg.includes("manual skipped"))
-            return { provider: id, status: "skipped", reason: s.reason };
-        return { provider: id, status: "rejected", reason: s.reason };
-    });
+        return { ok: true, value, timedOut: false };
+    }
+    catch (e) {
+        return { ok: false, reason: e, timedOut: e === gateError };
+    }
+    finally {
+        clearAdapterSignal(id);
+    }
+}
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function pollAll(enabled, opts) {
+    const maxConcurrency = opts?.maxConcurrency ?? 3;
+    const maxAttempts = Math.max(1, opts?.maxAttempts ?? 2);
+    const retryDelayMs = Math.max(0, opts?.retryDelayMs ?? 1000);
+    const runOne = async (id) => {
+        const a = adapters[id];
+        if (!a)
+            return { provider: id, status: "rejected", reason: new Error(`unknown adapter ${id}`) };
+        // manual adapter has no poll capability — skip without degraded
+        if (id === "manual")
+            return { provider: id, status: "skipped", reason: new Error("manual skipped") };
+        const timeout = opts?.timeouts?.[id] ?? ADAPTER_TIMEOUTS[id] ?? 8000;
+        let lastReason = new Error(`${id}: poll produced no result`);
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            if (attempt > 1 && opts?.signal?.aborted)
+                break;
+            const outcome = await pollOnceWithGate(id, a, timeout);
+            if (outcome.ok)
+                return { provider: id, status: "fulfilled", value: outcome.value };
+            lastReason = outcome.reason;
+            if (attempt >= maxAttempts || opts?.signal?.aborted)
+                break;
+            // Our own gate firing means transient slowness: always retry. A child
+            // failure retries only for output problems, never for deaths.
+            const retry = outcome.timedOut || isRetryableChildFailure(outcome.reason);
+            if (!retry)
+                break;
+            await delay(retryDelayMs);
+        }
+        return { provider: id, status: "rejected", reason: lastReason };
+    };
+    return mapWithConcurrency(enabled, maxConcurrency, runOne);
 }

package/dist/adapters/kimi.d.ts

@@ -1,6 +1,7 @@
+import { type GridDims } from "./vt.js";
 import type { ParsedQuota } from "./types.js";
 export declare function kimiProbeDir(): string;
-export declare function parseKimiTui(text: string, now?: Date): ParsedQuota;
+export declare function parseKimiTui(text: string, now?: Date, dims?: Partial<GridDims>): ParsedQuota;
 export declare function parseKimiApiUsage(usagesBody: unknown, meBody?: unknown, now?: Date): ParsedQuota;
 export interface KimiStoredCreds {
     access_token?: string;

package/dist/adapters/kimi.js

@@ -2,8 +2,10 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parseResetText } from "./parse.js";
-import { runPty, stripAnsi } from "./pty.js";
+import { runPty } from "./pty.js";
+import { parseScreens } from "./vt.js";
 import { adapterSignal } from "../runtime/spawn.js";
+import { attachEvidence } from "../diagnostics/failure.js";
 const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
 const DEFAULT_OAUTH_HOST = "https://auth.kimi.ai";
 const DEFAULT_BASE_URL = "https://api.kimi.ai/coding/v1";
@@ -11,8 +13,10 @@ const POLL_TIMEOUT_MS = 8000;
 export function kimiProbeDir() {
     return path.join(process.env.QUOTACAP_HOME ?? os.homedir(), ".quotacap", "kimi-probe");
 }
-export function parseKimiTui(text, now = new Date()) {
-    const cleaned = stripAnsi(text);
+export function parseKimiTui(text, now = new Date(), dims) {
+    return parseScreens(text, dims, (cleaned) => parseKimiCleaned(cleaned, now));
+}
+function parseKimiCleaned(cleaned, now) {
     const weeklyRe = /Weekly limit\s+[^0-9]*(\d+)%\s+used\s+resets\s+(in\s+[^\n│\r]+)/i;
     const fiveRe = /5h limit\s+[^0-9]*(\d+)%\s+used\s+resets\s+(in\s+[^\n│\r]+)/i;
     const w = cleaned.match(weeklyRe);
@@ -20,10 +24,8 @@ export function parseKimiTui(text, now = new Date()) {
         throw new Error("kimi: weekly limit not found in TUI output");
     const f = cleaned.match(fiveRe);
     let sessionPct = null;
-    let fiveRaw = null;
     if (f) {
         sessionPct = parseInt(f[1], 10);
-        fiveRaw = f[2].trim();
     }
     else {
         const fallback = cleaned.match(/5h limit[^\d%]*(\d+)%\s+used/i);
@@ -38,13 +40,13 @@ export function parseKimiTui(text, now = new Date()) {
     if (!Number.isFinite(sessionPct) || sessionPct < 0 || sessionPct > 100)
         throw new Error("kimi: bad 5h pct");
     const weeklyRaw = w[2].trim();
-    const weeklyIso = parseResetText(`resets ${weeklyRaw}`, now);
-    if (!weeklyIso)
-        throw new Error(`kimi: bad weekly reset "${weeklyRaw}"`);
-    if (fiveRaw) {
-        const fiveIso = parseResetText(`resets ${fiveRaw}`, now);
-        if (!fiveIso)
-            throw new Error(`kimi: bad 5h reset "${fiveRaw}"`);
+    // Degrade, don't fail (grok precedent): the percents are the critical
+    // fields; an unparseable timestamp degrades to an estimate.
+    let weeklyIso = parseResetText(`resets ${weeklyRaw}`, now);
+    let estimated = false;
+    if (!weeklyIso) {
+        weeklyIso = new Date(now.getTime() + 7 * 86400000).toISOString();
+        estimated = true;
     }
     let plan = "unknown";
     const paren = cleaned.match(/Weekly limit\s*\(([^)]+)\)/i);
@@ -88,6 +90,7 @@ export function parseKimiTui(text, now = new Date()) {
         periodStart,
         source: "tui",
         fetchedAt: now.toISOString(),
+        resetsAtEstimated: estimated || undefined,
         raw: cleaned.slice(0, 4096),
         ...monthlyFields,
     };
@@ -497,7 +500,15 @@ export async function pollKimiPty() {
         signal: adapterSignal("kimi"),
         label: "kimi",
     });
-    return parseKimiTui(transcript);
+    try {
+        return parseKimiTui(transcript, new Date(), { cols: 140, rows: 35 });
+    }
+    catch (e) {
+        // Side-channel only: the transcript a parse throw would discard, for
+        // failure bundles. The message is untouched.
+        attachEvidence(e, { source: "pty", stdout: transcript });
+        throw e;
+    }
 }
 export const kimiAdapter = {
     id: "kimi",

package/dist/adapters/muse.d.ts

@@ -1,3 +1,4 @@
+import { type GridDims } from "./vt.js";
 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. */
@@ -28,7 +29,7 @@ export interface RecoveryDeps {
  */
 export declare function recoverSubscription(deps: RecoveryDeps): Promise<ParsedQuota>;
 export declare function museProbeDir(): string;
-export declare function parseMuseTui(text: string, now?: Date): ParsedQuota;
+export declare function parseMuseTui(text: string, now?: Date, dims?: Partial<GridDims>): ParsedQuota;
 export declare const museAdapter: {
     id: string;
     requiresAuth: string;

package/dist/adapters/muse.js

@@ -2,8 +2,10 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parseResetText } from "./parse.js";
-import { runPty, stripAnsi } from "./pty.js";
+import { runPty } from "./pty.js";
+import { parseScreens } from "./vt.js";
 import { adapterSignal, trackedExecFile } from "../runtime/spawn.js";
+import { attachEvidence } from "../diagnostics/failure.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";
@@ -74,10 +76,13 @@ export async function recoverSubscription(deps) {
 export function museProbeDir() {
     return path.join(process.env.QUOTACAP_HOME ?? os.homedir(), ".quotacap", "muse-probe");
 }
-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);
+export function parseMuseTui(text, now = new Date(), dims) {
+    return parseScreens(text, dims, (cleaned) => parseMuseCleaned(cleaned, now));
+}
+// Input is either the rendered screen (visual rows) or the byte soup (one
+// glued line): no pattern here may anchor on ^ or $, and row-spanning
+// matches must allow newlines.
+function parseMuseCleaned(cleaned, now) {
     if (/currently unavailable|subscriptions aren't currently available|subscription_unavailable/i.test(cleaned)) {
         throw new Error(MUSE_UNAVAILABLE_MESSAGE);
     }
@@ -102,15 +107,16 @@ export function parseMuseTui(text, now = new Date()) {
         plan = planMatch[1].trim();
     // The Current-window reset ("Resets at 3:51 PM") is a bare clock time with
     // no date, and Quota has no session-reset field — discarded, as claude and
-    // kimi already do. A missing or unparseable Weekly reset throws rather than
-    // estimating: an invented reset would feed the advisory a false deadline.
-    const resetMatch = cleaned.match(/Weekly[^\n]*?Resets\s+([A-Za-z]{3}\s+\d{1,2}\s+at\s+\d{1,2}:\d{2}\s*[AP]M)/i);
-    if (!resetMatch)
-        throw new Error("muse: bad weekly reset");
-    const resetRaw = resetMatch[1].trim();
-    const resetsAt = parseResetText(`resets ${resetRaw}`, now);
-    if (!resetsAt)
-        throw new Error(`muse: bad weekly reset "${resetRaw}"`);
+    // kimi already do. A missing or unparseable Weekly reset degrades to an
+    // estimate (grok precedent): the percents are the critical fields, and the
+    // estimate flag keeps advisory and scheduler honest.
+    const resetMatch = cleaned.match(/Weekly[\s\S]{0,400}?Resets\s+([A-Za-z]{3}\s+\d{1,2}\s+at\s+\d{1,2}:\d{2}\s*[AP]M)/i);
+    let resetsAt = resetMatch ? parseResetText(`resets ${resetMatch[1].trim()}`, now) : null;
+    let estimated = false;
+    if (!resetsAt) {
+        resetsAt = new Date(now.getTime() + 7 * 86400000).toISOString();
+        estimated = true;
+    }
     const periodStart = new Date(new Date(resetsAt).getTime() - 7 * 86400000).toISOString();
     return {
         provider: "muse",
@@ -121,6 +127,7 @@ export function parseMuseTui(text, now = new Date()) {
         periodStart,
         source: "tui",
         fetchedAt: now.toISOString(),
+        resetsAtEstimated: estimated || undefined,
         raw: cleaned.slice(0, 4096),
     };
 }
@@ -157,7 +164,15 @@ async function usagePass(timeoutMs = USAGE_TIMEOUT_MS) {
         signal: adapterSignal("muse"),
         label: "muse",
     });
-    return parseMuseTui(transcript);
+    try {
+        return parseMuseTui(transcript);
+    }
+    catch (e) {
+        // Side-channel only: the transcript a parse throw would discard, for
+        // failure bundles. The message is untouched.
+        attachEvidence(e, { source: "pty", stdout: transcript });
+        throw e;
+    }
 }
 export const museAdapter = {
     id: "muse",

package/dist/adapters/pty.d.ts

@@ -22,6 +22,13 @@ export interface PtyRunOptions {
      */
     submitInput?: string;
     submitAfterMs?: number;
+    /**
+     * Grace delay after the completion pattern first matches, before the
+     * child is killed. Usage dialogs paint asynchronously (header first,
+     * timestamp later); without this the kill can land mid-paint. Bounded
+     * and fixed (not quiescence-detected: spinners never settle). Default 400.
+     */
+    completionSettleMs?: number;
     /**
      * Opt-in terminal-query responder: answers DSR, DA1 and OSC 4/10/11
      * capability queries the child emits. Off by default; TUIs that never