@openagents-org/agent-launcher 0.2.188 → 0.2.190

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.188",
+  "version": "0.2.190",
   "description": "OpenAgents Launcher \u2014 install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/registry.json

@@ -333,6 +333,10 @@
       "env_vars": [
         "CURSOR_API_KEY"
       ],
+      "creds_file": "~/.cursor/cli-config.json",
+      "creds_key": "authInfo",
+      "creds_no_parse": true,
+      "unverifiable": true,
       "login_command": "cursor-agent login"
     },
     "env_config": [

package/src/adapters/hermes.js

@@ -267,14 +267,23 @@ class HermesAdapter extends BaseAdapter {
   // Output parsing
   // ------------------------------------------------------------------
 
-  _parseHermesOutput(raw) {
+  _parseHermesOutput(raw, meta) {
     let sessionId = null;
     let body = raw;
 
-    const m = SESSION_ID_RE.exec(body);
-    if (m) {
-      sessionId = m[1];
-      body = body.replace(SESSION_ID_RE, '');
+    // Hermes -Q mode emits session_id to stderr (meta); the response body is
+    // on stdout (raw). Older Hermes printed session_id on stdout, so fall
+    // back to extracting it from the body when stderr carried none.
+    if (meta) {
+      const m = SESSION_ID_RE.exec(meta);
+      if (m) sessionId = m[1];
+    }
+    if (!sessionId) {
+      const m = SESSION_ID_RE.exec(body);
+      if (m) {
+        sessionId = m[1];
+        body = body.replace(SESSION_ID_RE, '');
+      }
     }
 
     const lines = [];
@@ -328,6 +337,7 @@ class HermesAdapter extends BaseAdapter {
     const proc = spawn(this._hermesBin, args, {
       env,
       stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: this.workingDir,
       // No process group on Windows (can't signal one); windowsHide keeps a
       // console from flashing up.
       detached: !IS_WINDOWS,
@@ -358,7 +368,9 @@ class HermesAdapter extends BaseAdapter {
       throw new Error(`hermes exited with code ${exitCode}: ${detail}`);
     }
 
-    const { text, sessionId } = this._parseHermesOutput(stdout);
+    // Hermes -Q mode: response body on stdout, session metadata
+    // (session_id:, resume banner) on stderr — parse both streams.
+    const { text, sessionId } = this._parseHermesOutput(stdout, stderr);
     if (sessionId) {
       this._channelSessions[channelName] = sessionId;
       this._saveSessions();

package/src/adapters/kimi-stream.js

@@ -340,7 +340,9 @@ function classifyKimiError(info) {
     };
   }
 
-  if (/auth_error|401|unauthorized|invalid.{0,20}(api.?key|token)|credential/i.test(detail)) {
+  // Bounded: a bare 401 matched request ids, and `invalid.{0,20}token` turned
+  // "Invalid value for max_tokens" into a bad key and a `kimi login` hint.
+  if (/auth_error|\b401\b|unauthorized|invalid[\s_-]*(api[\s_-]?key|token|authentication)\b|credential/i.test(detail)) {
     return {
       kind: 'auth',
       userMessage:

package/src/adapters/openclaw.js

@@ -31,6 +31,41 @@ const OPENCLAW_STATE_DIR = path.join(
   '.openclaw'
 );
 
+/**
+ * Archive the legacy auth-profiles.json this adapter used to write.
+ *
+ * Current OpenClaw keeps credentials in SQLite and refuses to run while a
+ * legacy JSON store sits beside an empty one ("requires legacy credential
+ * migration; run openclaw doctor --fix"); beside a populated one it silently
+ * ignores the file, so a changed key never took effect either. The key now
+ * reaches OpenClaw through the env and openclaw.json, so the file only gets
+ * in the way.
+ *
+ * Only a file made entirely of our entries is moved: the `custom` provider
+ * exists only because configureNativeAuth created it, and any other entry must
+ * carry a key we hold ourselves. A profile the user made (OpenClaw's own
+ * paste-token also names them `<provider>:manual`) keeps the file in place,
+ * for `openclaw doctor --fix` to migrate. Renamed, never deleted.
+ *
+ * @param {Array<string|undefined>} knownKeys  API keys this agent is configured with
+ */
+function retireOwnLegacyAuthProfiles(knownKeys) {
+  const file = path.join(OPENCLAW_STATE_DIR, 'agents', 'main', 'agent', 'auth-profiles.json');
+  let data;
+  try { data = JSON.parse(fs.readFileSync(file, 'utf-8')); } catch { return false; }
+  const keys = new Set((knownKeys || []).filter(Boolean));
+  const profiles = Object.values((data && data.profiles) || {});
+  const ours = profiles.every((p) => p && p.type === 'token'
+    && (p.provider === 'custom' || keys.has(p.token)));
+  if (!ours) return false;
+  try {
+    fs.renameSync(file, `${file}.openagents-retired`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 class OpenClawAdapter extends BaseAdapter {
   /**
    * @param {object} opts - BaseAdapter opts plus:
@@ -54,6 +89,14 @@ class OpenClawAdapter extends BaseAdapter {
       this._log('OpenClaw binary not found — agent will not be able to process messages');
     }
 
+    // Agents configured before the key stopped going into auth-profiles.json
+    // still have that file; clear it before the first run rather than on the
+    // next save.
+    const env = this.agentEnv || {};
+    if (retireOwnLegacyAuthProfiles([env.LLM_API_KEY, env.OPENAI_API_KEY, env.ANTHROPIC_API_KEY])) {
+      this._log('Archived the legacy auth-profiles.json this launcher wrote (OpenClaw now stores credentials in SQLite)');
+    }
+
     // Install workspace skill
     this._installWorkspaceSkill();
   }
@@ -586,9 +629,10 @@ class OpenClawAdapter extends BaseAdapter {
    * LLM_API_KEY / LLM_BASE_URL / LLM_MODEL values.
    * Called by the Launcher's saveAgentEnv when type === 'openclaw'.
    *
-   * For standard providers (OpenAI, Anthropic), uses auth-profiles.json.
-   * For custom endpoints, uses models.providers in openclaw.json which
-   * gives full tool support via the CLI gateway mode.
+   * For standard providers (OpenAI, Anthropic), the key travels in the env
+   * and only the model is set here. For custom endpoints, uses
+   * models.providers in openclaw.json which gives full tool support via the
+   * CLI gateway mode.
    */
   static configureNativeAuth(env) {
     const apiKey = env.LLM_API_KEY;
@@ -602,26 +646,19 @@ class OpenClawAdapter extends BaseAdapter {
     const isAnthropic = baseUrl.includes('api.anthropic.com');
     const configFile = path.join(OPENCLAW_STATE_DIR, 'openclaw.json');
 
+    // The key itself never goes into auth-profiles.json any more: current
+    // OpenClaw keeps credentials in SQLite and refuses to start while a legacy
+    // JSON store sits beside an empty one ("requires legacy credential
+    // migration; run openclaw doctor --fix"). A standard provider reads the
+    // key from the OPENAI_API_KEY / ANTHROPIC_API_KEY the resolve rules put
+    // in its env; a custom one from models.providers below.
+    retireOwnLegacyAuthProfiles([apiKey]);
+
     if (isOpenAI || isAnthropic) {
-      // Standard provider — use auth-profiles.json
       const provider = isAnthropic ? 'anthropic' : 'openai';
-      const profileId = `${provider}:manual`;
-      const agentDir = path.join(OPENCLAW_STATE_DIR, 'agents', 'main', 'agent');
-
-      try {
-        fs.mkdirSync(agentDir, { recursive: true });
-        const authFile = path.join(agentDir, 'auth-profiles.json');
-        let authData = { version: 1, profiles: {} };
-        try { authData = JSON.parse(fs.readFileSync(authFile, 'utf-8')); } catch {}
-        authData.profiles = authData.profiles || {};
-        authData.profiles[profileId] = { type: 'token', provider, token: apiKey };
-        authData.lastGood = authData.lastGood || {};
-        authData.lastGood[provider] = profileId;
-        fs.writeFileSync(authFile, JSON.stringify(authData, null, 2), 'utf-8');
-      } catch {}
-
       // Set model
       try {
+        fs.mkdirSync(OPENCLAW_STATE_DIR, { recursive: true });
         let config = {};
         try { config = JSON.parse(fs.readFileSync(configFile, 'utf-8')); } catch {}
         config.agents = config.agents || {};
@@ -653,22 +690,9 @@ class OpenClawAdapter extends BaseAdapter {
 
         fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf-8');
       } catch {}
-
-      // Also write auth-profiles.json for the custom provider
-      try {
-        const agentDir = path.join(OPENCLAW_STATE_DIR, 'agents', 'main', 'agent');
-        fs.mkdirSync(agentDir, { recursive: true });
-        const authFile = path.join(agentDir, 'auth-profiles.json');
-        let authData = { version: 1, profiles: {} };
-        try { authData = JSON.parse(fs.readFileSync(authFile, 'utf-8')); } catch {}
-        authData.profiles = authData.profiles || {};
-        authData.profiles['custom:manual'] = { type: 'token', provider: 'custom', token: apiKey };
-        authData.lastGood = authData.lastGood || {};
-        authData.lastGood.custom = 'custom:manual';
-        fs.writeFileSync(authFile, JSON.stringify(authData, null, 2), 'utf-8');
-      } catch {}
     }
   }
 }
 
 module.exports = OpenClawAdapter;
+module.exports.retireOwnLegacyAuthProfiles = retireOwnLegacyAuthProfiles;

package/src/adapters/workspace-prompt.js

@@ -415,28 +415,35 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs` +
         ` -d '{"url":"URL","network":"${workspaceId}",` +
-        `"source":"openagents:${agentName}"}'\`\n\n` +
+        `"source":"openagents:${agentName}"}'\`\n` +
+        'Tabs are **temporary** by default (closed after a while idle). Add ' +
+        '`"persistent":true` (and optionally `"name":"…"`) to open a **permanent** ' +
+        'tab whose login state is saved and reusable — humans see the two kinds ' +
+        'separately in their browser. Permanent slots are scarcer: use them only ' +
+        'for logins worth keeping.\n\n' +
         '**Navigate:**\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/navigate` +
-        ` -d '{"url":"URL"}'\`\n\n` +
+        ` -d '{"url":"URL","source":"openagents:${agentName}"}'\`\n\n` +
         '**Click element:**\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/click` +
-        ` -d '{"selector":"CSS_SELECTOR"}'\`\n\n` +
+        ` -d '{"selector":"CSS_SELECTOR","source":"openagents:${agentName}"}'\`\n\n` +
         '**Type text:**\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/type` +
-        ` -d '{"selector":"CSS_SELECTOR","text":"TEXT"}'\`\n` +
+        ` -d '{"selector":"CSS_SELECTOR","text":"TEXT","source":"openagents:${agentName}"}'\`\n` +
         '(add `"append":true` to keep existing text instead of replacing it)\n\n' +
         '**Press a key** (e.g. submit a form with Enter):\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/press_key` +
-        ` -d '{"key":"Enter"}'\`\n\n` +
+        ` -d '{"key":"Enter","source":"openagents:${agentName}"}'\`\n\n` +
         '**Run JavaScript** in the page (returns the result):\n' +
         `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json"` +
         ` ${baseUrl}/v1/browser/tabs/{tab_id}/evaluate` +
-        ` -d '{"expression":"document.title"}'\`\n\n` +
+        ` -d '{"expression":"document.title","source":"openagents:${agentName}"}'\`\n` +
+        'The `source` field is how humans watching the shared browser see *who* is ' +
+        'acting — include it on every tab action.\n\n' +
         '**Close tab:**\n' +
         `\`${curl} -s -X DELETE -H "${h}" ${baseUrl}/v1/browser/tabs/{tab_id}\`\n\n` +
         '**Clicks/typing use CSS selectors only** (no pixel coordinates). If a ' +

package/src/agent-rows.js

@@ -7,6 +7,8 @@
 
 'use strict';
 
+const { isCliLogin } = require('./env');
+
 /**
  * Build one display row per configured agent from a connector.
  *
@@ -39,7 +41,7 @@ function loadAgentRows(connector) {
     let notReadyMsg = '';
     let health = null;
     try {
-      health = connector.healthCheck(agent.type || 'openclaw');
+      health = connector.healthCheck(agent.type || 'openclaw', { cliLogin: isCliLogin(agent.env), agentEnv: agent.env || {} });
       if (health && !health.ready) {
         // "Not installed" only when the executable is genuinely missing; an
         // installed-but-signed-out agent shows its login/config message, never

package/src/cli.js

@@ -985,14 +985,16 @@ async function cmdProbe(connector, flags, positional) {
   const target = positional[0];
   if (!target) { print('Usage: agn probe <type|agent> [--json]'); return; }
 
-  // Accept an agent name as a convenience — probe its type.
+  // Accept an agent name — probe its type on that agent's own env, so a
+  // signed-in agent is tested on its sign-in rather than the type's key.
   let type = target;
+  let agentEnv;
   try {
     const agent = connector.config.getAgent(target);
-    if (agent) type = agent.type || 'openclaw';
+    if (agent) { type = agent.type || 'openclaw'; agentEnv = agent.env || {}; }
   } catch {}
 
-  const result = await connector.probeAgentType(type);
+  const result = await connector.probeAgentType(type, { agentEnv });
 
   if (flags && flags.json) {
     // Machine consumers (the daemon's probe_agent node command) read ONLY

package/src/daemon.js

@@ -10,6 +10,7 @@ const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
 const { listEndpointModels } = require('./model-list');
+const { AUTH_MODE_KEY, isCliLogin, stripForCliLogin, typeEnvFor } = require('./env');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 
 /**
@@ -72,6 +73,19 @@ function endpointHost(value) {
  * Compatible with the Python SDK's daemon — reads the same config files,
  * writes the same status format, and supports the same command protocol.
  */
+/**
+ * Whether a node command carries a key for the agent. A blank key is no key:
+ * saving one would leave the agent not-ready, and clearing the sign-in
+ * marker on its account would flip a signed-in agent to key mode with
+ * nothing to run on. `useDeviceCredentials` means the device already holds
+ * the key — nothing to write.
+ */
+function _sentKey(args) {
+  const key = args && args.apiKey;
+  const present = typeof key === 'string' ? key.trim().length > 0 : !!key;
+  return present && !args.useDeviceCredentials;
+}
+
 class Daemon {
   constructor(config, envManager, registry) {
     this.config = config;
@@ -139,7 +153,9 @@ class Daemon {
     const type = agent.type || 'openclaw';
     this._probeInFlight.add(name);
     try {
-      const r = await this._runAgn(['probe', type, '--json']);
+      // By agent name, not type: the probe runs on this agent's own env, so a
+      // signed-in agent is tested on its sign-in, not the type's saved key.
+      const r = await this._runAgn(['probe', name, '--json']);
       let parsed = null;
       try { parsed = JSON.parse(r.stdout.trim()); } catch {}
       if (!parsed || typeof parsed !== 'object') {
@@ -347,7 +363,7 @@ class Daemon {
         // ever leaving the device. The endpoint goes out as a hostname, so
         // the workspace can tell a relay from the vendor its model list is for.
         let typeEnv = {};
-        try { typeEnv = this.envManager.load(a.type) || {}; } catch {}
+        try { typeEnv = typeEnvFor(a.type, this.envManager.load(a.type) || {}, this.registry, a.env); } catch {}
         const model = (a.env && a.env.LLM_MODEL) || typeEnv.LLM_MODEL || null;
         const apiKey = (a.env && a.env.LLM_API_KEY) || typeEnv.LLM_API_KEY || null;
         roster.push({
@@ -372,9 +388,11 @@ class Daemon {
    * builds its env: LLM_BASE_URL or a provider variable (OPENAI_BASE_URL,
    * ANTHROPIC_BASE_URL, …) saved for it or mapped by resolve_env, and failing
    * those, the daemon's own environment for the provider variable this type's
-   * LLM_BASE_URL maps to, which the spawned CLI inherits.
+   * LLM_BASE_URL maps to, which the spawned CLI inherits. A signed-in agent
+   * has none: _buildAgentEnv drops every saved endpoint for it.
    */
   _configuredBaseUrl(a, typeEnv) {
+    if (isCliLogin(a.env)) return null;
     const saved = { ...typeEnv, ...(a.env || {}) };
     let env = saved;
     try { env = { ...saved, ...this.envManager.resolve(a.type, saved, this.registry) }; } catch {}
@@ -470,7 +488,12 @@ class Daemon {
    */
   _saveNodeAgentEnv(name, type, args) {
     const changes = {};
-    if (args.apiKey && !args.useDeviceCredentials) changes.LLM_API_KEY = args.apiKey;
+    if (_sentKey(args)) {
+      changes.LLM_API_KEY = args.apiKey;
+      // A key sent for the agent means it runs on that key: a sign-in marker
+      // left from the launcher would strip it again at launch.
+      changes[AUTH_MODE_KEY] = '';
+    }
     if (args.baseUrl !== undefined) changes.LLM_BASE_URL = args.baseUrl;
     if (args.model !== undefined) {
       const existing = this.config.getAgent(name);
@@ -585,7 +608,7 @@ async _runNodeCommand(n, cmd) {
         // Optional credentials for API-key agents (generic → provider mapping
         // happens in env resolution). `useDeviceCredentials` means the device
         // already holds them — nothing to write.
-        if (args.apiKey && !args.useDeviceCredentials)
+        if (_sentKey(args))
           await this._runAgn(['env', type, '--set', `LLM_API_KEY=${args.apiKey}`]);
         if (args.model) await this._setModelEnv(type, args.model);
         if (args.baseUrl) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
@@ -622,7 +645,7 @@ async _runNodeCommand(n, cmd) {
         // restart it so the change takes effect. Working-dir changes require a
         // recreate (agn has no in-place path change) at the new path.
         const type = (args.type || '').trim();
-        if (args.apiKey && !args.useDeviceCredentials)
+        if (_sentKey(args))
           await this._runAgn(['env', type, '--set', `LLM_API_KEY=${args.apiKey}`]);
         if (args.model !== undefined) await this._setModelEnv(type, args.model);
         if (args.baseUrl !== undefined) await this._runAgn(['env', type, '--set', `LLM_BASE_URL=${args.baseUrl}`]);
@@ -1519,11 +1542,9 @@ async _runNodeCommand(n, cmd) {
 
   _buildAgentEnv(agentCfg) {
     const type = agentCfg.type || 'openclaw';
-    const saved = this.envManager.load(type);
-    const mergedSaved = { ...saved, ...(agentCfg.env || {}) };
-    const resolved = this.envManager.resolve(type, mergedSaved, this.registry);
-    const merged = { ...mergedSaved, ...resolved };
-    return { ...process.env, ...merged };
+    const merged = this.envManager.getForAgent(type, this.registry, agentCfg.env);
+    // A signed-in agent drops every key, the launcher's own environment's too.
+    return stripForCliLogin(type, { ...process.env, ...merged }, this.registry, agentCfg.env);
   }
 
   _agentConfigFingerprint(agentCfg) {

package/src/env.js

@@ -112,6 +112,119 @@ class EnvManager {
     const resolved = this.resolve(agentType, saved, registry);
     return { ...saved, ...resolved };
   }
+
+  /**
+   * The saved env one agent runs on: the part of <type>.env it takes (see
+   * typeEnvFor) under its own env, resolved. The daemon launches the agent on
+   * this over its own environment, and readiness judges the agent on it too.
+   */
+  getForAgent(agentType, registry, agentEnv) {
+    const saved = { ...typeEnvFor(agentType, this.load(agentType), registry, agentEnv), ...(agentEnv || {}) };
+    const resolved = this.resolve(agentType, saved, registry);
+    return { ...saved, ...resolved };
+  }
+}
+
+/**
+ * Set on an agent's own env when it signs in through its CLI (`codex login`,
+ * `claude auth login`) instead of a key. Keys stay shared per type in
+ * <type>.env and the launcher's own environment, and a CLI prefers a key it
+ * is handed over its account session, so without this an agent created on
+ * the sign-in tab still ran on whatever key was saved there earlier.
+ */
+const AUTH_MODE_KEY = 'OPENAGENTS_AUTH_MODE';
+const CLI_LOGIN = 'cli_login';
+
+/**
+ * Whether the agent signs in through its CLI. Read from the agent's own env
+ * only: a marker in <type>.env or the launcher's environment would otherwise
+ * strip the key of every agent of that type, keyed ones included.
+ */
+function isCliLogin(agentEnv) {
+  return !!agentEnv && agentEnv[AUTH_MODE_KEY] === CLI_LOGIN;
+}
+
+/**
+ * Keys and endpoints a CLI reads under a name of its own that no registry
+ * field or readiness check declares (the launcher's auth-specs.ts offers the
+ * endpoints). Named per type rather than by suffix: the env stripped is the
+ * daemon's whole environment, where *_BASE_URL also names endpoints that are
+ * not the model's. CODEX_API_KEY: the Codex CLI honors it over its ChatGPT
+ * sign-in, so one set system-wide would defeat the sign-in just as
+ * OPENAI_API_KEY does.
+ */
+const NATIVE_CREDENTIALS = {
+  codex: ['CODEX_API_KEY'],
+  gemini: ['GOOGLE_GEMINI_BASE_URL'],
+  antigravity: ['GOOGLE_GEMINI_BASE_URL'],
+};
+
+/**
+ * The variables that carry a key or an endpoint for this agent type: its
+ * password and *_BASE_URL fields, what LLM_API_KEY / LLM_BASE_URL resolve to,
+ * and the *_API_KEY variables its readiness check accepts (Gemini has no
+ * fields at all, and reads GEMINI_API_KEY / GOOGLE_API_KEY). Only the
+ * *_API_KEY ones: that list also holds models and tokens other tools share
+ * (MSWEA_MODEL_NAME, GH_TOKEN). The model is not among them, it applies to a
+ * sign-in as well. So is
+ * CLAUDE_CODE_OAUTH_TOKEN: `claude setup-token` makes it from the account
+ * sign-in, so it is how a signed-in claude authenticates, not a key to drop.
+ */
+function credentialKeys(agentType, registry) {
+  const keys = new Set(['LLM_API_KEY', 'LLM_BASE_URL', ...(NATIVE_CREDENTIALS[agentType] || [])]);
+  if (!registry) return keys;
+  for (const field of registry.getEnvFields?.(agentType) || []) {
+    if (field.password || /BASE_URL$/.test(field.name || '')) keys.add(field.name);
+  }
+  for (const rule of registry.getResolveRules?.(agentType) || []) {
+    if (keys.has(rule.from) && rule.to) keys.add(rule.to);
+  }
+  const checkReady = registry.getEntry?.(agentType)?.check_ready;
+  for (const name of (checkReady && checkReady.env_vars) || []) {
+    if (/_API_KEY$/.test(name)) keys.add(name);
+  }
+  return keys;
+}
+
+/**
+ * The variables that pick the model: LLM_MODEL, what it resolves to
+ * (CODEX_MODEL, ANTHROPIC_MODEL), and a type's own *_MODEL fields.
+ */
+function modelKeys(agentType, registry) {
+  const keys = new Set(['LLM_MODEL']);
+  if (!registry) return keys;
+  for (const field of registry.getEnvFields?.(agentType) || []) {
+    if (/_MODEL(_NAME)?$/.test(field.name || '')) keys.add(field.name);
+  }
+  for (const rule of registry.getResolveRules?.(agentType) || []) {
+    if (rule.from === 'LLM_MODEL' && rule.to) keys.add(rule.to);
+  }
+  return keys;
+}
+
+/**
+ * The part of <type>.env an agent runs on. All of it for an agent on a key.
+ * A signed-in agent takes none of its keys, and none of its model either:
+ * that model was picked for the key's endpoint (a relay's
+ * openai-gpt-oss-20b), which the account behind a sign-in does not serve.
+ * Its model is the one in its own env, else the CLI's default.
+ */
+function typeEnvFor(agentType, typeEnv, registry, agentEnv) {
+  if (!isCliLogin(agentEnv)) return typeEnv;
+  const out = stripForCliLogin(agentType, typeEnv, registry, agentEnv);
+  for (const key of modelKeys(agentType, registry)) delete out[key];
+  return out;
+}
+
+/**
+ * `env` with every credential removed when the agent's own env (`agentEnv`)
+ * marks a sign-in, or unchanged for an agent that runs on a key.
+ */
+function stripForCliLogin(agentType, env, registry, agentEnv) {
+  if (!isCliLogin(agentEnv)) return env;
+  const out = { ...env };
+  for (const key of credentialKeys(agentType, registry)) delete out[key];
+  return out;
 }
 
 /**
@@ -128,4 +241,6 @@ function normalizeAnthropicBase(url) {
   return String(url || '').trim().replace(/\/+$/, '').replace(/\/v1$/i, '');
 }
 
-module.exports = { EnvManager };
+module.exports = {
+  EnvManager, AUTH_MODE_KEY, CLI_LOGIN, isCliLogin, credentialKeys, modelKeys, stripForCliLogin, typeEnvFor,
+};

package/src/index.js

@@ -69,8 +69,8 @@ class AgentConnector {
     return this.installer.isInstalled(agentType);
   }
 
-  healthCheck(agentType) {
-    return this.installer.healthCheck(agentType);
+  healthCheck(agentType, opts) {
+    return this.installer.healthCheck(agentType, opts);
   }
 
   // -- Agent CRUD --

package/src/installer.js

@@ -512,7 +512,15 @@ class Installer {
    * Health check — binary existence + version.
    * @returns {{ installed: boolean, binary: string|null, version: string|null }}
    */
-  healthCheck(agentType) {
+  /**
+   * `opts.cliLogin` checks one agent that signs in through its CLI: the core
+   * drops every key for it at launch, so a key saved for the type or set in
+   * the daemon's environment must not make it ready.
+   *
+   * `opts.agentEnv` is that agent's own env. With it the agent is judged on
+   * the env the daemon launches it on, not on <type>.env alone.
+   */
+  healthCheck(agentType, opts = {}) {
     const entry = this.registry.getEntry(agentType);
     if (entry?.install?.api_only) {
       const info = this.getInstallInfo(agentType);
@@ -532,7 +540,7 @@ class Installer {
         };
       }
 
-      const apiReadiness = this._evaluateReadiness(agentType, entry, null);
+      const apiReadiness = this._evaluateReadiness(agentType, entry, null, opts);
       return {
         installed: true,
         binary: null,
@@ -568,7 +576,7 @@ class Installer {
     const versionCmd = checkCmd || this._versionProbeCommand(binary);
 
     const version = this._detectVersion(binary, versionCmd);
-    const readiness = this._evaluateReadiness(agentType, entry, binary);
+    const readiness = this._evaluateReadiness(agentType, entry, binary, opts);
 
     // Generic minimum-version gate (no per-agent special-casing). An entry opts
     // in by declaring `install.min_version`. Below the floor we keep
@@ -776,7 +784,7 @@ class Installer {
     return { compatible: true, minVersion, message: null };
   }
 
-  _evaluateReadiness(agentType, entry, binary) {
+  _evaluateReadiness(agentType, entry, binary, opts = {}) {
     const checkReady = entry?.check_ready;
     if (!checkReady) {
       return {
@@ -788,10 +796,16 @@ class Installer {
       };
     }
 
-    const savedEnv = this.env.getEffective(agentType, this.registry);
+    // A key set on the agent itself (the workspace saves it there, as
+    // LLM_API_KEY) never reaches <type>.env, so judged on that file alone a
+    // Kimi agent that answered fine read "Not configured — … run: kimi login".
+    const savedEnv = opts.agentEnv
+      ? this.env.getForAgent(agentType, this.registry, opts.agentEnv)
+      : this.env.getEffective(agentType, this.registry);
     const directEnv = this._hasAllValues(process.env, checkReady.env_all);
     const directSaved = this._hasAllValues(savedEnv, checkReady.saved_env_all || checkReady.env_all);
-    const directReady = directEnv || directSaved;
+    const keyed = !opts.cliLogin;
+    const directReady = keyed && (directEnv || directSaved);
     // env_vars must be satisfiable by the SAVED (and resolved) per-agent env,
     // not only the daemon's own process env. The workspace configure flow
     // saves LLM_API_KEY, which resolve rules map to e.g. ANTHROPIC_AUTH_TOKEN
@@ -799,10 +813,10 @@ class Installer {
     // alone made a perfectly working key-configured agent read "Not logged
     // in" (health banner + failed smoke test) while chat answered fine, with
     // guidance telling the user to configure the very key they had saved.
-    const envAnyReady =
+    const envAnyReady = keyed && (
       this._hasAnyValue(process.env, checkReady.env_vars) ||
-      this._hasAnyValue(savedEnv, checkReady.env_vars);
-    const savedAnyReady = !!(checkReady.saved_env_key && savedEnv[checkReady.saved_env_key]);
+      this._hasAnyValue(savedEnv, checkReady.env_vars));
+    const savedAnyReady = keyed && !!(checkReady.saved_env_key && savedEnv[checkReady.saved_env_key]);
     // A registry entry may require a non-empty JSON object rather than mere
     // parseability. In that mode the stricter _evaluateCredsFile path below is
     // authoritative; the legacy parser treats an empty {} as ready.

package/src/probe.js

@@ -33,6 +33,7 @@ const { spawn } = require('./wsl');
 const { getEnhancedEnv } = require('./paths');
 const { shouldUseShellForBinary } = require('./adapters/health-status');
 const { formatAuthGuidance } = require('./auth-guidance');
+const { isCliLogin, stripForCliLogin, typeEnvFor } = require('./env');
 
 const PROBE_PROMPT = 'hi';
 const DEFAULT_TIMEOUT_MS = 90_000;
@@ -98,7 +99,14 @@ function authFlavor(entry, agentEnv) {
   const cr = (entry && entry.check_ready) || {};
   const envCfg = (entry && entry.env_config) || [];
   const hasKeyField = envCfg.some((f) => f && /key/i.test(f.name || ''));
-  const hasSavedKey = !!(agentEnv && (agentEnv.LLM_API_KEY || agentEnv.OPENAI_API_KEY || agentEnv.ANTHROPIC_API_KEY));
+  // The type's own key names count too: a Kimi agent on KIMI_API_KEY whose
+  // key was rejected was told its sign-in had expired and to run kimi login.
+  const keyNames = [
+    'LLM_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY', cr.saved_env_key,
+    ...(cr.env_vars || []).filter((k) => /_API_KEY$/.test(k)),
+    ...envCfg.filter((f) => f && f.password).map((f) => f.name),
+  ];
+  const hasSavedKey = !!agentEnv && keyNames.some((k) => k && agentEnv[k]);
   if (hasSavedKey || (hasKeyField && !cr.login_command)) return 'api_key';
   if (cr.login_command) return 'cli_login';
   return hasKeyField ? 'api_key' : 'cli_login';
@@ -287,16 +295,22 @@ async function probeAgentType(connector, type, opts = {}) {
     return done({ ok: false, method: 'none', code: CODE.UNKNOWN_TYPE, message: `Unknown agent type '${type}'` });
   }
 
+  // A signed-in agent is ready on its sign-in alone: judged on the type, a
+  // key it will never be given made it "pass" with no login at all.
+  const cliLogin = isCliLogin(opts.agentEnv);
   let health = {};
-  try { health = connector.healthCheck(type) || {}; } catch (e) {
+  try { health = connector.healthCheck(type, { cliLogin, agentEnv: opts.agentEnv }) || {}; } catch (e) {
     health = { installed: false, ready: false, message: e.message };
   }
 
+  // opts.agentEnv is one agent's own env, layered over the type's the way
+  // the daemon builds it; a signed-in agent then carries no key from either.
   let agentEnv = {};
   try {
-    const saved = connector.getAgentEnv(type) || {};
+    const typeEnv = typeEnvFor(type, connector.getAgentEnv(type) || {}, connector.registry, opts.agentEnv);
+    const saved = { ...typeEnv, ...(opts.agentEnv || {}) };
     const resolved = connector.resolveAgentEnv(type, saved) || {};
-    agentEnv = { ...saved, ...resolved };
+    agentEnv = stripForCliLogin(type, { ...saved, ...resolved }, connector.registry, opts.agentEnv);
   } catch {}
 
   if (!health.installed) {
@@ -321,7 +335,7 @@ async function probeAgentType(connector, type, opts = {}) {
 
   const timeoutMs = opts.timeoutMs
     || (entry.probe && entry.probe.timeout_s ? entry.probe.timeout_s * 1000 : DEFAULT_TIMEOUT_MS);
-  const env = { ...getEnhancedEnv(), ...agentEnv };
+  const env = stripForCliLogin(type, { ...getEnhancedEnv(), ...agentEnv }, connector.registry, opts.agentEnv);
 
   // Hoisted above the CLI tier: a failing CLI probe consults it too (below).
   const hasApiKey = !!(agentEnv.LLM_API_KEY || agentEnv.OPENAI_API_KEY || agentEnv.ANTHROPIC_API_KEY

package/src/tui.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const { spawn } = require('child_process');
 const { getExtraBinDirs } = require('./paths');
 const { hasCredentialMetadata, formatAuthGuidance } = require('./auth-guidance');
+const { isCliLogin } = require('./env');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -774,7 +775,7 @@ function createTUI() {
       const checkReady = entry && entry.check_ready;
       if (hasCredentialMetadata(checkReady)) {
         let health = null;
-        try { health = connector.healthCheck(agent.type); } catch {}
+        try { health = connector.healthCheck(agent.type, { cliLogin: isCliLogin(agent.env), agentEnv: agent.env || {} }); } catch {}
         const g = formatAuthGuidance(entry, health);
         const tag = g.ready ? 'green-fg' : 'yellow-fg';
         log(`{bold}{${tag}}${entry.label || agent.type} authentication: ${g.ready ? 'Ready' : 'Not ready'}{/}{/bold}`);