muonroi-cli 1.7.2 → 1.8.0

package/dist/src/product-loop/discovery-interview.js

@@ -21,6 +21,21 @@ export async function iterateInterview(opts) {
     // not web) are deferred unless the user explicitly re-runs with more context.
     const specificity = computePromptSpecificity(opts.idea);
     const skipOptionalForMinimal = specificity === "minimal";
+    // G2-b: for a minimal OR well-specified ("detailed") prompt the recommender's
+    // primary is high-confidence — minimal picks smallest-scope defaults, detailed
+    // respects the stated context. In both cases surfacing a card for EVERY
+    // required question (productType/targetPlatform/audience/…) is over-asking the
+    // user already complained about: they accept by reflex. Instead auto-accept
+    // the recommender primary for required questions and surface ONE summary card
+    // (the user gate) listing the assumptions so the user can proceed or adjust.
+    // "moderate" prompts keep the per-question cards (genuinely ambiguous). Escape
+    // hatch: MUONROI_DISCOVERY_AUTOFILL=0 restores per-question cards everywhere.
+    const autoFillRequired = (specificity === "minimal" || specificity === "detailed") && process.env.MUONROI_DISCOVERY_AUTOFILL !== "0";
+    const assumed = [];
+    // G1 follow-up: keep the recommendation behind each auto-filled assumption so
+    // the user-gate "edit: <field>" path can re-render the SAME per-question card
+    // (Recommended + alternatives) without a second recommender LLM call.
+    const assumedRec = new Map();
     // Build the repo brief ONCE per interview run for existing projects. The
     // brief replaces the Muonroi vendor preamble inside leader prompts so
     // rationales must cite real files, deps, and scripts. Skipped for greenfield —
@@ -74,12 +89,33 @@ export async function iterateInterview(opts) {
         else {
             recommendation = await opts.recommender.leaderRecommend(recInput);
         }
+        // G2-b: auto-accept the recommender primary for required questions on a
+        // minimal/well-specified prompt — no per-question card. Validated (+ FE
+        // policy) so a malformed recommendation falls back to the normal card flow.
+        // The assumed answers are surfaced together on the single user-gate card.
+        let autoAccepted = false;
+        if (autoFillRequired && effectivelyRequired && recommendation.primary?.value != null) {
+            const v = recommendation.primary.value;
+            const validation = validateAnswer(question.id, v);
+            const feLib = question.id === "frontendApproach" ? v?.library : undefined;
+            const fePolicyOk = !feLib || isFePolicyAccepted(feLib);
+            if (validation.ok && fePolicyOk) {
+                await recordRecommendation(flowDir, runId, question.id, toEntry(recommendation), recommendation.costUsd);
+                await saveDiscoveryAnswer(flowDir, runId, question.id, v);
+                assumed.push({ id: question.id, value: v });
+                assumedRec.set(question.id, recommendation);
+                autoAccepted = true;
+                // Fall through to the post-answer user-gate check below (skip the card).
+            }
+        }
         // Per-question skip-attempt counter for required questions.
         // Resets when the user provides a real answer (accept/override).
         let skipAttempts = 0;
         const MAX_SKIP_ATTEMPTS = 3;
         const _debugInterview = process.env.MUONROI_DEBUG_LEADER === "1";
-        for (;;) {
+        // When auto-accepted above, the card loop body is skipped entirely (the
+        // for-condition is false on entry) and we go straight to the gate check.
+        for (; !autoAccepted;) {
             const _iterStart = Date.now();
             if (_debugInterview) {
                 process.stderr.write(`[interview-timing] iter-start: ${JSON.stringify({ questionId: question.id, skipAttempts })}\n`);
@@ -176,14 +212,32 @@ export async function iterateInterview(opts) {
         if (refreshed &&
             allRequiredAnswered(refreshed.questionsAnswered, refreshedPlatforms) &&
             !refreshed.userGatePassed) {
-            const gate = await opts.userPrompt({ questionId: "__user_gate__" });
-            if (gate.action === "proceed") {
-                await markUserGatePassed(flowDir, runId);
+            // Gate loop: "proceed" exits the whole interview, "abort" throws,
+            // "edit-field" re-asks one assumed answer then RE-shows the gate (so the
+            // user can revise several before proceeding), "ask-more" falls through to
+            // keep iterating optional questions.
+            let proceeded = false;
+            for (;;) {
+                const gate = await opts.userPrompt({
+                    questionId: "__user_gate__",
+                    assumptions: assumed.length > 0 ? assumed : undefined,
+                });
+                if (gate.action === "proceed") {
+                    await markUserGatePassed(flowDir, runId);
+                    proceeded = true;
+                    break;
+                }
+                if (gate.action === "abort")
+                    throw new Error("discovery aborted at user gate");
+                if (gate.action === "edit-field") {
+                    await reAskAssumedField(opts, flowDir, runId, gate.fieldId, assumed, assumedRec.get(gate.fieldId));
+                    continue; // re-render the gate with the updated assumption
+                }
+                // ask-more: stop gating, continue iterating optional questions
                 break;
             }
-            if (gate.action === "abort")
-                throw new Error("discovery aborted at user gate");
-            // ask-more: continue iterating optional questions
+            if (proceeded)
+                break;
         }
     }
     const finalState = await readDiscoveryState(flowDir, runId);
@@ -197,6 +251,66 @@ export async function iterateInterview(opts) {
     await markDone(flowDir, runId);
     return ctx;
 }
+/**
+ * G1 follow-up: re-ask ONE auto-filled assumption from the user gate. Renders
+ * the same per-question card (Recommended + alternatives) as the normal flow by
+ * reusing the stored recommendation, validates (+ FE policy), persists the new
+ * answer, and updates the in-memory `assumed` list so the re-rendered gate shows
+ * the revised value. "skip" cancels the edit (keeps the current assumption);
+ * "abort" aborts the whole interview, consistent with the per-question card.
+ */
+async function reAskAssumedField(opts, flowDir, runId, fieldId, assumed, recommendation) {
+    const question = DISCOVERY_QUESTIONS.find((q) => q.id === fieldId);
+    if (!question)
+        return; // unknown field id — ignore defensively, keep current value
+    for (;;) {
+        const ans = await opts.userPrompt({ questionId: fieldId, recommendation });
+        if (ans.action === "abort")
+            throw new Error("discovery aborted by user");
+        let chosenValue;
+        if (ans.action === "accept") {
+            if (recommendation?.primary?.value == null)
+                continue; // nothing to accept — re-prompt
+            chosenValue = recommendation.primary.value;
+        }
+        else if (ans.action === "override") {
+            chosenValue = ans.value;
+        }
+        else if (ans.action === "skip") {
+            return; // user backed out of editing this field — keep the existing assumption
+        }
+        else {
+            continue; // more-options / edit-field / proceed / ask-more are no-ops here
+        }
+        const validation = validateAnswer(fieldId, chosenValue);
+        if (!validation.ok) {
+            if (fieldId !== "frontendApproach") {
+                await opts.userPrompt({ questionId: fieldId, message: validation.reason ?? "invalid answer" });
+            }
+            continue;
+        }
+        if (fieldId === "frontendApproach") {
+            const lib = chosenValue?.library;
+            if (lib && !isFePolicyAccepted(lib)) {
+                await opts.userPrompt({
+                    questionId: fieldId,
+                    message: "FE policy: library must be shadcn, radix, headlessui, or none",
+                });
+                continue;
+            }
+        }
+        if (ans.action === "override" && recommendation) {
+            await appendUserOverride(flowDir, runId, fieldId, recommendation.primary.value, chosenValue, ans.reason);
+        }
+        await saveDiscoveryAnswer(flowDir, runId, fieldId, chosenValue);
+        const entry = assumed.find((a) => a.id === fieldId);
+        if (entry)
+            entry.value = chosenValue;
+        else
+            assumed.push({ id: fieldId, value: chosenValue });
+        return;
+    }
+}
 function allRequiredAnswered(answered, platforms) {
     const baseRequired = REQUIRED_QUESTION_IDS.every((id) => answered.includes(id));
     if (!baseRequired)

package/dist/src/product-loop/done-gate.js

@@ -142,9 +142,9 @@ async function runCustomerDebate(ctx) {
     const criteriaText = ctx.criteria
         .map((c) => `- ${c.id}: ${c.status}${c.evidence ? ` (Evidence: ${c.evidence})` : ""}`)
         .join("\n");
-    let conversation = `System: You are in a "Definition of Done" debate. 
-PO's goal: Prove the product is ready to ship.
-Customer's goal: Ensure all requirements are met and it's high quality.
+    let conversation = `System: You are in a "Definition of Done" debate. 
+PO's goal: Prove the product is ready to ship.
+Customer's goal: Ensure all requirements are met and it's high quality.
 Criteria:\n${criteriaText}\n`;
     for (let r = 1; r <= rounds; r++) {
         const poPrompt = `${conversation}\nRound ${r}: PO, explain why this is ready to ship.`;

package/dist/src/product-loop/gather.js

@@ -93,15 +93,29 @@ function buildLiveTuiAsk(emit, respondToQuestion) {
 export function buildGatherUserPrompt(tuiAsk) {
     return async (args) => {
         if (args.questionId === "__user_gate__") {
-            const choice = await tuiAsk("All required questions answered. Proceed to research or ask more?", [
-                "proceed",
-                "ask-more",
-                "abort",
-            ]);
+            // G2-b: when required answers were auto-filled from the recommender
+            // (minimal/well-specified prompt), this single card IS the summary — list
+            // the assumptions so the user reviews them in one place instead of N
+            // sequential per-question cards. "ask-more" lets them revisit/expand.
+            const hasAssumptions = !!args.assumptions && args.assumptions.length > 0;
+            const label = hasAssumptions
+                ? `Assumed from your prompt:\n${args
+                    .assumptions.map((a) => `  • ${a.id} = ${JSON.stringify(a.value)}`)
+                    .join("\n")}\n\nProceed, edit one of the assumptions, or ask more to adjust/expand?`
+                : "All required questions answered. Proceed to research or ask more?";
+            // G1 follow-up: one "edit: <field>" option per auto-filled assumption so a
+            // single wrong default can be revised in place — no abort+reprompt or
+            // MUONROI_DISCOVERY_AUTOFILL=0. The prefix must match the parse below.
+            const EDIT_PREFIX = "edit: ";
+            const editOpts = hasAssumptions ? args.assumptions.map((a) => `${EDIT_PREFIX}${a.id}`) : [];
+            const choice = await tuiAsk(label, ["proceed", ...editOpts, "ask-more", "abort"]);
             if (choice === "proceed")
                 return { action: "proceed" };
             if (choice === "abort")
                 return { action: "abort" };
+            if (choice.startsWith(EDIT_PREFIX)) {
+                return { action: "edit-field", fieldId: choice.slice(EDIT_PREFIX.length) };
+            }
             return { action: "ask-more" };
         }
         if (args.message) {

package/dist/src/product-loop/loop-driver.js

@@ -39,10 +39,10 @@ function wrapLLMForUsageTracking(llm, ctx) {
         }
     };
     return {
-        generate: (modelId, system, prompt, maxTokens, onUsage) => llm.generate(modelId, system, prompt, maxTokens, (u) => {
+        generate: (modelId, system, prompt, maxTokens, onUsage, signal) => llm.generate(modelId, system, prompt, maxTokens, (u) => {
             recorder(modelId)(u);
             onUsage?.(u);
-        }),
+        }, signal),
         debate: (modelId, system, prompt, signal, persistTrace, options, onUsage) => llm.debate(modelId, system, prompt, signal, persistTrace, options, (u) => {
             recorder(modelId)(u);
             onUsage?.(u);
@@ -684,24 +684,24 @@ export async function* runLoopDriver(ctx) {
                     },
                 };
                 // Synthesize ProductSpec
-                const synthesisPrompt = `Synthesize a ProductSpec JSON based on the following:
-Idea: ${ctx.idea}
-Clarified Spec: ${JSON.stringify(clarifiedSpec)}
-Debate Summary: ${debateState.runningSummary}
-Research Findings: ${debateState.researchFindings ?? "N/A"}
-
-Output ONLY a JSON object matching this interface:
-interface ProductSpec {
-  idea: string;
-  persona: string;
-  mvp: string[];
-  phase2: string[];
-  architecture: string;
-  ioContract: string;
-  folderStructure: string;
-  sprintEstimate: number;
-  costEstimate: number;
-}
+                const synthesisPrompt = `Synthesize a ProductSpec JSON based on the following:
+Idea: ${ctx.idea}
+Clarified Spec: ${JSON.stringify(clarifiedSpec)}
+Debate Summary: ${debateState.runningSummary}
+Research Findings: ${debateState.researchFindings ?? "N/A"}
+
+Output ONLY a JSON object matching this interface:
+interface ProductSpec {
+  idea: string;
+  persona: string;
+  mvp: string[];
+  phase2: string[];
+  architecture: string;
+  ioContract: string;
+  folderStructure: string;
+  sprintEstimate: number;
+  costEstimate: number;
+}
 `;
                 // The scoping phase's only LLM call. Wrapped so a provider hang/
                 // timeout leaves a council_error audit row instead of swallowing the

package/dist/src/product-loop/progress-snapshot.js

@@ -20,10 +20,10 @@ function readLatestSprintStage(runId) {
     try {
         const db = getDatabase();
         const row = db
-            .prepare(`SELECT metadata_json, created_at
-         FROM interaction_logs
-         WHERE session_id = ? AND event_type = 'ui_interaction' AND event_subtype = 'sprint_stage'
-         ORDER BY id DESC
+            .prepare(`SELECT metadata_json, created_at
+         FROM interaction_logs
+         WHERE session_id = ? AND event_type = 'ui_interaction' AND event_subtype = 'sprint_stage'
+         ORDER BY id DESC
          LIMIT 1`)
             .get(runId);
         if (!row)

package/dist/src/product-loop/sprint-self-verify.js

@@ -31,10 +31,10 @@ const WATCH_DIRS = ["src/ui/", "src/self-qa/", "src/agent-harness/", "packages/a
 function isEnabled(forceEnable) {
     if (forceEnable === true)
         return true;
-    const v = process.env["MUONROI_SPRINT_SELF_VERIFY"];
+    const v = process.env.MUONROI_SPRINT_SELF_VERIFY;
     if (v === "0" || (v && v.toLowerCase() === "false"))
         return false;
-    if (process.env["CI"] === "true" || process.env["NODE_ENV"] === "ci")
+    if (process.env.CI === "true" || process.env.NODE_ENV === "ci")
         return false;
     // Default: ON. v === "1"/"true" still works; absence of env var also enables.
     return true;

package/dist/src/providers/__tests__/reasoning-roundtrip.test.js

@@ -179,6 +179,18 @@ describe("transformThinkingModeBody — backfill / disable (code 20015 fix)", ()
         expect(asst[0].reasoning_content).toBe("real thought"); // untouched
         expect(asst[1].reasoning_content).toBe(""); // backfilled
     });
+    it("A (default): backfills content: '' on a reasoning-only turn that lacks content and tool_calls", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "go" },
+                { role: "assistant", content: null, reasoning_content: "only thought" },
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        const asst = out.messages.find((m) => m.role === "assistant");
+        expect(asst.reasoning_content).toBe("only thought");
+        expect(asst.content).toBe("");
+    });
     it("A (default): does not touch non-assistant messages", () => {
         const body = {
             messages: [

package/dist/src/providers/auth/__tests__/gemini-oauth.test.d.ts

@@ -1,8 +1,4 @@
 /**
- * Tests for src/providers/auth/gemini-oauth.ts
- *
- * Login flow (callback server mocked), refresh (expiry pre-emption + mutex),
- * revoke, authHeaders, loadGeminiTokensWithRefresh.
- * No live network calls — all HTTP via mockFetch, no real browser opens.
+ * Tests for Agy Google OAuth (replaces legacy gemini public client)
  */
 export {};

package/dist/src/providers/auth/__tests__/gemini-oauth.test.js

@@ -1,9 +1,5 @@
 /**
- * Tests for src/providers/auth/gemini-oauth.ts
- *
- * Login flow (callback server mocked), refresh (expiry pre-emption + mutex),
- * revoke, authHeaders, loadGeminiTokensWithRefresh.
- * No live network calls — all HTTP via mockFetch, no real browser opens.
+ * Tests for Agy Google OAuth (replaces legacy gemini public client)
  */
 import { describe, expect, it, vi } from "vitest";
 import { GeminiOAuthProvider, loadGeminiTokensWithRefresh } from "../gemini-oauth.js";

package/dist/src/providers/auth/gcloud.d.ts

@@ -0,0 +1,28 @@
+/**
+ * src/providers/auth/gcloud.ts
+ *
+ * Reads and refreshes tokens from Google Cloud SDK credentials
+ * (~/.config/gcloud/application_default_credentials.json).
+ *
+ * The gcloud ADC token uses GCP's official OAuth client with cloud-platform
+ * scopes, which IS accepted by generativelanguage.googleapis.com (unlike the
+ * Agy OAuth token whose scope is restricted to cloudcode-pa).
+ *
+ * Usage:
+ *   1. User runs `gcloud auth application-default login` once.
+ *   2. This file reads the resulting credentials file, extracts the token,
+ *      and returns it as an OAuthTokens-compatible object.
+ *   3. The token auto-refreshes when expired (using the refresh_token inside
+ *      the credentials file).
+ */
+import type { OAuthTokens } from "./types.js";
+/**
+ * Try to load a token from gcloud ADC.
+ * Returns null if gcloud is not installed or no credentials exist.
+ */
+export declare function loadGcloudToken(): Promise<OAuthTokens | null>;
+/**
+ * Obtain auth headers from a gcloud-derived OAuthTokens.
+ * Compatible with ProviderOAuth.authHeaders() signature.
+ */
+export declare function gcloudAuthHeaders(tokens: OAuthTokens): Record<string, string>;

package/dist/src/providers/auth/gcloud.js

@@ -0,0 +1,102 @@
+/**
+ * src/providers/auth/gcloud.ts
+ *
+ * Reads and refreshes tokens from Google Cloud SDK credentials
+ * (~/.config/gcloud/application_default_credentials.json).
+ *
+ * The gcloud ADC token uses GCP's official OAuth client with cloud-platform
+ * scopes, which IS accepted by generativelanguage.googleapis.com (unlike the
+ * Agy OAuth token whose scope is restricted to cloudcode-pa).
+ *
+ * Usage:
+ *   1. User runs `gcloud auth application-default login` once.
+ *   2. This file reads the resulting credentials file, extracts the token,
+ *      and returns it as an OAuthTokens-compatible object.
+ *   3. The token auto-refreshes when expired (using the refresh_token inside
+ *      the credentials file).
+ */
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { OAuthRefreshError } from "./types.js";
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+const GCLOUD_ADC_PATH = join(homedir(), ".config", "gcloud", "application_default_credentials.json");
+// ---------------------------------------------------------------------------
+// Loader
+// ---------------------------------------------------------------------------
+/**
+ * Load gcloud Application Default Credentials file.
+ */
+async function loadADC() {
+    try {
+        const raw = await readFile(GCLOUD_ADC_PATH, "utf8");
+        const creds = JSON.parse(raw);
+        if (creds.type !== "authorized_user") {
+            // service-account keys have a different shape; skip
+            return null;
+        }
+        return creds;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Token exchange
+// ---------------------------------------------------------------------------
+/**
+ * Exchange a gcloud refresh_token for a fresh access_token.
+ * Google's OAuth token endpoint accepts gcloud ADC credentials.
+ */
+async function exchangeRefreshToken(clientId, clientSecret, refreshToken) {
+    const body = new URLSearchParams({
+        client_id: clientId,
+        client_secret: clientSecret,
+        refresh_token: refreshToken,
+        grant_type: "refresh_token",
+    });
+    let res;
+    try {
+        res = await fetch("https://oauth2.googleapis.com/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body,
+        });
+    }
+    catch (err) {
+        throw new OAuthRefreshError("google", `gcloud ADC refresh network error: ${err.message}`);
+    }
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new OAuthRefreshError("google", `gcloud ADC refresh failed (${res.status}): ${text}`);
+    }
+    const data = (await res.json());
+    return {
+        accessToken: data.access_token,
+        refreshToken,
+        expiresAt: Date.now() + data.expires_in * 1000,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Try to load a token from gcloud ADC.
+ * Returns null if gcloud is not installed or no credentials exist.
+ */
+export async function loadGcloudToken() {
+    const creds = await loadADC();
+    if (!creds)
+        return null;
+    return exchangeRefreshToken(creds.client_id, creds.client_secret, creds.refresh_token);
+}
+/**
+ * Obtain auth headers from a gcloud-derived OAuthTokens.
+ * Compatible with ProviderOAuth.authHeaders() signature.
+ */
+export function gcloudAuthHeaders(tokens) {
+    return { Authorization: `Bearer ${tokens.accessToken}` };
+}
+//# sourceMappingURL=gcloud.js.map

package/dist/src/providers/auth/gemini-oauth.d.ts

@@ -1,19 +1,19 @@
 /**
  * src/providers/auth/gemini-oauth.ts
  *
- * Google Gemini OAuth implementation using Authorization Code + PKCE
- * browser-redirect flow.
+ * Agy (Antigravity) Google OAuth implementation.
+ * Replaces the old abandoned public gemini-cli OAuth client.
  *
- * Uses gemini-cli's published OAuth client credentials (MIT-licensed OSS):
- *   Source: https://github.com/google-gemini/gemini-cli
- *     packages/core/src/code_assist/oauth2.ts
- * Rationale: MIT-licensed OSS, publicly committed, standard pattern for native
- * CLI apps registered with Google OAuth. Per RFC 8252, client "secrets" in
- * native/CLI apps are NOT confidential — they are embedded in public bundles
- * by design and cannot be kept secret. Override via MUONROI_GOOGLE_CLIENT_SECRET.
+ * Uses client credentials extracted from the local agy.exe binary
+ * (registered for agy's "oauth-personal" / Code Assist flow).
  *
- * Scopes: https://www.googleapis.com/auth/cloud-platform openid email
- * (same as gemini-cli — covers Generative Language API + user identity)
+ * Agy stores tokens in ~/.gemini/oauth_creds.json (legacy path).
+ * We auto-import so existing agy logins continue to work.
+ *
+ * Override with MUONROI_GOOGLE_* env vars if needed.
+ *
+ * Note: Even though the provider ID is "google" (for model routing),
+ * the OAuth registration and naming is now Agy.
  */
 import type { OAuthCallbackServer } from "../../mcp/oauth-callback.js";
 import type { FetchFn } from "./device-flow.js";
@@ -21,12 +21,13 @@ import type { OAuthTokens, ProviderOAuth } from "./types.js";
 export type CallbackServerFn = (opts: {
     onCode: (code: string, state: string) => void;
     timeoutMs?: number;
+    host?: string;
 }) => Promise<OAuthCallbackServer>;
 export type OpenBrowserFn = (url: string) => void;
-export declare class GeminiOAuthProvider implements ProviderOAuth {
+export declare class AgyOAuthProvider implements ProviderOAuth {
     readonly providerId: "google";
-    private readonly clientId;
-    private readonly clientSecret;
+    private clientId;
+    private clientSecret;
     private readonly fetchFn;
     private readonly callbackServerFn;
     private readonly openBrowserFn;
@@ -46,10 +47,36 @@ export declare class GeminiOAuthProvider implements ProviderOAuth {
     authHeaders(tokens: OAuthTokens): Record<string, string>;
     private _fetchUserEmail;
 }
-/** Default Gemini OAuth provider singleton (uses live Google endpoints). */
-export declare const geminiOAuth: GeminiOAuthProvider;
+/** Back-compat for tests that still reference the old class name. */
+export { AgyOAuthProvider as GeminiOAuthProvider };
+/** Default Agy OAuth provider singleton (uses agy's Google client registration). */
+export declare const agyOAuth: AgyOAuthProvider;
+/** Back-compat alias (some code still references the old name). */
+export declare const geminiOAuth: AgyOAuthProvider;
+/**
+ * Load stored OAuth tokens for the Google provider using Agy's registration.
+ * - Auto-imports from ~/.gemini/oauth_creds.json (agy storage).
+ * - Refreshes using the agy client/secret when near expiry.
+ */
+export declare function loadAgyTokensWithRefresh(oauthProvider?: AgyOAuthProvider): Promise<OAuthTokens | null>;
+/** Back-compat alias for older call sites. */
+export declare const loadGeminiTokensWithRefresh: typeof loadAgyTokensWithRefresh;
+/**
+ * Load a custom OAuth token using user-provided GCP OAuth client credentials.
+ * Users register their own OAuth client in GCP Console → use these credentials
+ * to obtain tokens with the `generativelanguage` scope (not restricted to
+ * cloudcode-pa like the Agy client).
+ *
+ * Settings sources (in priority order):
+ *   1. settings.json → providers → google → oauthClientId / oauthClientSecret
+ *   2. MUONROI_GOOGLE_CLIENT_ID / MUONROI_GOOGLE_CLIENT_SECRET env vars
+ *
+ * Returns null when no custom client is configured.
+ */
+export declare function loadCustomOAuthTokens(): Promise<OAuthTokens | null>;
 /**
- * Load stored OAuth tokens for Google/Gemini and auto-refresh if within the
- * expiry window. Returns null if no tokens are stored.
+ * Perform a full OAuth login with a custom client (Approach C).
+ * Users run `keys login google` with their own GCP OAuth client configured
+ * in settings → this opens the browser with the right scopes.
  */
-export declare function loadGeminiTokensWithRefresh(oauthProvider?: GeminiOAuthProvider): Promise<OAuthTokens | null>;
+export declare function loginWithCustomClient(): Promise<OAuthTokens | null>;