quotacap 0.0.39 → 0.0.41

package/dist/cli/runtime.js

@@ -8,6 +8,7 @@ import { createServiceClient, ServiceError, ServiceUnavailable, } from "../runti
 import { isServiceInstalled, isServiceManaged, runServiceCommand, serviceSupported, } from "../service/index.js";
 import { detectChannel, refreshUpdateCache } from "../runtime/updates.js";
 import { checkSkew, execSkewWarning, formatWedged, olderCliWarning, takeoverManaged, takeoverUnmanaged, upgradedMessage, waitForHealthy, WedgedError, } from "./takeover.js";
+import { phase } from "./progress.js";
 // Shared `web` launcher handler: the `web` command and the bare `quotacap`
 // invocation both run this. Decision order: healthy daemons open (with the
 // skew matrix), registered-but-down services start, and only the last resort
@@ -28,7 +29,8 @@ export async function launchWeb(o, deps = {}) {
     const isManaged = deps.isManaged ?? isServiceManaged;
     const isInstalled = deps.isInstalled ?? isServiceInstalled;
     const supported = deps.serviceSupported ?? serviceSupported;
-    const takeoverOpts = deps.takeoverOpts ?? {};
+    const phaseFn = deps.phase ?? phase;
+    const takeoverOpts = { phase: phaseFn, ...deps.takeoverOpts };
     const checkUpdates = deps.checkUpdates ??
         (() => refreshUpdateCache({ channel: detectChannel(), current: VERSION }));
     const sleep = takeoverOpts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
@@ -56,7 +58,7 @@ export async function launchWeb(o, deps = {}) {
         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 waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
             }
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
@@ -64,7 +66,7 @@ export async function launchWeb(o, deps = {}) {
         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 waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
             }
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
@@ -72,7 +74,7 @@ export async function launchWeb(o, deps = {}) {
         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 waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
             }
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
@@ -95,7 +97,7 @@ export async function launchWeb(o, deps = {}) {
                 exit(1);
                 return;
             }
-            await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
+            await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
             await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
             return;
         }
@@ -116,7 +118,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 waitForInitialPoll(started.port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
         await openDashboard(`http://127.0.0.1:${started.port}`, openBrowser);
         return;
     }
@@ -146,16 +148,18 @@ export async function launchWeb(o, deps = {}) {
                 detail = e?.message ?? String(e);
             }
             if (!detail) {
+                phaseFn("waiting for daemon…");
                 const healthy = await waitForHealthy(port, VERSION, {
                     createClient,
                     sleep,
                     timeoutMs: readyTimeoutMs,
+                    phase: phaseFn,
                 });
                 if (!healthy)
                     detail = `not ready within ${Math.round(readyTimeoutMs / 1000)}s`;
             }
             if (!detail) {
-                await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000) });
+                await waitForInitialPoll(port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
                 await openDashboard(`http://127.0.0.1:${port}`, openBrowser);
                 return;
             }
@@ -167,7 +171,7 @@ 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 waitForInitialPoll(started.port, { createClient, sleep, timeoutMs: Math.min(readyTimeoutMs, 5000), phase: phaseFn });
     await openDashboard(`http://127.0.0.1:${started.port}`, openBrowser);
 }
 export async function waitForInitialPoll(port, opts = {}) {
@@ -176,6 +180,7 @@ export async function waitForInitialPoll(port, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 5000;
     const deadline = Date.now() + timeoutMs;
     const client = createClient({ port, timeoutMs: 1000 });
+    let emitted = false;
     while (Date.now() < deadline) {
         await sleep(250);
         try {
@@ -183,6 +188,10 @@ export async function waitForInitialPoll(port, opts = {}) {
             if (!h?.ok || h?.polling !== "in-progress" || h?.lastCompletedPollAt) {
                 return;
             }
+            if (!emitted) {
+                (opts.phase ?? phase)("waiting for first readings…");
+                emitted = true;
+            }
         }
         catch {
             return;
@@ -254,6 +263,7 @@ export function registerRuntimeCommands(program, deps) {
         serviceSupported: supported,
         takeoverOpts,
         checkUpdates,
+        phase: deps?.phase,
     }));
     const service = program
         .command("service")

package/dist/cli/status.js

@@ -74,6 +74,7 @@ export function registerStatusCommand(program, deps) {
                             createClient,
                             execService,
                             ...takeoverOpts,
+                            json: !!o.json || takeoverOpts.json,
                         });
                         console.error(r.message);
                         // The takeover verified the daemon now reports the CLI version;

package/dist/cli/takeover.d.ts

@@ -1,6 +1,7 @@
 import { type ServiceClient } from "../runtime/client.js";
 import { type ClaimInfo } from "../runtime/owner.js";
 import { isServiceManaged } from "../service/index.js";
+import { type PhaseFn } from "./progress.js";
 export type SkewKind = "match" | "exec-only" | "cli-newer" | "cli-older";
 export interface HealthView {
     ok?: unknown;
@@ -37,6 +38,8 @@ export interface WaitOpts {
     createClient?: CreateTakeoverClient;
     sleep?: SleepFn;
     timeoutMs?: number;
+    phase?: PhaseFn;
+    json?: boolean;
 }
 export declare function waitForHealthy(port: number, expectedVersion: string, opts?: WaitOpts): Promise<any | null>;
 export declare function waitForRelease(port: number, dataDir?: string, opts?: WaitOpts): Promise<boolean>;

package/dist/cli/takeover.js

@@ -9,6 +9,7 @@ import { createServiceClient, ServiceError, ServiceUnavailable, } from "../runti
 import { readToken } from "../runtime/token.js";
 import { readClaim } from "../runtime/owner.js";
 import { runServiceCommand, isServiceManaged } from "../service/index.js";
+import { phase } from "./progress.js";
 export { parseVersion, compareVersions } from "../runtime/versions.js";
 import { compareVersions, parseVersion } from "../runtime/versions.js";
 export function checkSkew(health, cliVersion = VERSION, cliExec = process.execPath) {
@@ -69,6 +70,7 @@ export function formatWedged(opts) {
         `stop the process listening on port ${port} in its own terminal and retry`);
 }
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const silentPhase = () => { };
 // Poll /health until it reports the expected version (or the deadline).
 export async function waitForHealthy(port, expectedVersion, opts = {}) {
     const createClient = opts.createClient ?? createServiceClient;
@@ -119,7 +121,10 @@ export async function takeoverManaged(opts) {
         : "unknown";
     const execService = opts.execService ?? ((args, o) => runServiceCommand(args, o ?? {}, {}));
     const verb = opts.refreshRegistration ? "install" : "restart";
-    const code = await execService([verb], opts.refreshRegistration ? { version: cliVersion, quiet: true } : undefined);
+    (opts.phase ?? phase)("waiting for daemon…", { json: opts.json });
+    // The line above already reports this wait, so the nested restart stays
+    // silent instead of repeating it past the caller's --json suppression.
+    const code = await execService([verb], opts.refreshRegistration ? { version: cliVersion, quiet: true } : { phase: silentPhase });
     if (code !== 0) {
         throw new TakeoverError(`daemon upgrade failed: service ${verb} exited ${code}`);
     }
@@ -144,6 +149,7 @@ export async function takeoverUnmanaged(opts) {
     if (!token) {
         throw new WedgedError(formatWedged({ claim: readClaim(dataDir), port, managed: false }));
     }
+    (opts.phase ?? phase)("waiting for daemon to stop…", { json: opts.json });
     const createClient = opts.createClient ?? createServiceClient;
     const client = createClient({ port, token, timeoutMs: 5000 });
     try {

package/dist/cli/update.d.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 import { type ServiceClient } from "../runtime/client.js";
 import { type ChannelEnv } from "../runtime/updates.js";
 import { type SleepFn } from "./takeover.js";
+import { type PhaseFn } from "./progress.js";
 export interface UpdateJson {
     channel: string;
     current: string;
@@ -28,9 +29,12 @@ export interface UpdateCommandDeps {
         sleep?: SleepFn;
         timeoutMs?: number;
         readToken?: () => string | undefined;
+        phase?: PhaseFn;
+        json?: boolean;
     };
     spawnNpm?: (args: string[]) => Promise<number>;
     extractTar?: (tarball: string, destDir: string) => void;
+    phase?: PhaseFn;
 }
 export declare function stoppedDaemonMessage(oldVersion: string, newVersion: string): string;
 export interface PostUpdateTakeoverOpts {

package/dist/cli/update.js

@@ -7,6 +7,7 @@ import { compareVersions } from "../runtime/versions.js";
 import { detectChannel, resolveLatestVersionDetailed, updateNpm, updateStandalone, writeUpdateCache, } from "../runtime/updates.js";
 import { isServiceManaged, runServiceCommand } from "../service/index.js";
 import { checkSkew, formatWedged, olderCliWarning, takeoverManaged, takeoverUnmanaged, WedgedError, } from "./takeover.js";
+import { phase } from "./progress.js";
 export function stoppedDaemonMessage(oldVersion, newVersion) {
     return (`Stopped old daemon (${oldVersion}); no background service is registered. ` +
         `Run 'quotacap web' to start ${newVersion}, or 'quotacap service install' to run it in the background.`);
@@ -190,6 +191,10 @@ export function registerUpdateCommand(program, deps) {
         const pin = typeof o.to === "string" && o.to ? stripV(o.to) : null;
         let latest = null;
         let rateLimited = null;
+        const phaseFn = deps?.phase ?? phase;
+        if (!o.check && !pin) {
+            phaseFn("resolving latest version…", { json: asJson });
+        }
         try {
             const resolved = await resolveLatestVersionDetailed({ fetchFn });
             if (resolved.status === "ok")
@@ -298,9 +303,10 @@ export function registerUpdateCommand(program, deps) {
             createClient: deps?.createClient,
             isManaged: deps?.isManaged,
             execService: deps?.execService,
-            takeoverOpts: deps?.takeoverOpts,
+            takeoverOpts: { phase: phaseFn, json: asJson, ...deps?.takeoverOpts },
         };
         if (channel === "standalone") {
+            phaseFn(`downloading ${target}…`, { json: asJson });
             const swap = await updateStandalone({
                 target,
                 execPath,
@@ -356,6 +362,7 @@ export function registerUpdateCommand(program, deps) {
         }
         // npm global.
         const npmSpec = pin ?? "latest";
+        phaseFn(`updating npm package…`, { json: asJson });
         const npm = await updateNpm({
             target: npmSpec,
             execPath,

package/dist/diagnostics/failure.js

@@ -40,14 +40,25 @@ function stripAnsiAndControls(s) {
         .replace(/[\r\n\t]+/g, " ");
 }
 const UNRECOGNIZED_OMITTED = "Unrecognized diagnostic text omitted";
+// Vendor account-confirmation wording. The sentence is safe to recognize.
+// The browser link that follows it can carry a sign-in token, so the link is never stored.
+// "account is not eligible" is the Antigravity sentence; a bare "not eligible" is not.
+// The hyphen covers "Sign-in with". "signed in with" does not match.
+const ACCOUNT_CONFIRMATION = /\b(?:account is not eligible|verify your account|eligibility check failed|device code|sign(?:ing)?[ -]in with)\b/i;
 function matchPrecedence(evidence, errorName, errorCode, text) {
-    // Order 1: timeout — Structured AbortError or an explicit QuotaCap abort/timeout checkpoint
-    const isAbort = errorName === "AbortError" ||
-        errorCode === "ABORT_ERR" ||
-        evidence?.checkpoint === "abort" ||
-        evidence?.checkpoint === "ready timeout" ||
-        evidence?.checkpoint === "completion timeout" ||
-        /\bpty aborted\b/i.test(text);
+    // Order 1: timeout — Structured AbortError or an explicit QuotaCap abort/timeout checkpoint.
+    // A ready or completion timeout whose transcript is an account-confirmation
+    // screen falls through, so the sign-in sentence can win later. An explicit
+    // abort stays a timeout even if that screen is in the transcript.
+    const signInTimeout = ACCOUNT_CONFIRMATION.test(text) &&
+        (evidence?.checkpoint === "ready timeout" || evidence?.checkpoint === "completion timeout");
+    const isAbort = !signInTimeout &&
+        (errorName === "AbortError" ||
+            errorCode === "ABORT_ERR" ||
+            evidence?.checkpoint === "abort" ||
+            evidence?.checkpoint === "ready timeout" ||
+            evidence?.checkpoint === "completion timeout" ||
+            /\bpty aborted\b/i.test(text));
     if (isAbort) {
         return { code: "timeout", phrase: "timed out" };
     }
@@ -232,6 +243,15 @@ function matchPrecedence(evidence, errorName, errorCode, text) {
     if (/\bbad rolling pct\b/i.test(text)) {
         return { code: "parse_error", phrase: "bad rolling pct" };
     }
+    if (/\bbad monthly pct\b/i.test(text)) {
+        return { code: "parse_error", phrase: "bad monthly pct" };
+    }
+    if (/\bbad monthly reset\b/i.test(text)) {
+        return { code: "parse_error", phrase: "bad monthly reset" };
+    }
+    if (/\bunknown monthly status\b/i.test(text)) {
+        return { code: "parse_error", phrase: "unknown monthly status" };
+    }
     if (/\busage status not ok\b/i.test(text)) {
         return { code: "parse_error", phrase: "usage status not ok" };
     }
@@ -243,6 +263,13 @@ function matchPrecedence(evidence, errorName, errorCode, text) {
     if (/\blimits refresh requested\b/i.test(text) || /\brefresh requested\b/i.test(text)) {
         return { code: "service_unavailable", phrase: "limits refresh requested" };
     }
+    // Account confirmation is after network, parse, and service-unavailable.
+    // A sign-in menu line must not hide a harder failure. It is before the
+    // text timeout match so a completion timeout sitting on that screen still
+    // classifies as auth.
+    if (ACCOUNT_CONFIRMATION.test(text)) {
+        return { code: "auth", phrase: "account confirmation required" };
+    }
     // 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" };
@@ -347,14 +374,16 @@ export function diagnosticError(reason, evidence) {
         if (parsed.durationMs !== undefined)
             durationMs = parsed.durationMs;
     }
-    // Filter stdout to avoid matching non-error screen text (like login menus)
+    // Keep error lines and account-confirmation lines. Other PTY screen text
+    // stays out so a spinner or model list cannot change the classification.
     let safeStdoutText = "";
     if (evidence?.stdout) {
         if (evidence.source === "pty") {
             const lines = evidence.stdout.split(/[\r\n]+/);
             const matchedLines = lines.filter((l) => /\b(error|failed|failure|fatal|unauthorized|unauthorised|denied|forbidden|panic|exception)\b/i.test(l) ||
                 /\btrust\b/i.test(l) ||
-                /\b(stdin is not a terminal|device not configured|not a tty|inappropriate ioctl|node-pty)\b/i.test(l));
+                /\b(stdin is not a terminal|device not configured|not a tty|inappropriate ioctl|node-pty)\b/i.test(l) ||
+                ACCOUNT_CONFIRMATION.test(l));
             safeStdoutText = matchedLines.join(" ");
         }
         else {
@@ -419,7 +448,7 @@ function mapCategory(code) {
             return "unknown";
     }
 }
-function getSummaryAndAction(code, providerName, provider) {
+function getSummaryAndAction(code, providerName, provider, errorDetail) {
     switch (code) {
         case "terminal_error":
             return {
@@ -427,6 +456,12 @@ function getSummaryAndAction(code, providerName, provider) {
                 action: `Open ${providerName} directly in your terminal to check whether it starts. If it works there, inspect the QuotaCap service log and report the adapter failure. Refresh in the dashboard retries through the same service.`,
             };
         case "auth":
+            if (/\baccount confirmation required\b/i.test(errorDetail)) {
+                return {
+                    summary: `${providerName} needs you to confirm the subscription account`,
+                    action: `Open ${providerName}, complete the browser sign-in it shows, then select Refresh in the QuotaCap dashboard.`,
+                };
+            }
             return {
                 summary: `${providerName} login required`,
                 action: `Open ${providerName} and follow its sign-in instructions. Then select Refresh in the QuotaCap dashboard.`,
@@ -486,7 +521,7 @@ export function classifyFailure(provider, reason) {
     }
     const category = mapCategory(diag.diagnosticCode);
     const pName = formatProviderName(provider);
-    const { summary, action } = getSummaryAndAction(diag.diagnosticCode, pName, provider);
+    const { summary, action } = getSummaryAndAction(diag.diagnosticCode, pName, provider, diag.errorDetail);
     return {
         diagnosticCode: diag.diagnosticCode,
         errorDetail: diag.errorDetail,

package/dist/format/rows.d.ts

@@ -1,5 +1,5 @@
 import type { ProviderSnapshot } from "../advisory/types.js";
-export type StateWord = "On track" | "Behind pace" | "Ahead of pace" | "Cap risk" | "Watch" | "Measuring" | "Not reporting";
+export type StateWord = "On track" | "Behind pace" | "Ahead of pace" | "Cap risk" | "Watch" | "Measuring" | "Not reporting" | "Monthly exhausted";
 export type RailCell = "used" | "tick" | "unused";
 export type SortKey = "recommended" | "reset-asc" | "reset-desc" | "used-desc" | "used-asc";
 export type CompactSuffix = "" | "!" | "~" | "?";
@@ -16,7 +16,12 @@ export interface Row {
 }
 export declare const RAIL_CELLS = 20;
 export declare const SORT_KEYS: SortKey[];
+export declare function weeklyPctOf(q: {
+    weeklyPct?: number;
+    usedPct?: number;
+} | null | undefined): number | undefined;
 export declare function fmtDuration(ms: number): string;
+export declare function weekdayOf(iso: string | undefined): string;
 export declare function countdownText(ps: ProviderSnapshot, now: Date): string;
 export declare function elapsedPct(ps: ProviderSnapshot, now: Date): number | null;
 export declare function usedPctOf(ps: ProviderSnapshot): number | null;

package/dist/format/rows.js

@@ -9,6 +9,11 @@ function msOf(iso) {
     const ms = new Date(iso).getTime();
     return Number.isNaN(ms) ? null : ms;
 }
+// The CLI talks HTTP to a daemon that may predate the rename, which sent only
+// `usedPct`. Read both for one release; drop the fallback with the aliases.
+export function weeklyPctOf(q) {
+    return q?.weeklyPct ?? q?.usedPct;
+}
 // Compact duration: 7d / 12h / 45m. Countdown convention floors; sub-minute
 // spans read 1m so a live window never prints 0m.
 export function fmtDuration(ms) {
@@ -18,6 +23,12 @@ export function fmtDuration(ms) {
         return `${Math.floor(ms / HOUR_MS)}h`;
     return `${Math.max(1, Math.floor(ms / MIN_MS))}m`;
 }
+// Short weekday of an ISO instant in the locked English copy, e.g. "Tue".
+// Pinned to en-US: the sentence it feeds ("unused until Tue") is English, so
+// a non-English machine must not print a localized weekday inside it.
+export function weekdayOf(iso) {
+    return new Date(iso ?? "").toLocaleDateString("en-US", { weekday: "short" });
+}
 export function countdownText(ps, now) {
     const resetsMs = msOf(ps.quota?.resetsAt);
     let text;
@@ -40,14 +51,14 @@ export function elapsedPct(ps, now) {
     return Math.round(Math.min(100, Math.max(0, pct)));
 }
 export function usedPctOf(ps) {
-    const u = ps.quota?.usedPct;
+    const u = weeklyPctOf(ps.quota);
     return typeof u === "number" && Number.isFinite(u) ? Math.round(u) : null;
 }
 export function railCells(ps, now) {
     const cells = new Array(RAIL_CELLS).fill("unused");
     if (ps.exclusionReason !== null)
         return cells;
-    const u = ps.quota?.usedPct;
+    const u = weeklyPctOf(ps.quota);
     const used = typeof u === "number" && Number.isFinite(u)
         ? Math.min(RAIL_CELLS, Math.max(0, Math.round((u / 100) * RAIL_CELLS)))
         : 0;
@@ -70,6 +81,10 @@ export function stateWord(ps) {
     const adv = ps.advisory;
     if (!adv)
         return "Not reporting";
+    // A blocked month outranks every weekly verdict: weekly leftover cannot be
+    // spent until the month resets.
+    if (adv.bindingWindow === "monthly" && adv.bindingRemaining === 0)
+        return "Monthly exhausted";
     if (adv.status === "at risk")
         return "Cap risk";
     if (adv.status === "watch")
@@ -124,7 +139,13 @@ export function forecastText(ps, now) {
     if (!adv)
         return "no readings yet";
     let text;
-    if (adv.remaining <= 0) {
+    if (adv.bindingWindow === "monthly" && adv.bindingRemaining <= 0) {
+        text = `unused until ${weekdayOf(ps.quota?.monthlyResetsAt)}`;
+    }
+    else if (adv.bindingWindow === "monthly") {
+        text = `${Math.round(adv.bindingRemaining)}% of month left`;
+    }
+    else if (adv.remaining <= 0) {
         text = "Exhausted";
     }
     else if (adv.paceSource === "unknown" || adv.burnRate === null) {
@@ -179,7 +200,7 @@ function wasteOf(p) {
     return typeof w === "number" && Number.isFinite(w) ? w : null;
 }
 function finiteUsed(p) {
-    const u = p.quota?.usedPct;
+    const u = weeklyPctOf(p.quota);
     return typeof u === "number" && Number.isFinite(u) ? u : null;
 }
 export function sortProviders(providers, key, use) {
@@ -192,6 +213,8 @@ export function sortProviders(providers, key, use) {
                     return 0;
                 if (p.exclusionReason !== null)
                     return 2;
+                if (p.advisory?.bindingWindow === "monthly" && p.advisory.bindingRemaining === 0)
+                    return 2;
                 return 1;
             };
             indexed.sort((a, b) => {

package/dist/format/terminal.js

@@ -1,4 +1,4 @@
-import { buildRow, compactSuffix, sortProviders, } from "./rows.js";
+import { buildRow, compactSuffix, sortProviders, weeklyPctOf, } from "./rows.js";
 const GAP = "  ";
 const MIN_PROV_WIDTH = 12;
 const MAX_PROV_WIDTH = 22;
@@ -32,6 +32,7 @@ const STATE_COLORS = {
     "Cap risk": "\x1b[31m",
     "Measuring": "\x1b[90m",
     "Not reporting": "\x1b[90m",
+    "Monthly exhausted": "\x1b[31m",
 };
 // provWidth covers the 2-char prefix plus name, measured before ANSI.
 export function provWidthFor(ids) {
@@ -92,7 +93,7 @@ export function renderWide(snapshot, opts) {
         "PACE (%/DAY)".padEnd(paceWidth),
         "USED VS TIME".padEnd(20),
         "RESETS".padEnd(9),
-        "STATE".padEnd(15),
+        "STATE".padEnd(19),
         "FORECAST",
     ].join(GAP);
     const lines = rows.map(({ p, row }) => {
@@ -103,7 +104,7 @@ export function renderWide(snapshot, opts) {
         const pace = (opts.ascii ? asciiText(row.pace) : row.pace).padEnd(paceWidth);
         const rail = renderRail(row.railCells, g, row.state, color);
         const countdown = (opts.ascii ? asciiText(row.countdown) : row.countdown).padEnd(9);
-        const state = row.state.padEnd(15);
+        const state = row.state.padEnd(19);
         const forecast = opts.ascii ? asciiText(row.forecast) : row.forecast;
         const main = [
             color ? colorProviderField(name, recommended, row.state) : name,
@@ -158,7 +159,7 @@ export function renderCompact(snapshot, _now) {
     const entries = sorted
         .filter((p) => p.quota !== null)
         .map((p) => {
-        const u = p.quota?.usedPct;
+        const u = weeklyPctOf(p.quota);
         const used = typeof u === "number" && Number.isFinite(u) ? String(Math.round(u)) : "?";
         return `[${p.id}:${used}%${compactSuffix(p)}]`;
     });

package/dist/http/server.js

@@ -220,7 +220,7 @@ export function buildApp(ctx) {
         for (const [id, catalog] of catalogs) {
             const identity = providerIdentity(id, ctx.providerNames);
             const quota = quotaMap.get(id);
-            const leftoverPct = quota?.usedPct != null ? Math.round((100 - quota.usedPct) * 10) / 10 : null;
+            const leftoverPct = quota?.weeklyPct != null ? Math.round((100 - quota.weeklyPct) * 10) / 10 : null;
             out.push({
                 id,
                 displayName: identity.displayName,
@@ -452,8 +452,8 @@ export function buildApp(ctx) {
             upsertQuota(ctx.db, {
                 provider: parsed.provider,
                 plan: parsed.plan,
-                usedPct: parsed.usedPct,
-                sessionPct: parsed.sessionPct,
+                weeklyPct: parsed.weeklyPct,
+                fiveHourPct: parsed.fiveHourPct,
                 resetsAt: parsed.resetsAt,
                 periodStart: parsed.periodStart,
                 source: "manual",

package/dist/runtime/poll.js

@@ -138,7 +138,7 @@ export function createCoordinator(opts) {
                     success: true,
                     failureCategory: null,
                 });
-                const usedPct = row.value?.usedPct;
+                const usedPct = row.value?.weeklyPct;
                 const pctSuffix = typeof usedPct === "number" && Number.isFinite(usedPct)
                     ? ` (${usedPct}% used)`
                     : "";

package/dist/service/index.js

@@ -94,7 +94,9 @@ export async function runServiceCommand(args, opts = {}, deps = {}) {
                 await backend.stop(deps);
                 break;
             case "restart":
-                await backend.restart(deps);
+                // Internal: a takeover passes its own phase reporter so the nested
+                // restart honours the calling command's progress suppression.
+                await backend.restart({ ...deps, phase: opts.phase ?? deps.phase });
                 break;
             case "status":
                 await backend.status(deps, { json: !!opts.json });

package/dist/service/macos.d.ts

@@ -1,3 +1,4 @@
+import { type PhaseFn } from "../cli/progress.js";
 export declare const SERVICE_LABEL = "quotacap";
 export declare const PROVIDER_BINS: string[];
 export declare function serviceSupported(platform?: string): boolean;
@@ -22,6 +23,7 @@ export interface ServiceDeps {
     bootstrapTimeoutMs?: number;
     version?: string;
     quiet?: boolean;
+    phase?: PhaseFn;
 }
 export declare function foregroundGuidance(verb: string, platform: string): string;
 export declare function defaultRunLaunchctl(args: string[]): string;

package/dist/service/macos.js

@@ -9,6 +9,7 @@ import { VERSION } from "../version.js";
 import { getDbPath, readServiceMetadata, writeServiceMetadata, } from "../config.js";
 import { ensureConfig, readConfig } from "../config.js";
 import { createServiceClient } from "../runtime/client.js";
+import { phase, phaseIfSlow } from "../cli/progress.js";
 export const SERVICE_LABEL = "quotacap";
 export const PROVIDER_BINS = ["claude", "codex", "kimi", "grok", "agy", "muse"];
 export function serviceSupported(platform = process.platform) {
@@ -428,7 +429,8 @@ export async function start(deps = {}) {
     run(["enable", `gui/${uid}/${SERVICE_LABEL}`]);
     const waitReady = deps.waitReady ?? defaultWaitReady;
     const cfg = await readConfig();
-    const ready = await waitReady(cfg.port);
+    // An already-loaded, ready job answers at once; report only a real wait.
+    const ready = await phaseIfSlow(waitReady(cfg.port), () => (deps.phase ?? phase)("waiting for daemon…", { quiet: deps.quiet }));
     if (!ready) {
         throw new Error(`service did not become ready on port ${cfg.port}; check ${path.join(dataDir, "logs", "service.log")}`);
     }
@@ -445,6 +447,7 @@ export async function restart(deps = {}) {
     // process for the port and start() fails its readiness check.
     // deps.port keeps tests off the real daemon's port.
     const port = deps.port ?? (await readConfig()).port;
+    (deps.phase ?? phase)("waiting for daemon to stop…", { quiet: deps.quiet });
     const waitReleased = deps.waitReleased ?? defaultWaitReleased;
     if (!(await waitReleased(port))) {
         (deps.print ?? console.log)(`port ${port} is still in use after stopping; starting anyway`);

package/dist/service/systemd.d.ts

@@ -1,3 +1,4 @@
+import { type PhaseFn } from "../cli/progress.js";
 import { defaultWhich, type ServiceStatus } from "./macos.js";
 export declare const SERVICE_UNIT = "quotacap.service";
 export declare function serviceSupported(platform?: string): boolean;
@@ -19,6 +20,7 @@ export interface SystemdDeps {
     now?: () => Date;
     version?: string;
     quiet?: boolean;
+    phase?: PhaseFn;
 }
 export declare function formatSystemctlError(args: string[], detail: string): Error;
 export declare function defaultRunSystemctl(args: string[]): string;

package/dist/service/systemd.js

@@ -8,9 +8,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { VERSION } from "../version.js";
-import { getDbPath, readServiceMetadata, writeServiceMetadata, } from "../config.js";
-import { ensureConfig, readConfig } from "../config.js";
+import { getDbPath, readServiceMetadata, writeServiceMetadata, ensureConfig, readConfig, } from "../config.js";
 import { createServiceClient } from "../runtime/client.js";
+import { phase, phaseIfSlow } from "../cli/progress.js";
 import { SERVICE_LABEL, PROVIDER_BINS, buildChildPath, defaultWaitReady, defaultWaitReleased, defaultWhich, formatMissingProviders, formatStatus, foregroundGuidance, resolveProviderPaths, resolveServiceExec, } from "./macos.js";
 export const SERVICE_UNIT = `${SERVICE_LABEL}.service`;
 export function serviceSupported(platform = process.platform) {
@@ -241,7 +241,8 @@ export async function start(deps = {}) {
     }
     const { dataDir, print, run } = resolved(deps);
     run(["enable", "--now", SERVICE_UNIT]);
-    const port = await waitForReady(deps, dataDir);
+    // An already-active, ready unit answers at once; report only a real wait.
+    const port = await phaseIfSlow(waitForReady(deps, dataDir), () => (deps.phase ?? phase)("waiting for daemon…", { quiet: deps.quiet }));
     print(`service started and ready on port ${port}`);
 }
 export async function restart(deps = {}) {
@@ -254,6 +255,7 @@ export async function restart(deps = {}) {
     // systemctl stop can return before the port is released; same race as launchd.
     // deps.port mirrors start(): tests must never probe the real daemon's port.
     const port = deps.port ?? (await readConfig()).port;
+    (deps.phase ?? phase)("waiting for daemon to stop…", { quiet: deps.quiet });
     const waitReleased = deps.waitReleased ?? defaultWaitReleased;
     if (!(await waitReleased(port))) {
         (deps.print ?? console.log)(`port ${port} is still in use after stopping; starting anyway`);