@botcord/daemon 0.2.88 → 0.2.90

package/dist/system-context.d.ts

@@ -26,6 +26,7 @@
  */
 import type { GatewayInboundMessage } from "./gateway/index.js";
 import type { ActivityTracker } from "./activity-tracker.js";
+import type { SkillIndexOptions } from "./skill-index.js";
 /**
  * Async per-turn room-context builder (see `room-context.ts`). Returns the
  * rendered `[BotCord Room Context]` block, or `null` when there is nothing
@@ -59,6 +60,11 @@ export interface SystemContextDeps {
      * dirs each turn. Return null to suppress the block.
      */
     skillIndexBuilder?: (message: GatewayInboundMessage) => string | null;
+    /**
+     * Runtime/profile options for the default soft skill scanner. Kept lazy so
+     * hot-provisioned runtime changes are visible without rebuilding this closure.
+     */
+    skillIndexOptions?: (message: GatewayInboundMessage) => SkillIndexOptions;
 }
 /**
  * Build a {@link SystemContextBuilder} for the gateway dispatcher.

package/dist/system-context.js

@@ -112,7 +112,7 @@ export function createDaemonSystemContextBuilder(deps) {
         try {
             if (deps.skillIndexBuilder)
                 return deps.skillIndexBuilder(message);
-            return buildSoftSkillIndexPrompt(deps.agentId);
+            return buildSoftSkillIndexPrompt(deps.agentId, deps.skillIndexOptions?.(message) ?? {});
         }
         catch (err) {
             log.warn("system-context: skill index build failed — skipping skill block", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.88",
+  "version": "0.2.90",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -23,8 +23,8 @@
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.63.1",
     "ws": "^8.20.1",
-    "@botcord/cli": "^0.1.18",
-    "@botcord/protocol-core": "^0.2.13"
+    "@botcord/protocol-core": "^0.2.13",
+    "@botcord/cli": "^0.1.18"
   },
   "overrides": {
     "axios": "^1.15.2"

package/src/__tests__/runtime-discovery.test.ts

@@ -147,11 +147,14 @@ describe("collectRuntimeSnapshot", () => {
   });
 
   it("omits optional fields rather than emitting explicit undefineds", () => {
+    // Use a synthetic runtime id with no catalog strategy so the snapshot
+    // doesn't pick up a `models` field. Switching to "gemini" here would
+    // attach the built-in gemini model list.
     setRuntimes([
       {
-        id: "gemini",
-        displayName: "Gemini",
-        binary: "gemini",
+        id: "unknown-runtime",
+        displayName: "Unknown",
+        binary: "unknown",
         supportsRun: true,
         result: { available: true },
       },

package/src/__tests__/runtime-models.test.ts

@@ -380,4 +380,57 @@ describe("runtime model discovery parsers", () => {
       },
     ]);
   });
+
+  it("returns the built-in Gemini catalog and caches it under gemini.json", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "daemon-gemini-catalog-"));
+    const prevHome = process.env.HOME;
+    const prevCacheDir = process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+    try {
+      const home = path.join(tmp, "home");
+      const cacheDir = path.join(tmp, "catalog-cache");
+      mkdirSync(home, { recursive: true });
+      process.env.HOME = home;
+      process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = cacheDir;
+
+      const catalog = discoverRuntimeModelCatalog({
+        id: "gemini",
+        displayName: "Gemini CLI",
+        binary: "gemini",
+        supportsRun: true,
+        result: { available: true, path: path.join(tmp, "missing-gemini") },
+      });
+
+      const ids = catalog.models?.map((m) => m.id) ?? [];
+      // `auto` is the default — wizard should pre-select it.
+      expect(catalog.models?.find((m) => m.isDefault)?.id).toBe("auto");
+      // Spot-check the documented family is present.
+      expect(ids).toEqual(
+        expect.arrayContaining([
+          "auto",
+          "pro",
+          "flash",
+          "flash-lite",
+          "gemini-2.5-pro",
+          "gemini-2.5-flash",
+          "gemini-3-pro-preview",
+          "gemini-3.1-pro-preview",
+        ]),
+      );
+      // No per-turn parameters yet (thinkingLevel / thinkingBudget aren't
+      // exposed as CLI flags; we can't safely route them through `extraArgs`).
+      expect(catalog.parameters ?? []).toEqual([]);
+
+      // Cache persisted so subsequent calls don't re-touch settings.json.
+      expect(readdirSync(cacheDir)).toEqual(["gemini.json"]);
+      const payload = JSON.parse(readFileSync(path.join(cacheDir, "gemini.json"), "utf8"));
+      expect(payload.runtimeId).toBe("gemini");
+      expect(payload.catalog.models.map((m: { id: string }) => m.id)).toContain("gemini-2.5-flash");
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      if (prevCacheDir === undefined) delete process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+      else process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = prevCacheDir;
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -4,8 +4,10 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import {
   agentCodexHomeDir,
+  agentHermesHomeDir,
   agentWorkspaceDir,
 } from "../agent-workspace.js";
+import { hermesProfileHomeDir } from "../gateway/runtimes/hermes-agent.js";
 import {
   buildSoftSkillIndexPrompt,
   collectAgentSkillSnapshot,
@@ -37,27 +39,40 @@ afterEach(() => {
 });
 
 describe("skill snapshots", () => {
-  it("scans agent workspace/runtime-global skills and maps UI source buckets", () => {
+  it("scopes scans to the selected runtime and maps UI source buckets", () => {
     const agentId = "ag_skilltest";
-    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "workspace-skill", "Workspace skill");
-    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-skill", "Codex skill");
-    writeSkill(path.join(tmpDir, ".codex", "skills"), "global-skill", "Global skill");
+    const claudePath = path.join(agentWorkspaceDir(agentId), ".claude", "skills");
+    const codexPath = path.join(agentCodexHomeDir(agentId), "skills");
+    writeSkill(claudePath, "claude-skill", "Claude skill");
+    writeSkill(codexPath, "codex-skill", "Codex skill");
+    writeSkill(path.join(tmpDir, ".claude", "skills"), "global-claude", "Global Claude");
+    writeSkill(path.join(tmpDir, ".codex", "skills"), "global-codex", "Global Codex");
 
-    const scanned = scanSoftSkills(agentId);
-    expect(scanned.map((s) => s.name).sort()).toEqual([
+    const claudeScanned = scanSoftSkills(agentId, { runtime: "claude-code" });
+    expect(claudeScanned.map((s) => s.name).sort()).toEqual([
+      "claude-skill",
+      "global-claude",
+    ]);
+    expect(claudeScanned.every((s) => s.runtime === "claude-code")).toBe(true);
+
+    const codexScanned = scanSoftSkills(agentId, { runtime: "codex" });
+    expect(codexScanned.map((s) => s.name).sort()).toEqual([
       "codex-skill",
-      "global-skill",
-      "workspace-skill",
+      "global-codex",
     ]);
+    expect(codexScanned.every((s) => s.runtime === "codex")).toBe(true);
 
-    const snapshot = collectAgentSkillSnapshot(agentId);
+    const snapshot = collectAgentSkillSnapshot(agentId, { runtime: "codex" });
     expect(snapshot.agentId).toBe(agentId);
-    expect(snapshot.skills).toHaveLength(3);
-    expect(snapshot.skills.find((s) => s.name === "workspace-skill")?.source)
-      .toBe("workspace");
+    expect(snapshot.runtime).toBe("codex");
+    expect(snapshot.skills).toHaveLength(2);
     expect(snapshot.skills.find((s) => s.name === "codex-skill")?.source)
       .toBe("workspace");
-    expect(snapshot.skills.find((s) => s.name === "global-skill")?.source)
+    expect(snapshot.skills.find((s) => s.name === "codex-skill")?.sourceDetail)
+      .toBe("agent-codex");
+    expect(snapshot.skills.find((s) => s.name === "codex-skill")?.path)
+      .toBe(path.join(codexPath, "codex-skill", "SKILL.md"));
+    expect(snapshot.skills.find((s) => s.name === "global-codex")?.source)
       .toBe("runtime-global");
     expect(snapshot.probedAt).toBeGreaterThan(0);
   });
@@ -101,6 +116,67 @@ describe("skill snapshots", () => {
       .toBe("runtime-global");
   });
 
+  it("scans Hermes home/profile skills without mixing Claude or Codex dirs", () => {
+    const agentId = "ag_hermes_skills";
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "claude-only", "Claude only");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-only", "Codex only");
+    writeSkill(path.join(agentHermesHomeDir(agentId), "skills"), "hermes-only", "Hermes only");
+
+    const isolated = scanSoftSkills(agentId, { runtime: "hermes-agent" });
+    expect(isolated.map((s) => s.name)).toEqual(["hermes-only"]);
+    expect(isolated[0]).toMatchObject({
+      source: "agent-hermes",
+      runtime: "hermes-agent",
+    });
+
+    const profileAgentId = "ag_hermes_profile";
+    writeSkill(
+      path.join(hermesProfileHomeDir("writer"), "skills"),
+      "profile-skill",
+      "Hermes profile skill",
+    );
+    const profile = collectAgentSkillSnapshot(profileAgentId, {
+      runtime: "hermes-agent",
+      hermesProfile: "writer",
+    });
+    expect(profile.skills).toHaveLength(1);
+    expect(profile.skills[0]).toMatchObject({
+      name: "profile-skill",
+      source: "workspace",
+      sourceDetail: "agent-hermes-profile",
+      runtime: "hermes-agent",
+      profile: "writer",
+    });
+  });
+
+  it("keeps same-device workspace skills scoped by agent id", () => {
+    writeSkill(
+      path.join(agentWorkspaceDir("ag_workspace_a"), ".claude", "skills"),
+      "agent-local",
+      "Skill for agent A",
+    );
+    writeSkill(
+      path.join(agentWorkspaceDir("ag_workspace_b"), ".claude", "skills"),
+      "agent-local",
+      "Skill for agent B",
+    );
+
+    expect(scanSoftSkills("ag_workspace_a", { runtime: "claude-code" })).toEqual([
+      expect.objectContaining({
+        name: "agent-local",
+        description: "Skill for agent A",
+        source: "agent-claude",
+      }),
+    ]);
+    expect(scanSoftSkills("ag_workspace_b", { runtime: "claude-code" })).toEqual([
+      expect.objectContaining({
+        name: "agent-local",
+        description: "Skill for agent B",
+        source: "agent-claude",
+      }),
+    ]);
+  });
+
   it("returns complete snapshots while keeping the prompt soft index capped", () => {
     const agentId = "ag_manyskills";
     const workspaceSkills = path.join(agentWorkspaceDir(agentId), ".claude", "skills");

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,
         });
       }