quotacap 0.0.40 → 0.0.41

package/dist/cli/advise.js

@@ -82,6 +82,7 @@ export function registerAdviseCommand(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/clients.d.ts

@@ -3,6 +3,7 @@ import type { ServiceClient } from "../runtime/client.js";
 import type { CatalogFetcher } from "../catalog/index.js";
 import type { SleepFn } from "./takeover.js";
 import type { UpdateCache } from "../runtime/updates.js";
+import type { PhaseFn } from "./progress.js";
 export interface CreateClientOptions {
     port: number;
     token?: string;
@@ -24,8 +25,11 @@ export interface ClientCommandDeps {
         sleep?: SleepFn;
         timeoutMs?: number;
         readToken?: () => string | undefined;
+        phase?: PhaseFn;
+        json?: boolean;
     };
     checkUpdates?: () => Promise<UpdateCache | null>;
     catalogFetchers?: Record<string, CatalogFetcher>;
+    phase?: PhaseFn;
 }
 export declare function registerClientCommands(program: Command, deps?: ClientCommandDeps): void;

package/dist/cli/models.js

@@ -6,6 +6,7 @@ import { providerIdentity } from "../advisory/provider-names.js";
 import { readToken } from "../runtime/token.js";
 import { createServiceClient } from "../runtime/client.js";
 import { OFFLINE_LABEL } from "./snapshot-source.js";
+import { phase } from "./progress.js";
 function projectModels(catalogs, quotaMap, providerNames) {
     const out = [];
     for (const [id, catalog] of catalogs) {
@@ -70,6 +71,9 @@ export function registerModelsCommand(program, deps = {}) {
         });
         let body;
         try {
+            if (o.refresh) {
+                (deps.phase ?? phase)("refreshing model catalogs…", { json: !!o.json });
+            }
             const url = o.refresh
                 ? (o.provider ? `/api/models/refresh?provider=${encodeURIComponent(o.provider)}` : "/api/models/refresh")
                 : (o.provider ? `/api/models?provider=${encodeURIComponent(o.provider)}` : "/api/models");

package/dist/cli/progress.d.ts

@@ -0,0 +1,32 @@
+export interface ProgressOptions {
+    /** Suppress output when machine-readable JSON is requested. */
+    json?: boolean;
+    /** Explicitly silence progress (e.g. quiet mode). */
+    quiet?: boolean;
+    /** Whether the output stream is interactive. Defaults to process.stderr.isTTY. */
+    isTTY?: boolean;
+    /** Custom writer for stderr (defaults to console.error). */
+    stderr?: (message: string) => void;
+}
+export type PhaseFn = (message: string, opts?: ProgressOptions) => void;
+/**
+ * Format a progress phase string ensuring consistent trailing ellipsis without duplication.
+ */
+export declare function formatPhase(message: string): string;
+/**
+ * Determine whether progress messages should be printed given the options.
+ */
+export declare function shouldEmitProgress(opts?: ProgressOptions): boolean;
+/**
+ * Emit a progress phase message strictly to stderr if interactive and non-json.
+ */
+export declare function phase(message: string, opts?: ProgressOptions): void;
+/**
+ * Await work, calling emit only if it is still pending after graceMs, so an
+ * already-settled fast path stays silent.
+ */
+export declare function phaseIfSlow<T>(work: Promise<T>, emit: () => void, graceMs?: number): Promise<T>;
+/**
+ * Create a phase reporter with pre-bound default options.
+ */
+export declare function createPhase(baseOpts?: ProgressOptions): (message: string, overrideOpts?: ProgressOptions) => void;

package/dist/cli/progress.js

@@ -0,0 +1,70 @@
+// Shared progress helper for multi-second CLI operations.
+// Strictly writes to stderr with a consistent lowercase phrasing ending in '…'.
+// Automatically suppressed under --json, quiet mode, and non-interactive (non-TTY) runs.
+/**
+ * Format a progress phase string ensuring consistent trailing ellipsis without duplication.
+ */
+export function formatPhase(message) {
+    const trimmed = message.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.endsWith("...")) {
+        return `${trimmed.slice(0, -3)}…`;
+    }
+    if (trimmed.endsWith("…")) {
+        return trimmed;
+    }
+    return `${trimmed}…`;
+}
+/**
+ * Determine whether progress messages should be printed given the options.
+ */
+export function shouldEmitProgress(opts = {}) {
+    if (opts.json || opts.quiet)
+        return false;
+    if (opts.isTTY !== undefined)
+        return Boolean(opts.isTTY);
+    return Boolean(process.stderr.isTTY);
+}
+/**
+ * Emit a progress phase message strictly to stderr if interactive and non-json.
+ */
+export function phase(message, opts = {}) {
+    const formatted = formatPhase(message);
+    if (!formatted)
+        return;
+    if (!shouldEmitProgress(opts))
+        return;
+    const write = opts.stderr ?? console.error;
+    write(formatted);
+}
+/**
+ * Await work, calling emit only if it is still pending after graceMs, so an
+ * already-settled fast path stays silent.
+ */
+export async function phaseIfSlow(work, emit, graceMs = 250) {
+    let timer;
+    const slow = new Promise((r) => {
+        timer = setTimeout(() => r("slow"), graceMs);
+    });
+    try {
+        const first = await Promise.race([
+            work.then(() => "done", () => "done"),
+            slow,
+        ]);
+        if (first === "slow")
+            emit();
+        return await work;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Create a phase reporter with pre-bound default options.
+ */
+export function createPhase(baseOpts = {}) {
+    return (message, overrideOpts = {}) => {
+        phase(message, { ...baseOpts, ...overrideOpts });
+    };
+}

package/dist/cli/runtime.d.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 import { startService, type StartServiceOptions } from "../runtime/service.js";
 import { type ServiceClient } from "../runtime/client.js";
 import { type SleepFn } from "./takeover.js";
+import { type PhaseFn } from "./progress.js";
 export type StartServiceFn = (opts?: StartServiceOptions) => ReturnType<typeof startService>;
 export type OpenBrowserFn = (url: string) => Promise<void> | void;
 export type ExecServiceFn = (args: string[], opts?: Record<string, any>) => Promise<number>;
@@ -20,10 +21,13 @@ export interface RuntimeCommandDeps {
         sleep?: SleepFn;
         timeoutMs?: number;
         readToken?: () => string | undefined;
+        phase?: PhaseFn;
+        json?: boolean;
     };
     checkUpdates?: () => Promise<unknown>;
     isInstalled?: () => Promise<boolean>;
     serviceSupported?: () => boolean;
+    phase?: PhaseFn;
 }
 export interface WebLaunchOptions {
     port?: string;
@@ -38,5 +42,6 @@ export declare function waitForInitialPoll(port: number, opts?: {
     }) => any;
     sleep?: SleepFn;
     timeoutMs?: number;
+    phase?: PhaseFn;
 }): Promise<void>;
 export declare function registerRuntimeCommands(program: Command, deps?: RuntimeCommandDeps): void;

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" };
     }
@@ -252,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" };
@@ -356,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 {
@@ -428,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 {
@@ -436,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.`,
@@ -495,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/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`);

package/dist/version.js

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

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

@@ -3,12 +3,17 @@ import type { ProviderView } from "../state.js";
 export interface Repair {
     text: string;
 }
+/** Dashboard wording for a server auth action. The button on this page is Retry. */
+export declare function authInstruction(name: string, attempt: {
+    summary?: string | null;
+    action?: string | null;
+} | null | undefined): string;
 /**
- * Repair routing per excluded provider. Auth failures point at signing into
- * the provider CLI (by default QuotaCap never reads credentials; the only
- * exception is OpenCode Go, which the user enables explicitly); every other
- * exclusion points at a re-poll. Service start/install is covered by the
- * service-unavailable panel when the daemon itself is down.
+ * Repair routing per excluded provider. Auth failures use the server's
+ * summary and action, with Retry in place of the dashboard Refresh control.
+ * OpenCode Go names its own login command. Every other exclusion points at
+ * a re-poll. Service start/install is covered by the service-unavailable
+ * panel when the daemon itself is down.
  */
 export declare function repairFor(provider: ProviderView): Repair;
 export declare function FaultBanner({ providers, onRepoll, repolling, polling, }: {