@botcord/daemon 0.2.89 → 0.2.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.89",
+  "version": "0.2.91",
   "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.19"
   },
   "overrides": {
     "axios": "^1.15.2"

package/src/__tests__/provision.test.ts

@@ -336,6 +336,29 @@ describe("wake_agent handler", () => {
     });
   });
 
+  it("acks wake_agent after queueing instead of waiting for the turn to finish", async () => {
+    const gw = makeFakeGateway(["ag_wake"]);
+    gw.injectInbound.mockImplementation(() => new Promise(() => undefined));
+    const handler = createProvisioner({ gateway: gw as any });
+
+    const res = await Promise.race([
+      handler({
+        id: "req_wake_pending",
+        type: "wake_agent",
+        params: {
+          agent_id: "ag_wake",
+          message: "tick",
+          run_id: "sr_pending",
+        },
+      }),
+      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 20)),
+    ]);
+
+    expect(res).not.toBe("timeout");
+    expect(res).toMatchObject({ ok: true, result: { agent_id: "ag_wake", queued: true } });
+    expect(gw.injectInbound).toHaveBeenCalledTimes(1);
+  });
+
   it("rejects wake_agent for an unloaded agent", async () => {
     const gw = makeFakeGateway(["ag_loaded"]);
     const handler = createProvisioner({ gateway: gw as any });

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__/self-restart.test.ts

@@ -0,0 +1,57 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { findDaemonInstallPrefix } from "../self-restart.js";
+
+describe("self restart install prefix detection", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), "botcord-self-restart-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("finds the npm install prefix for a managed @botcord/daemon entrypoint", () => {
+    const prefix = path.join(tmpDir, ".botcord", "daemon");
+    const packageRoot = path.join(prefix, "node_modules", "@botcord", "daemon");
+    const entrypoint = path.join(packageRoot, "dist", "index.js");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    writeFileSync(path.join(packageRoot, "package.json"), '{"name":"@botcord/daemon"}');
+    writeFileSync(entrypoint, "");
+
+    expect(findDaemonInstallPrefix(entrypoint)).toBe(prefix);
+  });
+
+  it("resolves npm .bin symlinks before looking for the package root", () => {
+    const prefix = path.join(tmpDir, ".botcord", "daemon");
+    const packageRoot = path.join(prefix, "node_modules", "@botcord", "daemon");
+    const entrypoint = path.join(packageRoot, "dist", "index.js");
+    const bin = path.join(prefix, "node_modules", ".bin", "botcord-daemon");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    mkdirSync(path.dirname(bin), { recursive: true });
+    writeFileSync(path.join(packageRoot, "package.json"), '{"name":"@botcord/daemon"}');
+    writeFileSync(entrypoint, "");
+    symlinkSync(entrypoint, bin);
+
+    expect(findDaemonInstallPrefix(bin)).toBe(realpathSync(prefix));
+  });
+
+  it("does not treat a monorepo development entrypoint as self-updatable", () => {
+    const entrypoint = path.join(tmpDir, "packages", "daemon", "dist", "index.js");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    writeFileSync(entrypoint, "");
+
+    expect(findDaemonInstallPrefix(entrypoint)).toBeNull();
+  });
+});

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,108 @@ 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("scans Gemini workspace and user skill roots without mixing Claude or Codex dirs", () => {
+    const agentId = "ag_gemini_skills";
+    const workspaceGemini = path.join(agentWorkspaceDir(agentId), ".gemini", "skills");
+    const workspaceAgents = path.join(agentWorkspaceDir(agentId), ".agents", "skills");
+    writeSkill(workspaceGemini, "workspace-gemini", "Workspace Gemini skill");
+    writeSkill(workspaceAgents, "workspace-agent", "Workspace shared-agent skill");
+    writeSkill(path.join(tmpDir, ".gemini", "skills"), "global-gemini", "Global Gemini skill");
+    writeSkill(path.join(tmpDir, ".agents", "skills"), "global-agent", "Global shared-agent skill");
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "claude-only", "Claude only");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-only", "Codex only");
+
+    const geminiScanned = scanSoftSkills(agentId, { runtime: "gemini" });
+    expect(geminiScanned.map((s) => s.name)).toEqual([
+      "global-agent",
+      "global-gemini",
+      "workspace-agent",
+      "workspace-gemini",
+    ]);
+    expect(geminiScanned.every((s) => s.runtime === "gemini")).toBe(true);
+
+    const snapshot = collectAgentSkillSnapshot(agentId, { runtime: "gemini" });
+    expect(snapshot.runtime).toBe("gemini");
+    expect(snapshot.skills.find((s) => s.name === "workspace-gemini"))
+      .toMatchObject({
+        source: "workspace",
+        sourceDetail: "agent-gemini",
+        runtime: "gemini",
+        path: path.join(workspaceGemini, "workspace-gemini", "SKILL.md"),
+      });
+    expect(snapshot.skills.find((s) => s.name === "workspace-agent"))
+      .toMatchObject({
+        source: "workspace",
+        sourceDetail: "agent-agents",
+      });
+    expect(snapshot.skills.find((s) => s.name === "global-agent"))
+      .toMatchObject({
+        source: "runtime-global",
+        sourceDetail: "global-agents",
+      });
+  });
+
+  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,