quotacap 0.0.40 → 0.0.42

package/dist/adapters/opencode-go.js

@@ -8,7 +8,14 @@ import path from "node:path";
 import { adapterSignal } from "../runtime/spawn.js";
 const USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
 const POLL_TIMEOUT_MS = 8000;
-export const OPENCODE_GO_CONSENT_NOTICE = "QuotaCap will read the API key OpenCode already stored when you ran `opencode auth login -p opencode-go` (`~/.local/share/opencode/auth.json`, `opencode-go` → `opencode` fallback). It is read in-memory, read-only once per poll (every 15 minutes by default). It is sent only as `Authorization: Bearer` to `https://opencode.ai/zen/go/v1/usage` to fetch `rolling/weekly/monthly` `percent` + `resetsAt`. It is never used to make chat or model requests, never written or rotated, never stored in the `quotacap` DB, never returned by the API or MCP, and never logged (errors show `[redacted]`). Revoke at `https://opencode.ai/auth` or `opencode providers logout opencode-go` and run `quotacap providers disable opencode-go` to stop polling. If you prefer no file access, set `OPENCODE_API_KEY` instead.";
+export const OPENCODE_GO_CONSENT_NOTICE = [
+    "• What is read: API key OpenCode already stored when you ran `opencode auth login -p opencode-go` (`~/.local/share/opencode/auth.json`, `opencode-go` → `opencode` fallback).",
+    "• Read frequency: in-memory, read-only once per poll (every 15 minutes by default).",
+    "• Request destination: sent only as `Authorization: Bearer` to `https://opencode.ai/zen/go/v1/usage` to fetch `rolling/weekly/monthly` `percent` + `resetsAt`.",
+    "• Never-list: never used to make chat or model requests, never written or rotated, never stored in the `quotacap` DB, never returned by the API or MCP, and never logged (errors show `[redacted]`).",
+    "• Revocation instructions: revoke at `https://opencode.ai/auth` or `opencode providers logout opencode-go` and run `quotacap providers disable opencode-go` to stop polling.",
+    "• Optional environment override: if you prefer no file access, set `OPENCODE_API_KEY` instead.",
+].join("\n");
 export function openCodeGoAuthPath() {
     return path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
 }

package/dist/adapters/pty.d.ts

@@ -29,6 +29,15 @@ export interface PtyRunOptions {
      */
     respondToQueries?: boolean;
     completionRegex?: RegExp;
+    /**
+     * Optional initial prompt responder before readyRegex matches.
+     * If matched against the cleaned transcript during the pre-ready poll loop,
+     * sends `reply` once to dismiss or answer the prompt (e.g. workspace trust in a probe directory).
+     */
+    preReadyResponse?: {
+        match: RegExp;
+        reply: string;
+    };
     /** If matched, abort immediately with a clear error (e.g. trust prompts). */
     abortOn?: RegExp;
     timeoutMs: number;

package/dist/adapters/pty.js

@@ -329,6 +329,7 @@ async function runPtyBun(opts) {
         if (opts.readyRegex) {
             const deadline = Date.now() + readyTimeoutMs;
             let matched = false;
+            let preReadySent = false;
             while (Date.now() < deadline) {
                 checkCap();
                 checkAborted();
@@ -341,6 +342,13 @@ async function runPtyBun(opts) {
                     });
                 }
                 const clean = stripAnsi(transcript);
+                if (opts.preReadyResponse && !preReadySent && regexTest(opts.preReadyResponse.match, clean)) {
+                    preReadySent = true;
+                    try {
+                        proc.terminal.write(opts.preReadyResponse.reply);
+                    }
+                    catch { }
+                }
                 checkAbort(clean);
                 if (regexTest(opts.readyRegex, clean)) {
                     matched = true;
@@ -633,6 +641,7 @@ async function runPtyNode(opts) {
         if (opts.readyRegex) {
             const deadline = Date.now() + readyTimeoutMs;
             let matched = false;
+            let preReadySent = false;
             while (Date.now() < deadline) {
                 checkCap();
                 checkAborted();
@@ -645,6 +654,13 @@ async function runPtyNode(opts) {
                     });
                 }
                 const clean = stripAnsi(transcript);
+                if (opts.preReadyResponse && !preReadySent && regexTest(opts.preReadyResponse.match, clean)) {
+                    preReadySent = true;
+                    try {
+                        ptyProcess.write(opts.preReadyResponse.reply);
+                    }
+                    catch { }
+                }
                 checkAbort(clean);
                 if (regexTest(opts.readyRegex, clean)) {
                     matched = true;

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/providers.js

@@ -248,7 +248,8 @@ export function registerProvidersCommand(program, deps = {}) {
                 return;
             }
         }
-        console.log(`enabled ${id} — restart quotacap daemon to apply`);
+        console.log(`enabled ${id}`);
+        console.log("Next: run quotacap service restart to start polling");
     });
     providers
         .command("disable <id>")

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/config.d.ts

@@ -1,35 +1,17 @@
 import { z } from "zod";
 export declare function getConfigPath(p?: string): string;
 export declare function getDbPath(p?: string): string;
-export declare const ProviderDisplayNameSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const ProviderDisplayNameSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
 declare const ConfigSchema: z.ZodObject<{
     port: z.ZodDefault<z.ZodNumber>;
     pollMinutes: z.ZodDefault<z.ZodNumber>;
     catalogTtlHours: z.ZodDefault<z.ZodNumber>;
-    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    knownProviders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    providerNames: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>>;
+    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    knownProviders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    providerNames: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
     opencodeGoConsentAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     experimentalIngest: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    port: number;
-    pollMinutes: number;
-    catalogTtlHours: number;
-    enabledProviders: string[];
-    knownProviders: string[];
-    providerNames: Record<string, string>;
-    opencodeGoConsentAt: string | null;
-    experimentalIngest?: boolean | undefined;
-}, {
-    port?: number | undefined;
-    pollMinutes?: number | undefined;
-    catalogTtlHours?: number | undefined;
-    enabledProviders?: string[] | undefined;
-    knownProviders?: string[] | undefined;
-    providerNames?: Record<string, string> | undefined;
-    opencodeGoConsentAt?: string | null | undefined;
-    experimentalIngest?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type Config = z.infer<typeof ConfigSchema>;
 /**
  * Manual ingest (CLI `ingest`, POST /api/ingest) is off unless this returns

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,