@botcord/daemon 0.2.89 → 0.2.90

package/src/__tests__/skill-installer.test.ts

@@ -0,0 +1,224 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  agentCodexHomeDir,
+  agentWorkspaceDir,
+} from "../agent-workspace.js";
+import {
+  buildVercelSkillsArgs,
+  installAgentSkillManifest,
+  installBotLearnArchiveManifest,
+  installVercelSkillsForAgent,
+} from "../skill-installer.js";
+
+let tmpHome = "";
+let prevHome: string | undefined;
+
+beforeEach(() => {
+  tmpHome = mkdtempSync(path.join(tmpdir(), "skill-installer-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = tmpHome;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+describe("skill installer", () => {
+  it("installs a manifest into the loaded agent runtime path and returns a refreshed snapshot", () => {
+    const result = installAgentSkillManifest(
+      "ag_manifest",
+      {
+        name: "review-helper",
+        description: "Review pull requests",
+        files: [{ path: "references/checklist.md", content: "Check tests\n" }],
+      },
+      { runtime: "codex" },
+    );
+
+    const skillDir = path.join(agentCodexHomeDir("ag_manifest"), "skills", "review-helper");
+    expect(readFileSync(path.join(skillDir, "SKILL.md"), "utf8")).toContain("name: review-helper");
+    expect(readFileSync(path.join(skillDir, "references", "checklist.md"), "utf8")).toBe("Check tests\n");
+    expect(result.installed).toEqual([
+      {
+        name: "review-helper",
+        targets: ["codex"],
+        paths: [skillDir],
+      },
+    ]);
+    expect(result.snapshot.skills.map((s) => s.name)).toContain("review-helper");
+  });
+
+  it("installs BotLearn archive-style manifests containing multiple skills", () => {
+    const result = installBotLearnArchiveManifest(
+      "ag_archive",
+      {
+        targetRuntimes: ["claude-code"],
+        skills: [
+          {
+            id: "planner",
+            description: "Plan work",
+            skillMd: "---\nname: planner\ndescription: Plan work\n---\n\n# Planner\n",
+          },
+          {
+            name: "tester",
+            markdown: "---\nname: tester\n---\n\n# Tester\n",
+          },
+        ],
+      },
+      { runtime: "claude-code" },
+    );
+
+    const skillsRoot = path.join(agentWorkspaceDir("ag_archive"), ".claude", "skills");
+    expect(existsSync(path.join(skillsRoot, "planner", "SKILL.md"))).toBe(true);
+    expect(existsSync(path.join(skillsRoot, "tester", "SKILL.md"))).toBe(true);
+    expect(result.installed.map((skill) => skill.name)).toEqual(["planner", "tester"]);
+    expect(result.snapshot.skills.map((skill) => skill.name).sort()).toEqual(["planner", "tester"]);
+  });
+
+  it("rejects unsafe names and file paths before writing", () => {
+    expect(() => installAgentSkillManifest("ag_unsafe_name", {
+      name: "../bad",
+    })).toThrow(/unsafe skill name/);
+
+    expect(() => installAgentSkillManifest("ag_unsafe_file", {
+      name: "safe",
+      files: [{ path: "../escape.txt", content: "no" }],
+    })).toThrow(/unsafe skill file path/);
+  });
+
+  it("does not leave a partial skill dir when source file validation fails", () => {
+    const sourceRoot = mkdtempSync(path.join(tmpdir(), "skill-source-"));
+    try {
+      expect(() => installAgentSkillManifest("ag_missing_source", {
+        name: "missing-source",
+        files: [{ path: "references/missing.md", sourcePath: "missing.md" }],
+      }, {
+        runtime: "codex",
+        sourceRoot,
+      })).toThrow();
+
+      const skillDir = path.join(agentCodexHomeDir("ag_missing_source"), "skills", "missing-source");
+      expect(existsSync(skillDir)).toBe(false);
+    } finally {
+      rmSync(sourceRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("does not leave a partial skill dir when an inline file is oversized", () => {
+    const oversized = "x".repeat((256 * 1024) + 1);
+
+    expect(() => installAgentSkillManifest("ag_oversized", {
+      name: "oversized",
+      files: [{ path: "references/large.md", content: oversized }],
+    }, {
+      runtime: "codex",
+    })).toThrow(/skill file too large/);
+
+    const skillDir = path.join(agentCodexHomeDir("ag_oversized"), "skills", "oversized");
+    expect(existsSync(skillDir)).toBe(false);
+  });
+
+  it("builds a non-interactive vercel-labs/skills command for injected execution", () => {
+    expect(buildVercelSkillsArgs("https://github.com/vercel-labs/skills", ["frontend-design"], ["codex"]))
+      .toEqual([
+        "--yes",
+        "skills",
+        "add",
+        "https://github.com/vercel-labs/skills",
+        "--global",
+        "--copy",
+        "--yes",
+        "--skill",
+        "frontend-design",
+        "--agent",
+        "codex",
+      ]);
+  });
+
+  it("imports skills produced by an injected vercel-labs/skills executor without network", async () => {
+    const executor = vi.fn(async (_command, _args, options) => {
+      const home = options.env?.HOME as string;
+      const namespaced = path.join(home, ".codex", "skills", "vercel-labs", "find-skills");
+      mkdirSync(namespaced, { recursive: true });
+      writeFileSync(
+        path.join(namespaced, "SKILL.md"),
+        "---\nname: find-skills\ndescription: Find skills\n---\n\n# Find Skills\n",
+      );
+    });
+
+    const result = await installVercelSkillsForAgent({
+      agentId: "ag_vercel",
+      packageSpec: "https://github.com/vercel-labs/skills",
+      skills: ["find-skills"],
+      runtime: "codex",
+      executor,
+    });
+
+    const installed = path.join(agentCodexHomeDir("ag_vercel"), "skills", "find-skills", "SKILL.md");
+    expect(existsSync(installed)).toBe(true);
+    expect(result.installed).toEqual([
+      {
+        name: "find-skills",
+        targets: ["codex"],
+        paths: [path.dirname(installed)],
+      },
+    ]);
+    expect(result.snapshot.skills.map((skill) => skill.name)).toContain("find-skills");
+    expect(executor).toHaveBeenCalledWith(
+      "npx",
+      expect.arrayContaining(["skills", "add", "https://github.com/vercel-labs/skills"]),
+      expect.objectContaining({ cwd: agentWorkspaceDir("ag_vercel") }),
+    );
+  });
+
+  it("rejects untrusted vercel package specs", async () => {
+    await expect(installVercelSkillsForAgent({
+      agentId: "ag_untrusted_vercel",
+      packageSpec: "attacker/skills",
+      runtime: "codex",
+      executor: vi.fn(),
+    })).rejects.toThrow(/unsupported vercel skills packageSpec/);
+  });
+
+  it("rejects symlinked files from vercel skill import without installing a skill dir", async () => {
+    const outside = mkdtempSync(path.join(tmpdir(), "skill-outside-"));
+    try {
+      writeFileSync(path.join(outside, "secret.txt"), "do not copy");
+      const executor = vi.fn(async (_command, _args, options) => {
+        const home = options.env?.HOME as string;
+        const skillDir = path.join(home, ".codex", "skills", "vercel-labs", "linked-skill");
+        mkdirSync(skillDir, { recursive: true });
+        writeFileSync(
+          path.join(skillDir, "SKILL.md"),
+          "---\nname: linked-skill\n---\n\n# Linked Skill\n",
+        );
+        symlinkSync(path.join(outside, "secret.txt"), path.join(skillDir, "secret.txt"));
+      });
+
+      await expect(installVercelSkillsForAgent({
+        agentId: "ag_vercel_symlink",
+        packageSpec: "https://github.com/vercel-labs/skills",
+        runtime: "codex",
+        executor,
+      })).rejects.toThrow(/rejects symlink/);
+
+      const skillDir = path.join(agentCodexHomeDir("ag_vercel_symlink"), "skills", "linked-skill");
+      expect(existsSync(skillDir)).toBe(false);
+    } finally {
+      rmSync(outside, { recursive: true, force: true });
+    }
+  });
+});

package/src/cloud-daemon.ts

@@ -42,6 +42,7 @@ import { CloudAuthManager, asUserAuthManager } from "./cloud-auth.js";
 import type { CloudModeConfig } from "./cloud-mode.js";
 import { buildCloudRunSettleHook } from "./cloud-settle.js";
 import type { InstalledAgentInfo, OnAgentInstalledHook } from "./provision.js";
+import type { SkillIndexOptions } from "./skill-index.js";
 
 // Cloud daemons follow the same cadence as local — keeps dashboard
 // "runtimes last detected" behavior identical across both kinds.
@@ -125,6 +126,15 @@ export async function startCloudDaemon(
   const credentialPathByAgentId = new Map<string, string>();
   const hubUrlByAgentId = new Map<string, string>();
   const displayNameByAgent = new Map<string, string>();
+  const runtimeByAgentId = new Map<string, string>();
+  const hermesProfileByAgentId = new Map<string, string>();
+  const skillIndexOptionsForAgent = (agentId: string): SkillIndexOptions => {
+    const hermesProfile = hermesProfileByAgentId.get(agentId);
+    return {
+      runtime: runtimeByAgentId.get(agentId) ?? opts.config.defaultRoute.adapter,
+      ...(hermesProfile ? { hermesProfile } : {}),
+    };
+  };
   // Seed each per-agent hub URL with the cloud-mode value so that even
   // before the first credential file is written the room-context fetcher
   // has somewhere sensible to point.
@@ -235,15 +245,15 @@ export async function startCloudDaemon(
   };
 
   const installedAgentIds = new Set<string>();
-  const runtimeByAgentId = new Map<string, string>();
   let controlChannel: ControlChannel | null = null;
   const pushInstalledAgentSkillSnapshot = (agentId: string, reason: string): void => {
     if (!controlChannel) return;
-    const runtime = runtimeByAgentId.get(agentId) ?? opts.config.defaultRoute.adapter;
-    const pushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+    const skillIndexOptions = skillIndexOptionsForAgent(agentId);
+    const pushed = pushAgentSkillSnapshot(controlChannel, agentId, skillIndexOptions);
     logger.info("cloud control-channel: agent_skill_snapshot pushed", {
       agentId,
-      runtime,
+      runtime: skillIndexOptions.runtime,
+      hermesProfile: skillIndexOptions.hermesProfile ?? null,
       reason,
       ok: pushed,
     });
@@ -252,6 +262,8 @@ export async function startCloudDaemon(
   const onAgentInstalled: OnAgentInstalledHook = (info: InstalledAgentInfo) => {
     installedAgentIds.add(info.agentId);
     if (info.runtime) runtimeByAgentId.set(info.agentId, info.runtime);
+    if (info.hermesProfile) hermesProfileByAgentId.set(info.agentId, info.hermesProfile);
+    else if (info.runtime) hermesProfileByAgentId.delete(info.agentId);
     credentialPathByAgentId.set(info.agentId, info.credentialsFile);
     if (info.hubUrl) hubUrlByAgentId.set(info.agentId, info.hubUrl);
     if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
@@ -262,6 +274,7 @@ export async function startCloudDaemon(
           agentId: info.agentId,
           activityTracker,
           roomContextBuilder,
+          skillIndexOptions: () => skillIndexOptionsForAgent(info.agentId),
           // Cloud daemons run isolated — no loop-risk guard wired in PR1;
           // the runtime adapter's wall-time budget enforces the equivalent.
           loopRiskBuilder: () => null,

package/src/daemon.ts

@@ -52,7 +52,7 @@ import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-res
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 import { createAttentionPolicyFetcher } from "./attention-policy-fetcher.js";
-import { collectAgentSkillSnapshot } from "./skill-index.js";
+import { collectAgentSkillSnapshot, type SkillIndexOptions } from "./skill-index.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -249,7 +249,7 @@ export function pushRuntimeSnapshot(
 export function pushAgentSkillSnapshot(
   sink: RuntimeSnapshotSink,
   agentId: string,
-  opts: { runtime?: string } = {},
+  opts: SkillIndexOptions = {},
 ): boolean {
   const snap = collectAgentSkillSnapshot(agentId, opts);
   const ok = sink.send({
@@ -354,6 +354,13 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
   );
 
   const gwConfig = toGatewayConfig(opts.config, { agentIds, agentRuntimes });
+  const skillIndexOptionsForAgent = (agentId: string): SkillIndexOptions => {
+    const meta = agentRuntimes[agentId];
+    return {
+      runtime: meta?.runtime ?? opts.config.defaultRoute.adapter,
+      ...(meta?.hermesProfile ? { hermesProfile: meta.hermesProfile } : {}),
+    };
+  };
 
   // Per-agent hub URL — read from each credential file at boot. Used to
   // populate `BOTCORD_HUB` for runtime CLI subprocesses so the bundled
@@ -420,6 +427,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
         activityTracker,
         roomContextBuilder,
         loopRiskBuilder,
+        skillIndexOptions: () => skillIndexOptionsForAgent(aid),
       }),
     );
   }
@@ -530,11 +538,16 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     // next room-context fetch re-loads the BotCordClient against the new
     // credential file.
     credentialPathByAgentId.set(info.agentId, info.credentialsFile);
-    if (info.runtime) {
-      agentRuntimes[info.agentId] = {
+    if (info.runtime || info.hermesProfile) {
+      const next = {
         ...(agentRuntimes[info.agentId] ?? {}),
-        runtime: info.runtime,
+        ...(info.runtime ? { runtime: info.runtime } : {}),
+        ...(info.hermesProfile ? { hermesProfile: info.hermesProfile } : {}),
       };
+      if (info.runtime && !info.hermesProfile) {
+        delete next.hermesProfile;
+      }
+      agentRuntimes[info.agentId] = next;
     }
     if (info.hubUrl) hubUrlByAgentId.set(info.agentId, info.hubUrl);
     if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
@@ -546,6 +559,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
           activityTracker,
           roomContextBuilder,
           loopRiskBuilder,
+          skillIndexOptions: () => skillIndexOptionsForAgent(info.agentId),
         }),
       );
     }
@@ -677,11 +691,12 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
         ok: pushed,
       });
       for (const agentId of agentIds) {
-        const runtime = agentRuntimes[agentId]?.runtime ?? opts.config.defaultRoute.adapter;
-        const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+        const skillIndexOptions = skillIndexOptionsForAgent(agentId);
+        const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId, skillIndexOptions);
         logger.info("control-channel: initial agent_skill_snapshot push", {
           agentId,
-          runtime,
+          runtime: skillIndexOptions.runtime,
+          hermesProfile: skillIndexOptions.hermesProfile ?? null,
           ok: skillsPushed,
         });
       }

package/src/provision.ts

@@ -28,6 +28,8 @@ import {
   type StoredBotCordCredentials,
   type UpdateAgentParams,
   type GatewayInboundFrame,
+  type InstallAgentSkillParams,
+  type ListAgentSkillsParams,
 } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
 import type { GatewayInboundMessage } from "./gateway/index.js";
@@ -75,7 +77,12 @@ import { log as daemonLog } from "./log.js";
 import { discoverAgentCredentials } from "./agent-discovery.js";
 import { resolveMemoryDir } from "./working-memory.js";
 import { discoverRuntimeModelCatalog } from "./runtime-models.js";
-import { collectAgentSkillSnapshot } from "./skill-index.js";
+import { collectAgentSkillSnapshot, type SkillIndexOptions } from "./skill-index.js";
+import {
+  installAgentSkillManifest,
+  installBotLearnArchiveManifest,
+  installVercelSkillsForAgent,
+} from "./skill-installer.js";
 import {
   buildRuntimeSelectionExtraArgs,
   mergeRuntimeExtraArgs,
@@ -85,14 +92,21 @@ import {
   type CloudGatewayTypingEmitter,
 } from "./cloud-gateway-runtime.js";
 
-interface ListAgentSkillsParams {
-  agentId: string;
-}
-
-function runtimeForLoadedAgent(gateway: Gateway, agentId: string): string | undefined {
-  return gateway.listManagedRoutes()
-    .find((route) => route.match?.accountId === agentId)
-    ?.runtime;
+function skillIndexOptionsForLoadedAgent(gateway: Gateway, agentId: string): SkillIndexOptions {
+  const route = gateway.listManagedRoutes()
+    .find((entry) => entry.match?.accountId === agentId);
+  let credentials: StoredBotCordCredentials | null = null;
+  try {
+    credentials = loadStoredCredentials(defaultCredentialsFile(agentId));
+  } catch {
+    credentials = null;
+  }
+  const runtime = route?.runtime ?? credentials?.runtime;
+  const hermesProfile = route?.hermesProfile ?? credentials?.hermesProfile;
+  return {
+    ...(runtime ? { runtime } : {}),
+    ...(hermesProfile ? { hermesProfile } : {}),
+  };
 }
 
 /**
@@ -108,6 +122,7 @@ export interface InstalledAgentInfo {
   hubUrl: string;
   displayName?: string;
   runtime?: string;
+  hermesProfile?: string;
 }
 
 /**
@@ -516,16 +531,77 @@ export function createProvisioner(opts: ProvisionerOptions): (
             },
           };
         }
-        const runtime = runtimeForLoadedAgent(gateway, params.agentId);
-        const result = collectAgentSkillSnapshot(params.agentId, { runtime });
+        const skillIndexOptions = skillIndexOptionsForLoadedAgent(gateway, params.agentId);
+        const result = collectAgentSkillSnapshot(params.agentId, skillIndexOptions);
         daemonLog.debug("list_agent_skills", {
           agentId: params.agentId,
-          runtime,
+          runtime: skillIndexOptions.runtime,
+          hermesProfile: skillIndexOptions.hermesProfile ?? null,
           count: result.skills.length,
         });
         return { ok: true, result };
       }
 
+      case CONTROL_FRAME_TYPES.INSTALL_AGENT_SKILL: {
+        const params = (frame.params ?? {}) as unknown as InstallAgentSkillParams;
+        if (!params.agentId) {
+          return {
+            ok: false,
+            error: { code: "bad_params", message: "install_agent_skill requires params.agentId" },
+          };
+        }
+        const channels = gateway.snapshot().channels;
+        if (!channels[params.agentId]) {
+          return {
+            ok: false,
+            error: {
+              code: "agent_not_loaded",
+              message: `agent ${params.agentId} is not loaded in daemon gateway`,
+            },
+          };
+        }
+        const skillIndexOptions = skillIndexOptionsForLoadedAgent(gateway, params.agentId);
+        const runtime = skillIndexOptions.runtime;
+        const modes = [params.manifest, params.archiveManifest, params.vercel].filter(Boolean).length;
+        if (modes !== 1) {
+          return {
+            ok: false,
+            error: {
+              code: "bad_params",
+              message: "install_agent_skill requires exactly one of manifest, archiveManifest, or vercel",
+            },
+          };
+        }
+        let result;
+        try {
+          result = params.vercel
+            ? await installVercelSkillsForAgent({
+              agentId: params.agentId,
+              packageSpec: params.vercel.packageSpec,
+              skills: params.vercel.skills,
+              runtime,
+            })
+            : params.archiveManifest
+              ? installBotLearnArchiveManifest(params.agentId, params.archiveManifest, { runtime })
+              : installAgentSkillManifest(params.agentId, params.manifest!, { runtime });
+        } catch (err) {
+          return {
+            ok: false,
+            error: {
+              code: "skill_install_failed",
+              message: err instanceof Error ? err.message : String(err),
+            },
+          };
+        }
+        daemonLog.debug("install_agent_skill", {
+          agentId: params.agentId,
+          runtime,
+          installed: result.installed.map((s) => s.name),
+          snapshotCount: result.snapshot.skills.length,
+        });
+        return { ok: true, result };
+      }
+
       case "wake_agent": {
         return handleWakeAgent(gateway, frame.params);
       }
@@ -1118,6 +1194,7 @@ async function installLocalAgent(
         hubUrl: credentials.hubUrl,
         ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
         ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
       });
     } catch (err) {
       // Hook misbehavior must not fail the install — the agent is already
@@ -1212,6 +1289,7 @@ async function installExistingOpenclawBinding(
         hubUrl: credentials.hubUrl,
         ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
         ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
       });
     } catch (err) {
       daemonLog.error("provision.onAgentInstalled threw — caches may be stale", {

package/src/runtime-models.ts

@@ -68,6 +68,37 @@ const KIMI_FALLBACK_MODELS: RuntimeModelProbe[] = [
   { id: "kimi-k2-0711", displayName: "kimi-k2-0711", provider: "kimi", source: "builtin" },
 ];
 
+// Gemini CLI has no `gemini models list` command — the model set is
+// hard-coded inside the bundle's `VALID_GEMINI_MODELS` (see `@google/gemini-cli`
+// bundle `chunk-BE42OOYM.js:275832`). We mirror the documented user-facing
+// names here as a static catalog; the actual availability depends on the
+// user's auth tier (gcloud ADC / Vertex / GEMINI_API_KEY) and project quota.
+// The `auto` alias is the default — it lets gemini pick the best model.
+const GEMINI_FALLBACK_MODELS: RuntimeModelProbe[] = [
+  { id: "auto", displayName: "Auto (let Gemini pick)", provider: "google", source: "builtin", isDefault: true },
+  { id: "pro", displayName: "Pro alias", provider: "google", source: "builtin" },
+  { id: "flash", displayName: "Flash alias", provider: "google", source: "builtin" },
+  { id: "flash-lite", displayName: "Flash Lite alias", provider: "google", source: "builtin" },
+  { id: "gemini-2.5-pro", displayName: "Gemini 2.5 Pro", provider: "google", source: "builtin" },
+  { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", provider: "google", source: "builtin" },
+  { id: "gemini-2.5-flash-lite", displayName: "Gemini 2.5 Flash Lite", provider: "google", source: "builtin" },
+  { id: "gemini-3-pro-preview", displayName: "Gemini 3 Pro (preview)", provider: "google", source: "builtin" },
+  { id: "gemini-3-flash-preview", displayName: "Gemini 3 Flash (preview)", provider: "google", source: "builtin" },
+  { id: "gemini-3.1-pro-preview", displayName: "Gemini 3.1 Pro (preview)", provider: "google", source: "builtin" },
+  {
+    id: "gemini-3.1-pro-preview-customtools",
+    displayName: "Gemini 3.1 Pro Custom Tools (preview)",
+    provider: "google",
+    source: "builtin",
+  },
+  {
+    id: "gemini-3.1-flash-lite-preview",
+    displayName: "Gemini 3.1 Flash Lite (preview)",
+    provider: "google",
+    source: "builtin",
+  },
+];
+
 export interface RuntimeModelDiscovery {
   models?: RuntimeModelProbe[];
   parameters?: RuntimeParameterProbe[];
@@ -160,6 +191,22 @@ function runtimeCatalogStrategy(entry: RuntimeProbeEntry): RuntimeCatalogStrateg
           ],
         }),
       };
+    case "gemini":
+      // Gemini CLI exposes no runtime discovery command and its thinking
+      // budget / level (see bundle `ThinkingLevel`, `thinkingBudget`) is
+      // configured per-installation in `~/.gemini/settings.json`, not via
+      // any CLI flag — so we ship a static model catalog with no parameter
+      // controls. settings.json + BOTCORD_GEMINI_BIN feed the cache key so
+      // user-side reconfig (e.g. switching auth type) busts the cache.
+      return {
+        id: entry.id,
+        contextKey: runtimeCatalogContextKey(entry, {
+          settings: fileStatKey(path.join(homedir(), ".gemini", "settings.json")),
+          env: pickEnv(["BOTCORD_GEMINI_BIN", "GEMINI_CLI_HOME"]),
+        }),
+        discoverFresh: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+        fallback: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+      };
     default:
       return null;
   }