@botcord/daemon 0.2.89 → 0.2.90

package/dist/cloud-daemon.js

@@ -76,6 +76,15 @@ export async function startCloudDaemon(opts) {
     const credentialPathByAgentId = new Map();
     const hubUrlByAgentId = new Map();
     const displayNameByAgent = new Map();
+    const runtimeByAgentId = new Map();
+    const hermesProfileByAgentId = new Map();
+    const skillIndexOptionsForAgent = (agentId) => {
+        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.
@@ -158,16 +167,16 @@ export async function startCloudDaemon(opts) {
         });
     };
     const installedAgentIds = new Set();
-    const runtimeByAgentId = new Map();
     let controlChannel = null;
     const pushInstalledAgentSkillSnapshot = (agentId, reason) => {
         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,
         });
@@ -176,6 +185,10 @@ export async function startCloudDaemon(opts) {
         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);
@@ -186,6 +199,7 @@ export async function startCloudDaemon(opts) {
                 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/dist/daemon.d.ts

@@ -3,6 +3,7 @@ import type { DaemonConfig } from "./config.js";
 import { type BootAgentsResult } from "./agent-discovery.js";
 import { ensureAgentWorkspace } from "./agent-workspace.js";
 import { UserAuthManager } from "./user-auth.js";
+import { type SkillIndexOptions } from "./skill-index.js";
 import { classifyActivitySender } from "./sender-classify.js";
 export { classifyActivitySender };
 /** Minimal activity-tracker surface the inbound observer uses. */
@@ -65,9 +66,7 @@ export interface RuntimeSnapshotSink {
  * or wait for the next daemon restart). Exported for unit tests.
  */
 export declare function pushRuntimeSnapshot(sink: RuntimeSnapshotSink, liveSnapshot?: GatewayRuntimeSnapshot): boolean;
-export declare function pushAgentSkillSnapshot(sink: RuntimeSnapshotSink, agentId: string, opts?: {
-    runtime?: string;
-}): boolean;
+export declare function pushAgentSkillSnapshot(sink: RuntimeSnapshotSink, agentId: string, opts?: SkillIndexOptions): boolean;
 /** Options accepted by {@link startDaemon} — the P0.5 compatibility shim. */
 export interface DaemonRuntimeOptions {
     config: DaemonConfig;

package/dist/daemon.js

@@ -221,6 +221,13 @@ export async function startDaemon(opts) {
     const agentIds = boot.agents.map((a) => a.agentId);
     const { credentialPathByAgentId, agentRuntimes } = backfillBootAgents(boot.agents, { logger });
     const gwConfig = toGatewayConfig(opts.config, { agentIds, agentRuntimes });
+    const skillIndexOptionsForAgent = (agentId) => {
+        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
     // `botcord` CLI talks to the same hub the agent is registered against,
@@ -273,6 +280,7 @@ export async function startDaemon(opts) {
             activityTracker,
             roomContextBuilder,
             loopRiskBuilder,
+            skillIndexOptions: () => skillIndexOptionsForAgent(aid),
         }));
     }
     const buildSystemContext = (message) => {
@@ -372,11 +380,16 @@ export async function startDaemon(opts) {
         // 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);
@@ -388,6 +401,7 @@ export async function startDaemon(opts) {
                 activityTracker,
                 roomContextBuilder,
                 loopRiskBuilder,
+                skillIndexOptions: () => skillIndexOptionsForAgent(info.agentId),
             }));
         }
     };
@@ -507,11 +521,12 @@ export async function startDaemon(opts) {
                 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/dist/provision.d.ts

@@ -18,6 +18,7 @@ export interface InstalledAgentInfo {
     hubUrl: string;
     displayName?: string;
     runtime?: string;
+    hermesProfile?: string;
 }
 /**
  * Hook fired after `installLocalAgent` / `installExistingOpenclawBinding`

package/dist/provision.js

@@ -20,12 +20,25 @@ 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 { installAgentSkillManifest, installBotLearnArchiveManifest, installVercelSkillsForAgent, } from "./skill-installer.js";
 import { buildRuntimeSelectionExtraArgs, mergeRuntimeExtraArgs, } from "./runtime-route-options.js";
 import { handleCloudGatewayRuntimeInbound, } from "./cloud-gateway-runtime.js";
-function runtimeForLoadedAgent(gateway, agentId) {
-    return gateway.listManagedRoutes()
-        .find((route) => route.match?.accountId === agentId)
-        ?.runtime;
+function skillIndexOptionsForLoadedAgent(gateway, agentId) {
+    const route = gateway.listManagedRoutes()
+        .find((entry) => entry.match?.accountId === agentId);
+    let credentials = 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 } : {}),
+    };
 }
 /**
  * Build a dispatcher function that routes a `ControlFrame` to the right
@@ -339,15 +352,76 @@ export function createProvisioner(opts) {
                         },
                     };
                 }
-                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 ?? {});
+                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);
             }
@@ -823,6 +897,7 @@ async function installLocalAgent(credentials, ctx) {
                 hubUrl: credentials.hubUrl,
                 ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
                 ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+                ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
             });
         }
         catch (err) {
@@ -904,6 +979,7 @@ async function installExistingOpenclawBinding(agentId, ctx) {
                 hubUrl: credentials.hubUrl,
                 ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
                 ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+                ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
             });
         }
         catch (err) {

package/dist/runtime-models.js

@@ -54,6 +54,36 @@ const KIMI_FALLBACK_MODELS = [
     { id: "kimi-k2-5-preview", displayName: "kimi-k2-5-preview", provider: "kimi", source: "builtin" },
     { 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 = [
+    { 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",
+    },
+];
 const backgroundRefreshes = new Set();
 export function discoverRuntimeModelCatalog(entry) {
     if (!entry.result.available)
@@ -126,6 +156,22 @@ function runtimeCatalogStrategy(entry) {
                     ],
                 }),
             };
+        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;
     }

package/dist/skill-index.d.ts

@@ -2,29 +2,41 @@ export interface SoftSkillEntry {
     name: string;
     path: string;
     source: string;
+    runtime?: string;
+    profile?: string;
     description?: string;
     mtimeMs: number;
 }
 export interface AgentSkillSnapshotEntry {
     name: string;
     source: string;
+    sourceDetail?: string;
+    runtime?: string;
+    path?: string;
+    profile?: string;
     description?: string;
     mtimeMs: number;
 }
 export interface AgentSkillSnapshot {
     agentId: string;
+    runtime?: string;
     skills: AgentSkillSnapshotEntry[];
     probedAt: number;
 }
 export interface SkillIndexOptions {
     extraDirs?: string[];
+    hermesProfile?: string;
     includeGlobal?: boolean;
     runtime?: string;
 }
-export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptions): Array<{
+interface SkillRoot {
     dir: string;
     source: string;
-}>;
+    runtime?: string;
+    profile?: string;
+}
+export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptions): SkillRoot[];
 export declare function scanSoftSkills(agentId: string, opts?: SkillIndexOptions): SoftSkillEntry[];
 export declare function collectAgentSkillSnapshot(agentId: string, opts?: SkillIndexOptions): AgentSkillSnapshot;
 export declare function buildSoftSkillIndexPrompt(agentId: string, opts?: SkillIndexOptions): string | null;
+export {};

package/dist/skill-index.js

@@ -1,7 +1,8 @@
 import { existsSync, readdirSync, readFileSync, statSync, } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import { agentCodexHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+import { agentCodexHomeDir, agentHermesHomeDir, agentWorkspaceDir, } from "./agent-workspace.js";
+import { hermesProfileHomeDir } from "./gateway/runtimes/hermes-agent.js";
 const MAX_SKILLS = 24;
 const MAX_DESCRIPTION_CHARS = 260;
 const MAX_SKILL_MD_READ_CHARS = 8192;
@@ -10,24 +11,50 @@ export function defaultSkillDirs(agentId, opts = {}) {
     const agentClaude = {
         dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
         source: "agent-claude",
+        runtime: "claude-code",
     };
     const agentCodex = {
         dir: path.join(agentCodexHomeDir(agentId), "skills"),
         source: "agent-codex",
+        runtime: "codex",
     };
-    const dirs = runtimeFamily(opts.runtime) === "codex"
-        ? [agentCodex, agentClaude]
-        : [agentClaude, agentCodex];
-    if (includeGlobal) {
-        const globalClaude = { dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" };
-        const globalCodex = { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" };
-        dirs.push(...(runtimeFamily(opts.runtime) === "codex"
-            ? [globalCodex, globalClaude]
-            : [globalClaude, globalCodex]));
+    const agentHermes = hermesSkillRoot(agentId, opts.hermesProfile);
+    const dirs = [];
+    switch (runtimeFamily(opts.runtime)) {
+        case "codex":
+            dirs.push(agentCodex);
+            if (includeGlobal) {
+                dirs.push({
+                    dir: path.join(homedir(), ".codex", "skills"),
+                    source: "global-codex",
+                    runtime: "codex",
+                });
+            }
+            break;
+        case "hermes":
+            dirs.push(agentHermes);
+            break;
+        case "claude":
+            dirs.push(agentClaude);
+            if (includeGlobal) {
+                dirs.push({
+                    dir: path.join(homedir(), ".claude", "skills"),
+                    source: "global-claude",
+                    runtime: "claude-code",
+                });
+            }
+            break;
+        case "other":
+            break;
     }
     const envDirs = parseSkillDirsEnv(process.env.BOTCORD_SKILL_DIRS);
     for (const dir of [...envDirs, ...(opts.extraDirs ?? [])]) {
-        dirs.push({ dir, source: "external" });
+        dirs.push({
+            dir,
+            source: "external",
+            ...(opts.runtime ? { runtime: opts.runtime } : {}),
+            ...(opts.hermesProfile ? { profile: opts.hermesProfile } : {}),
+        });
     }
     return dedupeDirs(expandSkillRoots(dirs));
 }
@@ -65,6 +92,8 @@ export function scanSoftSkills(agentId, opts = {}) {
                 name: parsed.name,
                 path: skillMd,
                 source: root.source,
+                ...(root.runtime ? { runtime: root.runtime } : {}),
+                ...(root.profile ? { profile: root.profile } : {}),
                 description: parsed.description,
                 mtimeMs: st.mtimeMs,
             };
@@ -79,9 +108,14 @@ export function scanSoftSkills(agentId, opts = {}) {
 export function collectAgentSkillSnapshot(agentId, opts = {}) {
     return {
         agentId,
+        ...(opts.runtime ? { runtime: opts.runtime } : {}),
         skills: scanSoftSkills(agentId, opts).map((skill) => ({
             name: skill.name,
-            source: skill.source.startsWith("agent-") ? "workspace" : "runtime-global",
+            source: snapshotSource(skill.source),
+            sourceDetail: skill.source,
+            ...(skill.runtime ? { runtime: skill.runtime } : {}),
+            path: skill.path,
+            ...(skill.profile ? { profile: skill.profile } : {}),
             ...(skill.description ? { description: skill.description } : {}),
             mtimeMs: skill.mtimeMs,
         })),
@@ -157,7 +191,7 @@ function dedupeDirs(dirs) {
         if (seen.has(resolved))
             continue;
         seen.add(resolved);
-        out.push({ dir: resolved, source: entry.source });
+        out.push({ ...entry, dir: resolved });
     }
     return out;
 }
@@ -166,46 +200,59 @@ function expandSkillRoots(dirs) {
     for (const entry of dirs) {
         out.push(entry);
         if (entry.source.includes("codex")) {
-            out.push({ dir: path.join(entry.dir, ".system"), source: entry.source });
+            out.push({ ...entry, dir: path.join(entry.dir, ".system") });
         }
     }
     return out;
 }
+function hermesSkillRoot(agentId, profile) {
+    if (profile) {
+        try {
+            return {
+                dir: path.join(hermesProfileHomeDir(profile), "skills"),
+                source: "agent-hermes-profile",
+                runtime: "hermes-agent",
+                profile,
+            };
+        }
+        catch {
+            // Corrupt legacy credentials should not make the whole skill snapshot fail.
+        }
+    }
+    return {
+        dir: path.join(agentHermesHomeDir(agentId), "skills"),
+        source: "agent-hermes",
+        runtime: "hermes-agent",
+    };
+}
 function runtimeFamily(runtime) {
     if (runtime === "codex")
         return "codex";
+    if (runtime === "hermes-agent")
+        return "hermes";
+    if (!runtime)
+        return "claude";
     if (runtime === "claude-code")
         return "claude";
     return "other";
 }
-function priority(source, runtime) {
-    if (runtimeFamily(runtime) === "codex") {
-        switch (source) {
-            case "agent-codex":
-                return 0;
-            case "global-codex":
-                return 1;
-            case "agent-claude":
-                return 2;
-            case "global-claude":
-                return 3;
-            default:
-                return 4;
-        }
-    }
+function priority(source, _runtime) {
     switch (source) {
         case "agent-claude":
-            return 0;
         case "agent-codex":
-            return 1;
+        case "agent-hermes":
+        case "agent-hermes-profile":
+            return 0;
         case "global-claude":
-            return 2;
         case "global-codex":
-            return 3;
+            return 1;
         default:
-            return 4;
+            return 2;
     }
 }
+function snapshotSource(source) {
+    return source.startsWith("agent-") ? "workspace" : "runtime-global";
+}
 function unquote(value) {
     const trimmed = value.trim();
     if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||

package/dist/skill-installer.d.ts

@@ -0,0 +1,61 @@
+import { type ExecFileOptions } from "node:child_process";
+import { type AgentSkillSnapshot } from "./skill-index.js";
+export type SkillInstallTarget = "claude-code" | "codex";
+export interface SkillFileManifest {
+    path: string;
+    content?: string;
+    sourcePath?: string;
+}
+export interface SkillManifestInput {
+    name?: string;
+    id?: string;
+    description?: string;
+    skillMd?: string;
+    markdown?: string;
+    files?: SkillFileManifest[];
+    targetRuntimes?: SkillInstallTarget[];
+}
+export interface SkillArchiveManifestInput {
+    name?: string;
+    id?: string;
+    description?: string;
+    skillMd?: string;
+    markdown?: string;
+    files?: SkillFileManifest[];
+    skills?: SkillManifestInput[];
+    targetRuntimes?: SkillInstallTarget[];
+}
+export interface NormalizedSkillManifest {
+    name: string;
+    description?: string;
+    skillMd: string;
+    files: SkillFileManifest[];
+    targetRuntimes?: SkillInstallTarget[];
+}
+export interface InstalledSkillRecord {
+    name: string;
+    targets: SkillInstallTarget[];
+    paths: string[];
+}
+export interface AgentSkillInstallResult {
+    agentId: string;
+    installed: InstalledSkillRecord[];
+    snapshot: AgentSkillSnapshot;
+}
+export interface InstallAgentSkillManifestOptions {
+    runtime?: string;
+    sourceRoot?: string;
+}
+export interface VercelSkillsInstallOptions {
+    agentId: string;
+    packageSpec: string;
+    skills?: string[];
+    runtime?: string;
+    executor?: VercelSkillsExecutor;
+}
+export type VercelSkillsExecutor = (command: string, args: string[], options: ExecFileOptions) => Promise<void>;
+export declare function normalizeSkillManifest(input: SkillManifestInput): NormalizedSkillManifest;
+export declare function installAgentSkillManifest(agentId: string, manifest: SkillManifestInput, opts?: InstallAgentSkillManifestOptions): AgentSkillInstallResult;
+export declare function installBotLearnArchiveManifest(agentId: string, archive: SkillArchiveManifestInput, opts?: InstallAgentSkillManifestOptions): AgentSkillInstallResult;
+export declare function installVercelSkillsForAgent(opts: VercelSkillsInstallOptions): Promise<AgentSkillInstallResult>;
+export declare function buildVercelSkillsArgs(packageSpec: string, skills: string[] | undefined, targets: SkillInstallTarget[]): string[];