muonroi-cli 1.8.4 → 1.9.0

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

@@ -2,7 +2,7 @@
  * src/providers/auth/types.ts
  *
  * Provider OAuth interfaces and token shapes.
- * Designed to be extensible for Anthropic / Google OAuth in the future.
+ * Designed to be extensible for additional provider OAuth in the future.
  */
 import type { ProviderId } from "../types.js";
 export interface OAuthTokens {
@@ -26,8 +26,16 @@ export interface ProviderOAuth {
      * Calls onUserCode with the human-readable code + verification URL so the
      * caller can display them to the user before polling.
      */
+    /**
+     * `signal` aborts an in-flight sign-in. Browser flows bind a loopback
+     * callback server on a fixed, tiny port set; without an abort the server
+     * outlives a cancelled sign-in for the full callback timeout and the next
+     * attempt cannot bind — which reads to the user as "OAuth is broken until I
+     * restart the CLI".
+     */
     login(opts: {
         onUserCode?: (code: string, url: string) => void;
+        signal?: AbortSignal;
     }): Promise<OAuthTokens>;
     /**
      * Exchange a refresh token for new tokens.

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

@@ -2,7 +2,7 @@
  * src/providers/auth/types.ts
  *
  * Provider OAuth interfaces and token shapes.
- * Designed to be extensible for Anthropic / Google OAuth in the future.
+ * Designed to be extensible for additional provider OAuth in the future.
  */
 // ---------------------------------------------------------------------------
 // Errors

package/dist/src/providers/capabilities.d.ts

@@ -2,9 +2,9 @@
  * src/providers/capabilities.ts
  *
  * Per-provider capability flags. Each provider quirks differently:
- *   - DeepSeek / SiliconFlow models leak `<｜DSML｜>` control tokens into
+ *   - DeepSeek models leak `<｜DSML｜>` control tokens into
  *     JSON tool inputs, breaking Zod validation for plain-text schemas.
- *   - OpenAI / Anthropic / Google handle structured tool calls reliably.
+ *   - OpenAI / Anthropic handle structured tool calls reliably.
  *   - Local Ollama models vary wildly per checkpoint — treat conservatively.
  *
  * The PIL Layer 6 output module queries these flags before offering a
@@ -81,10 +81,10 @@ export interface ProviderCapabilities {
     /**
      * Transform conversation history before sending to the provider. Default is
      * identity (returns input by reference). Providers override when they
-     * reject specific message parts — e.g. SiliconFlow's DeepSeek thinking-mode
-     * endpoint returns HTTP 400 code 20015 when assistant `reasoning` parts are
+     * reject specific message parts — e.g. a DeepSeek thinking-mode endpoint
+     * that returns HTTP 400 code 20015 when assistant `reasoning` parts are
      * present, because @ai-sdk/openai-compatible does not serialize them as the
-     * `reasoning_content` field SiliconFlow expects.
+     * `reasoning_content` field the endpoint expects.
      */
     sanitizeHistory<T>(messages: readonly T[]): readonly T[];
     /**
@@ -133,3 +133,22 @@ export interface ProviderCapabilities {
  * unknown so new providers don't accidentally inherit a quirk override.
  */
 export declare function getProviderCapabilities(providerId: ProviderId | string): ProviderCapabilities;
+/**
+ * Resolve the temperature to send for a given (provider, model), or `undefined`
+ * to omit the field entirely.
+ *
+ * Two provider quirks are handled here so no call site has to hardcode a
+ * temperature and silently break on a picky upstream:
+ *   1. Reasoning models — `acceptsParam("temperature")` returns false; they
+ *      ignore (OpenAI Responses) or reject temperature. We omit it.
+ *   2. Fixed-temperature models — some upstreams (e.g. Moonshot/Kimi via
+ *      opencode-go) reject any value other than a single allowed one with
+ *      "invalid temperature: only 1 is allowed for this model". `catalog.json`
+ *      pins `fixed_temperature` for those; we send exactly that value instead
+ *      of the caller's desired temperature.
+ *
+ * Every request that sets a temperature MUST go through this helper — inlining
+ * `temperature: 0.7` is what caused the council clarification/spec calls to
+ * fail wholesale on a Kimi session (see src/council/llm.ts).
+ */
+export declare function resolveTemperature(providerId: ProviderId | string, model: ModelInfo | undefined, desired: number): number | undefined;

package/dist/src/providers/capabilities.js

@@ -2,9 +2,9 @@
  * src/providers/capabilities.ts
  *
  * Per-provider capability flags. Each provider quirks differently:
- *   - DeepSeek / SiliconFlow models leak `<｜DSML｜>` control tokens into
+ *   - DeepSeek models leak `<｜DSML｜>` control tokens into
  *     JSON tool inputs, breaking Zod validation for plain-text schemas.
- *   - OpenAI / Anthropic / Google handle structured tool calls reliably.
+ *   - OpenAI / Anthropic handle structured tool calls reliably.
  *   - Local Ollama models vary wildly per checkpoint — treat conservatively.
  *
  * The PIL Layer 6 output module queries these flags before offering a
@@ -150,7 +150,7 @@ class XAIProviderCapabilities extends ReliableProviderCapabilities {
     }
 }
 /**
- * DeepSeek / SiliconFlow quirk: special tokens like `<｜DSML｜>` leak into
+ * DeepSeek quirk: special tokens like `<｜DSML｜>` leak into
  * tool-call JSON bodies, failing Zod validation. Plain-text schemas
  * (`respond_general`) are hit hardest because the model can't recover
  * from a malformed string field. Structured schemas (`respond_plan`,
@@ -162,10 +162,6 @@ class XAIProviderCapabilities extends ReliableProviderCapabilities {
  * malformed bodies before the model fell back to free-form text.
  */
 class DeepSeekProviderCapabilities extends ReliableProviderCapabilities {
-    /** Namespace used for openai-compatible providerOptions merge. Overridden by SiliconFlow. */
-    providerNamespace() {
-        return "deepseek";
-    }
     supportsResponseTool(taskType) {
         if (taskType === "general")
             return false;
@@ -180,18 +176,6 @@ class DeepSeekProviderCapabilities extends ReliableProviderCapabilities {
         return { readField: "promptCacheHitTokens", creationSupported: false };
     }
 }
-/**
- * SiliconFlow shares DeepSeek's `<｜DSML｜>` tool-call quirk; everything else
- * (cache metric layout, signup URL pointer) differs only by namespace.
- */
-class SiliconflowProviderCapabilities extends DeepSeekProviderCapabilities {
-    providerNamespace() {
-        return "siliconflow";
-    }
-    consoleSignupURL() {
-        return consoleUrlFor("siliconflow");
-    }
-}
 /**
  * Local Ollama models are heterogeneous; some emit clean tool JSON, some
  * don't. Treat conservatively until per-checkpoint capability detection
@@ -208,21 +192,29 @@ class OllamaProviderCapabilities extends ReliableProviderCapabilities {
     }
 }
 /**
- * Google Gemini — defaults are reliable; only the console URL differs.
+ * Z.ai — defaults are reliable; only the console URL differs.
+ */
+class ZaiProviderCapabilities extends ReliableProviderCapabilities {
+    consoleSignupURL() {
+        return consoleUrlFor("zai");
+    }
+}
+/**
+ * OpenCode Go — defaults are reliable; only the console URL differs.
  */
-class GoogleProviderCapabilities extends ReliableProviderCapabilities {
+class OpenCodeGoProviderCapabilities extends ReliableProviderCapabilities {
     consoleSignupURL() {
-        return consoleUrlFor("google");
+        return consoleUrlFor("opencode-go");
     }
 }
 const CAPABILITIES = {
     anthropic: new AnthropicProviderCapabilities(),
     openai: new OpenAIProviderCapabilities(),
-    google: new GoogleProviderCapabilities(),
     xai: new XAIProviderCapabilities(),
     deepseek: new DeepSeekProviderCapabilities(),
-    siliconflow: new SiliconflowProviderCapabilities(),
     ollama: new OllamaProviderCapabilities(),
+    zai: new ZaiProviderCapabilities(),
+    "opencode-go": new OpenCodeGoProviderCapabilities(),
 };
 /**
  * Singleton resolver — returns the capability instance for a given
@@ -232,4 +224,30 @@ const CAPABILITIES = {
 export function getProviderCapabilities(providerId) {
     return CAPABILITIES[providerId] ?? new ReliableProviderCapabilities();
 }
+/**
+ * Resolve the temperature to send for a given (provider, model), or `undefined`
+ * to omit the field entirely.
+ *
+ * Two provider quirks are handled here so no call site has to hardcode a
+ * temperature and silently break on a picky upstream:
+ *   1. Reasoning models — `acceptsParam("temperature")` returns false; they
+ *      ignore (OpenAI Responses) or reject temperature. We omit it.
+ *   2. Fixed-temperature models — some upstreams (e.g. Moonshot/Kimi via
+ *      opencode-go) reject any value other than a single allowed one with
+ *      "invalid temperature: only 1 is allowed for this model". `catalog.json`
+ *      pins `fixed_temperature` for those; we send exactly that value instead
+ *      of the caller's desired temperature.
+ *
+ * Every request that sets a temperature MUST go through this helper — inlining
+ * `temperature: 0.7` is what caused the council clarification/spec calls to
+ * fail wholesale on a Kimi session (see src/council/llm.ts).
+ */
+export function resolveTemperature(providerId, model, desired) {
+    const caps = getProviderCapabilities(providerId);
+    if (!caps.acceptsParam("temperature", model))
+        return undefined;
+    if (typeof model?.fixedTemperature === "number")
+        return model.fixedTemperature;
+    return desired;
+}
 //# sourceMappingURL=capabilities.js.map

package/dist/src/providers/endpoints.d.ts

@@ -20,6 +20,6 @@ export declare function apiBaseFor(provider: ProviderId): string;
 export declare function consoleUrlFor(provider: ProviderId): string;
 /**
  * Default base URLs for OpenAI-compatible providers only. Used by adapters
- * that share the OpenAI SDK shape (deepseek, siliconflow, xai).
+ * that share the OpenAI SDK shape (deepseek, xai).
  */
-export declare const OPENAI_COMPATIBLE_BASE_URLS: Record<"deepseek" | "siliconflow" | "xai", string>;
+export declare const OPENAI_COMPATIBLE_BASE_URLS: Record<"deepseek" | "xai" | "zai" | "opencode-go", string>;

package/dist/src/providers/endpoints.js

@@ -17,18 +17,10 @@ export const PROVIDER_ENDPOINTS = {
         apiBase: "https://api.openai.com/v1",
         consoleUrl: "https://platform.openai.com/api-keys",
     },
-    google: {
-        apiBase: "https://generativelanguage.googleapis.com/v1beta",
-        consoleUrl: "https://aistudio.google.com/app/apikey",
-    },
     deepseek: {
         apiBase: "https://api.deepseek.com",
         consoleUrl: "https://platform.deepseek.com/api_keys",
     },
-    siliconflow: {
-        apiBase: "https://api.siliconflow.com/v1",
-        consoleUrl: "https://cloud.siliconflow.com/account/ak",
-    },
     xai: {
         apiBase: "https://api.x.ai/v1",
         consoleUrl: "https://console.x.ai/",
@@ -37,6 +29,14 @@ export const PROVIDER_ENDPOINTS = {
         apiBase: "http://localhost:11434",
         consoleUrl: "(no key needed for Ollama)",
     },
+    zai: {
+        apiBase: "https://api.z.ai/api/coding/paas/v4",
+        consoleUrl: "https://z.ai/coding-plan",
+    },
+    "opencode-go": {
+        apiBase: "https://opencode.ai/zen/go/v1",
+        consoleUrl: "https://opencode.ai",
+    },
 };
 /** Fast lookup: provider id → API base URL. */
 export function apiBaseFor(provider) {
@@ -48,11 +48,12 @@ export function consoleUrlFor(provider) {
 }
 /**
  * Default base URLs for OpenAI-compatible providers only. Used by adapters
- * that share the OpenAI SDK shape (deepseek, siliconflow, xai).
+ * that share the OpenAI SDK shape (deepseek, xai).
  */
 export const OPENAI_COMPATIBLE_BASE_URLS = {
     deepseek: PROVIDER_ENDPOINTS.deepseek.apiBase,
-    siliconflow: PROVIDER_ENDPOINTS.siliconflow.apiBase,
     xai: PROVIDER_ENDPOINTS.xai.apiBase,
+    zai: PROVIDER_ENDPOINTS.zai.apiBase,
+    "opencode-go": PROVIDER_ENDPOINTS["opencode-go"].apiBase,
 };
 //# sourceMappingURL=endpoints.js.map

package/dist/src/providers/env-store.d.ts

@@ -0,0 +1,17 @@
+export declare function envFilePath(): string;
+/**
+ * Upsert `name=value` in the `.env` store, set `process.env[name]` for the
+ * current process, and (on Windows) mirror to the User registry env.
+ */
+export declare function persistEnvVar(name: string, value: string): void;
+/** Remove `name` from the `.env` store, `process.env`, and Windows registry. */
+export declare function clearEnvVar(name: string): void;
+/**
+ * Load the `.env` store into `process.env` at startup.
+ *
+ * For ordinary variables the ambient OS environment stays authoritative and
+ * `.env` only fills gaps. For `*_API_KEY` credentials the CLI writes itself,
+ * `.env` wins and the conflict is logged — see {@link ambientWinsForSecrets}
+ * for why, and `MUONROI_ENV_PRECEDENCE=ambient` to opt out.
+ */
+export declare function loadEnvFileIntoProcess(): void;

package/dist/src/providers/env-store.js

@@ -0,0 +1,228 @@
+/**
+ * src/providers/env-store.ts
+ *
+ * Canonical CLI key store: a `~/.muonroi-cli/.env` file (mode 0600) that is
+ * loaded into process.env at startup and written when the user sets a key.
+ * On Windows we ALSO mirror to the User-scope registry env so other OS
+ * processes see the key. Replaces the OS keychain (keytar).
+ */
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { redactor } from "../utils/redactor.js";
+export function envFilePath() {
+    return process.env.MUONROI_ENV_FILE ?? join(homedir(), ".muonroi-cli", ".env");
+}
+function readLines() {
+    try {
+        return readFileSync(envFilePath(), "utf8").split(/\r?\n/);
+    }
+    catch (err) {
+        // Missing file is the normal first-run case — no key store yet.
+        if (err?.code === "ENOENT")
+            return [];
+        // Anything else (locked, permissions, corrupt) must NOT read as "no keys":
+        // persistEnvVar rebuilds the file from these lines, so returning [] here
+        // silently rewrites the store WITHOUT the keys it failed to read — the user
+        // sets one key and the others are gone. Fail loudly instead.
+        throw new Error(`[env-store] cannot read ${envFilePath()}: ${err instanceof Error ? err.message : String(err)}. ` +
+            `Refusing to continue — writing now would drop the keys already in it.`);
+    }
+}
+function writeLines(lines) {
+    const p = envFilePath();
+    mkdirSync(dirname(p), { recursive: true });
+    const body = lines.filter((l, i) => !(l === "" && i === lines.length - 1)).join("\n");
+    writeFileSync(p, body === "" ? "" : `${body}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch (err) {
+        // Non-fatal on filesystems without POSIX perms (e.g. some Windows FS).
+        if (process.env.MUONROI_DEBUG_ENVSTORE) {
+            console.error(`[env-store] chmod failed for ${p}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+/** Parse "KEY=value" — value may contain "="; comments/blank lines ignored. */
+function parseLine(line) {
+    if (!line || line.trimStart().startsWith("#"))
+        return null;
+    const eq = line.indexOf("=");
+    if (eq <= 0)
+        return null;
+    return { key: line.slice(0, eq).trim(), value: line.slice(eq + 1) };
+}
+/** Env-var names we will ever mirror are plain identifiers; reject anything else. */
+function isValidEnvName(name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+/**
+ * Credentials this CLI owns: it writes them itself (`/login`, `keys set` →
+ * persistEnvVar) so its own store is the user's latest intent. Matched by the
+ * `*_API_KEY` naming convention shared by ENV_BY_PROVIDER / ENV_BY_CHAT /
+ * ENV_BY_MCP — a structural test, not a provider-id list, and importing
+ * keychain.ts here would be circular (keychain imports this module).
+ */
+function isCliOwnedSecret(name) {
+    return /_API_KEY$/.test(name);
+}
+/** Last 4 chars + length — enough to tell two keys apart, never enough to use one. */
+function maskSecret(value) {
+    return `len=${value.length} …${value.slice(-4)}`;
+}
+/**
+ * Which side wins when `.env` and the ambient OS environment disagree.
+ *
+ * Default `store`: for `*_API_KEY` only, `.env` wins. A stale Windows User-scope
+ * var silently beating the key the user just set through the CLI cost a full
+ * session of debugging — two council panelists died on a forgotten placeholder
+ * key while `.env` held the working one, and nothing said so.
+ *
+ * `MUONROI_ENV_PRECEDENCE=ambient` restores the old behaviour for CI and
+ * scripts that intentionally inject a key for one run.
+ */
+function ambientWinsForSecrets() {
+    return process.env.MUONROI_ENV_PRECEDENCE === "ambient";
+}
+/**
+ * True while a test runner is driving. Vitest sets both `VITEST` and
+ * `NODE_ENV=test`; either is enough.
+ */
+function isTestRunner() {
+    return process.env.VITEST !== undefined || process.env.NODE_ENV === "test";
+}
+function mirrorToWindowsRegistry(name, value) {
+    if (process.platform !== "win32")
+        return;
+    // A unit test must never write the developer's OS-global environment. It did:
+    // `bunx vitest run` on Windows left the fixture values from env-store.test.ts,
+    // migrate-legacy-keys.test.ts and auth-exclusivity.test.ts sitting in
+    // HKCU:\Environment. Those tests point MUONROI_ENV_FILE at a temp dir and
+    // clean it up, so they look hermetic — but persistEnvVar also mirrors here,
+    // none of them mocks child_process, and nothing cleaned the registry.
+    //
+    // The credential fixtures then outlived the suite and shadowed the real
+    // provider credentials for every NEW process: sub-agents 401'd, the AI SDK
+    // reported the resulting empty stream as AI_NoOutputGeneratedError, and
+    // /ideal's implementation stage died in 0.6s across three runs — bug "G1",
+    // whose own comment blames "gpt-5.4 reasoning models". The model was never
+    // involved. Guarding here rather than mocking per-test: the next test to call
+    // persistEnvVar would reintroduce the leak, and this is invisible on POSIX.
+    if (isTestRunner())
+        return;
+    if (!isValidEnvName(name)) {
+        // Defense-in-depth: never let a non-identifier name reach the shell.
+        if (process.env.MUONROI_DEBUG_ENVSTORE) {
+            console.error(`[env-store] refusing to mirror invalid env name: ${name}`);
+        }
+        return;
+    }
+    try {
+        // Neither name nor value is interpolated into the script — both are read
+        // from the child's environment as literal strings, so no PowerShell
+        // metacharacters in either can be interpreted as commands (injection-safe).
+        const script = value === null
+            ? "[Environment]::SetEnvironmentVariable($env:MUONROI_ENVSTORE_NAME, $null, 'User')"
+            : "[Environment]::SetEnvironmentVariable($env:MUONROI_ENVSTORE_NAME, $env:MUONROI_ENVSTORE_VALUE, 'User')";
+        execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+            env: value === null
+                ? { ...process.env, MUONROI_ENVSTORE_NAME: name }
+                : { ...process.env, MUONROI_ENVSTORE_NAME: name, MUONROI_ENVSTORE_VALUE: value },
+            stdio: "ignore",
+        });
+    }
+    catch (err) {
+        // .env + in-memory write already succeeded; OS-wide mirror is best-effort.
+        if (process.env.MUONROI_DEBUG_ENVSTORE) {
+            console.error(`[env-store] registry mirror failed for ${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+/**
+ * Upsert `name=value` in the `.env` store, set `process.env[name]` for the
+ * current process, and (on Windows) mirror to the User registry env.
+ */
+export function persistEnvVar(name, value) {
+    redactor.enrollSecret(value);
+    const lines = readLines();
+    const out = [];
+    let replaced = false;
+    for (const line of lines) {
+        const parsed = parseLine(line);
+        if (parsed?.key === name) {
+            if (!replaced) {
+                out.push(`${name}=${value}`);
+                replaced = true;
+            }
+        }
+        else if (line !== "") {
+            out.push(line);
+        }
+    }
+    if (!replaced)
+        out.push(`${name}=${value}`);
+    writeLines(out);
+    process.env[name] = value;
+    mirrorToWindowsRegistry(name, value);
+}
+/** Remove `name` from the `.env` store, `process.env`, and Windows registry. */
+export function clearEnvVar(name) {
+    const lines = readLines();
+    const out = lines.filter((line) => parseLine(line)?.key !== name && line !== "");
+    writeLines(out);
+    delete process.env[name];
+    mirrorToWindowsRegistry(name, null);
+}
+/**
+ * Load the `.env` store into `process.env` at startup.
+ *
+ * For ordinary variables the ambient OS environment stays authoritative and
+ * `.env` only fills gaps. For `*_API_KEY` credentials the CLI writes itself,
+ * `.env` wins and the conflict is logged — see {@link ambientWinsForSecrets}
+ * for why, and `MUONROI_ENV_PRECEDENCE=ambient` to opt out.
+ */
+export function loadEnvFileIntoProcess() {
+    let lines;
+    try {
+        lines = readLines();
+    }
+    catch (err) {
+        // Boot must survive an unreadable store, but never in silence: every
+        // provider would 401 and the CLI would look like it lost the keys.
+        console.error(`${err instanceof Error ? err.message : String(err)} — continuing without the stored keys.`);
+        return;
+    }
+    for (const line of lines) {
+        const parsed = parseLine(line);
+        if (!parsed)
+            continue;
+        const ambient = process.env[parsed.key];
+        if (ambient === undefined) {
+            process.env[parsed.key] = parsed.value;
+            redactor.enrollSecret(parsed.value);
+            continue;
+        }
+        if (ambient === parsed.value)
+            continue;
+        // The two disagree. For non-secrets the ambient stays authoritative, as
+        // before. For a CLI-owned credential a silent divergence is exactly the
+        // failure that must never happen again, so it is always reported.
+        if (!isCliOwnedSecret(parsed.key))
+            continue;
+        redactor.enrollSecret(ambient);
+        if (ambientWinsForSecrets()) {
+            console.error(`[env-store] ${parsed.key}: OS environment (${maskSecret(ambient)}) overrides the CLI store ` +
+                `(${maskSecret(parsed.value)}) — MUONROI_ENV_PRECEDENCE=ambient is set. If auth fails, the ` +
+                `OS variable is the one being used.`);
+            continue;
+        }
+        console.error(`[env-store] ${parsed.key}: the CLI store (${maskSecret(parsed.value)}) takes precedence over a ` +
+            `conflicting OS environment variable (${maskSecret(ambient)}). Remove the OS variable to silence ` +
+            `this, or set MUONROI_ENV_PRECEDENCE=ambient to let it win.`);
+        process.env[parsed.key] = parsed.value;
+        redactor.enrollSecret(parsed.value);
+    }
+}
+//# sourceMappingURL=env-store.js.map

package/dist/src/providers/keychain.d.ts

@@ -1,14 +1,15 @@
 /**
  * src/providers/keychain.ts
  *
- * Per-provider keychain loader with env-var fallback.
- * Extends the Phase 0 loadAnthropicKey pattern to all 6 providers.
- * PROV-02 / PROV-03 requirements.
+ * Per-provider key store. Backed by the env-store (`.env` file + process.env +
+ * Windows registry mirror) — the OS keychain (keytar) has been removed.
  *
- * Priority: OS keychain (keytar) > environment variable > settings.json > ProviderKeyMissingError.
+ * Source of truth: `process.env[ENV_BY_PROVIDER[provider]]`. Writes go through
+ * the env-store; reads come straight from process.env.
  * Exception: ollama is keyless by default.
  */
 import type { ProviderId } from "./types.js";
+export declare const ENV_BY_PROVIDER: Record<ProviderId, string>;
 /**
  * Thrown when no API key can be found for a provider.
  */
@@ -17,37 +18,33 @@ export declare class ProviderKeyMissingError extends Error {
     constructor(provider: ProviderId);
 }
 /**
- * Providers that store an API key in the OS keychain.
- * Phase 12.2-G5: derived from `ALL_PROVIDER_IDS` by excluding ollama
- * (keyless local server). Preserves the original ordering.
+ * Providers that store an API key (all except keyless ollama). Derived from
+ * `ALL_PROVIDER_IDS`; preserves the original ordering.
  */
 export declare const KEYCHAIN_PROVIDER_IDS: readonly ProviderId[];
 /**
- * Store a provider API key in the OS keychain. Returns true on success.
- * Falls back to false (silent) if keytar is unavailable on this platform.
+ * Store a provider API key in the OS environment (via the env-store: `.env`
+ * file + process.env + Windows registry mirror). Returns true on success.
  */
 export declare function setKeyForProvider(provider: string | ProviderId, key: string): Promise<boolean>;
 /**
- * Delete a stored key. Returns true if a key was deleted, false if none was
- * present or keytar is unavailable.
+ * Delete a stored key from the env-store. Returns true if a key was present.
  */
 export declare function deleteKeyForProvider(provider: string | ProviderId): Promise<boolean>;
 /**
- * List provider IDs that currently have a key stored in the keychain.
- * Empty array if keytar is unavailable.
+ * List provider IDs that currently have a key set in the environment.
  */
 export declare function listStoredProviders(): Promise<ProviderId[]>;
 /**
- * Load the API key for a given provider.
- * Priority: OS keychain (keytar) > environment variable.
+ * Load the API key for a given provider from the environment.
  * Ollama returns '' when no key is found (keyless).
  *
  * @throws {ProviderKeyMissingError} when no key found for non-ollama providers.
  */
 export declare function loadKeyForProvider(provider: ProviderId): Promise<string>;
 /**
- * Return the list of providers that currently have credentials available — checked across
- * OS keychain, environment variables, and user-settings.json. `ollama` is always included
+ * Return the list of providers that currently have credentials available —
+ * either an env API key or a stored OAuth token. `ollama` is always included
  * because it is keyless. Order is stable for UI rendering.
  */
 export declare function getConfiguredProviders(): Promise<ProviderId[]>;
@@ -60,7 +57,14 @@ export declare function getConfiguredProviders(): Promise<ProviderId[]>;
 export declare function getOAuthTokens(provider: ProviderId): Promise<import("./auth/types.js").OAuthTokens | null>;
 /**
  * Find the first provider with an available API key.
- * Checks in priority order: anthropic, openai, google, deepseek, siliconflow, ollama.
+ * Checks in priority order: anthropic, openai, deepseek, ollama.
  * Returns null if no provider has a key (unlikely — ollama is keyless fallback).
  */
 export declare function firstAvailableProvider(): Promise<ProviderId | null>;
+/**
+ * One-time migration: move any legacy API keys — OS keychain (keytar) or
+ * `settings.json` (`providers.<p>.apiKey`) — into the env-store, then remove
+ * the legacy copies. Best-effort, idempotent, and never throws. Guarded by
+ * `settings.keysMigratedToEnv`. Runs once at startup before key resolution.
+ */
+export declare function migrateLegacyKeysToEnv(): Promise<void>;