@botcord/daemon 0.2.88 → 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/gateway/runtimes/gemini.d.ts

@@ -1,15 +1,67 @@
+import { NdjsonStreamAdapter, type NdjsonEventCtx } from "./ndjson-stream.js";
 import { type ProbeDeps } from "./probe.js";
-import type { RuntimeAdapter, RuntimeProbeResult, RuntimeRunOptions, RuntimeRunResult } from "../types.js";
+import type { RuntimeProbeResult, RuntimeRunOptions } from "../types.js";
 /** Resolve the Gemini CLI executable on PATH. */
 export declare function resolveGeminiCommand(deps?: ProbeDeps): string | null;
 /** Probe whether the Gemini CLI is installed and report its version. */
 export declare function probeGemini(deps?: ProbeDeps): RuntimeProbeResult;
 /**
- * Gemini adapter stub — probe() is wired up so `botcord-daemon doctor` can report it.
- * run() is not implemented yet; routing a turn here will surface the error upstream.
+ * Gemini adapter — spawns `gemini -p "<text>" --output-format stream-json
+ * --yolo` (with `--resume <sid>` for continuing sessions) and parses the
+ * newline-delimited JSON stream.
+ *
+ * stream-json event shape (abridged, sourced from `@google/gemini-cli`
+ * bundle `nonInteractiveCliAgentSession.ts`):
+ *
+ *   {type:"init", timestamp, session_id, model}
+ *   {type:"message", timestamp, role:"user", content}            // echo of input
+ *   {type:"message", timestamp, role:"assistant", content, delta:true}
+ *   {type:"tool_use", timestamp, tool_name, tool_id, parameters}
+ *   {type:"tool_result", timestamp, tool_id, status, output?, error?}
+ *   {type:"error", timestamp, severity, message}                 // non-fatal warning
+ *   {type:"result", timestamp, status:"success", stats}          // terminal
+ *   {type:"result", timestamp, status:"error", error:{type,message}, stats}
+ *
+ * Unlike Claude Code's `result` event, gemini's terminal event carries NO
+ * final assistant text — the reply must be assembled by concatenating every
+ * `message` event with `role:"assistant"` (the CLI emits them as deltas).
+ *
+ * ## systemContext
+ *
+ * Gemini's headless mode has no `--append-system-prompt` equivalent and
+ * `GEMINI_SYSTEM_MD` replaces the entire core system prompt (which would
+ * brick the agent — that core prompt scaffolds tool use). For v1 the
+ * adapter prepends `systemContext` directly to the positional prompt. Each
+ * turn re-injects the dynamic context so memory / digest updates take
+ * effect immediately; the trade-off is the resumed session transcript
+ * accumulates one prompt prefix per turn. Acceptable while we ship the
+ * connectivity layer — a follow-up can move systemContext into a
+ * daemon-managed `GEMINI.md` once we decide where to isolate it.
+ *
+ * ## Session continuity
+ *
+ * `gemini --session-id <uuid>` is for FRESH sessions only — it errors if
+ * the id already exists. `gemini --resume <uuid>` resolves the UUID against
+ * the project's existing session pool (gemini stores sessions per
+ * cwd-derived project hash, so the per-agent workspace already isolates
+ * them from the user's interactive sessions). We therefore:
+ *   - new turn (sessionId=null): omit both flags; capture `init.session_id`.
+ *   - continuation: pass `--resume <uuid>`. If gemini cannot resolve the id
+ *     it exits with `FATAL_INPUT_ERROR` and stderr; we surface that as
+ *     `errorText` and wipe `newSessionId` so the dispatcher discards the
+ *     stale entry.
  */
-export declare class GeminiAdapter implements RuntimeAdapter {
+export declare class GeminiAdapter extends NdjsonStreamAdapter {
     readonly id: "gemini";
+    private readonly explicitBinary;
+    private resolvedBinary;
+    constructor(opts?: {
+        binary?: string;
+    });
     probe(): RuntimeProbeResult;
-    run(_opts: RuntimeRunOptions): Promise<RuntimeRunResult>;
+    run(opts: RuntimeRunOptions): Promise<import("../types.js").RuntimeRunResult>;
+    protected resolveBinary(): string;
+    protected buildArgs(opts: RuntimeRunOptions): string[];
+    protected spawnEnv(opts: RuntimeRunOptions): NodeJS.ProcessEnv;
+    protected handleEvent(raw: unknown, ctx: NdjsonEventCtx): void;
 }

package/dist/gateway/runtimes/gemini.js

@@ -1,4 +1,79 @@
+import { NdjsonStreamAdapter } from "./ndjson-stream.js";
 import { readCommandVersion, resolveCommandOnPath, } from "./probe.js";
+/**
+ * Gemini's `--session-id` / `--resume` accept only `[A-Za-z0-9-_]+` and we
+ * forward whatever the CLI emitted in its `init` event. Rejecting anything
+ * else keeps argv safe even if the upstream session id format ever changes.
+ */
+const GEMINI_SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+function isValidGeminiSessionId(id) {
+    return GEMINI_SESSION_ID_RE.test(id);
+}
+function invalidGeminiSessionIdError(id) {
+    return `gemini: invalid sessionId ${JSON.stringify(id)} (expected [A-Za-z0-9_-]+)`;
+}
+/**
+ * Drop adapter-foreign flags inherited from other runtimes' route configs
+ * (claude-code, codex). Each entry that takes a value also swallows the
+ * value that follows. Anything else is forwarded verbatim so operators can
+ * still push gemini-native flags through.
+ */
+const GEMINI_FOREIGN_FLAGS_WITH_VALUE = new Set([
+    "--append-system-prompt",
+    "--permission-mode",
+    "--setting-sources",
+    "--sandbox",
+    "-c",
+]);
+const GEMINI_FOREIGN_BOOLEAN_FLAGS = new Set([
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--full-auto",
+    "--skip-git-repo-check",
+    "--json",
+    "--verbose",
+]);
+function extraFlagName(arg) {
+    if (!arg.startsWith("-"))
+        return arg;
+    const eq = arg.indexOf("=");
+    return eq === -1 ? arg : arg.slice(0, eq);
+}
+function nextExtraValue(args, index) {
+    const next = args[index + 1];
+    if (typeof next !== "string")
+        return undefined;
+    if (!next.startsWith("-"))
+        return next;
+    return /^-\d/.test(next) ? next : undefined;
+}
+function sanitizeGeminiExtraArgs(extraArgs) {
+    if (!extraArgs?.length)
+        return [];
+    const out = [];
+    for (let i = 0; i < extraArgs.length; i += 1) {
+        const arg = extraArgs[i];
+        const name = extraFlagName(arg);
+        if (GEMINI_FOREIGN_FLAGS_WITH_VALUE.has(name)) {
+            if (!arg.includes("=") && nextExtraValue(extraArgs, i) !== undefined)
+                i += 1;
+            continue;
+        }
+        if (GEMINI_FOREIGN_BOOLEAN_FLAGS.has(name)) {
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+function hasFlag(args, name) {
+    for (const arg of args) {
+        if (arg === name)
+            return true;
+        if (arg.startsWith(`${name}=`))
+            return true;
+    }
+    return false;
+}
 /** Resolve the Gemini CLI executable on PATH. */
 export function resolveGeminiCommand(deps = {}) {
     return resolveCommandOnPath("gemini", deps);
@@ -15,15 +90,201 @@ export function probeGemini(deps = {}) {
     };
 }
 /**
- * Gemini adapter stub — probe() is wired up so `botcord-daemon doctor` can report it.
- * run() is not implemented yet; routing a turn here will surface the error upstream.
+ * Gemini adapter — spawns `gemini -p "<text>" --output-format stream-json
+ * --yolo` (with `--resume <sid>` for continuing sessions) and parses the
+ * newline-delimited JSON stream.
+ *
+ * stream-json event shape (abridged, sourced from `@google/gemini-cli`
+ * bundle `nonInteractiveCliAgentSession.ts`):
+ *
+ *   {type:"init", timestamp, session_id, model}
+ *   {type:"message", timestamp, role:"user", content}            // echo of input
+ *   {type:"message", timestamp, role:"assistant", content, delta:true}
+ *   {type:"tool_use", timestamp, tool_name, tool_id, parameters}
+ *   {type:"tool_result", timestamp, tool_id, status, output?, error?}
+ *   {type:"error", timestamp, severity, message}                 // non-fatal warning
+ *   {type:"result", timestamp, status:"success", stats}          // terminal
+ *   {type:"result", timestamp, status:"error", error:{type,message}, stats}
+ *
+ * Unlike Claude Code's `result` event, gemini's terminal event carries NO
+ * final assistant text — the reply must be assembled by concatenating every
+ * `message` event with `role:"assistant"` (the CLI emits them as deltas).
+ *
+ * ## systemContext
+ *
+ * Gemini's headless mode has no `--append-system-prompt` equivalent and
+ * `GEMINI_SYSTEM_MD` replaces the entire core system prompt (which would
+ * brick the agent — that core prompt scaffolds tool use). For v1 the
+ * adapter prepends `systemContext` directly to the positional prompt. Each
+ * turn re-injects the dynamic context so memory / digest updates take
+ * effect immediately; the trade-off is the resumed session transcript
+ * accumulates one prompt prefix per turn. Acceptable while we ship the
+ * connectivity layer — a follow-up can move systemContext into a
+ * daemon-managed `GEMINI.md` once we decide where to isolate it.
+ *
+ * ## Session continuity
+ *
+ * `gemini --session-id <uuid>` is for FRESH sessions only — it errors if
+ * the id already exists. `gemini --resume <uuid>` resolves the UUID against
+ * the project's existing session pool (gemini stores sessions per
+ * cwd-derived project hash, so the per-agent workspace already isolates
+ * them from the user's interactive sessions). We therefore:
+ *   - new turn (sessionId=null): omit both flags; capture `init.session_id`.
+ *   - continuation: pass `--resume <uuid>`. If gemini cannot resolve the id
+ *     it exits with `FATAL_INPUT_ERROR` and stderr; we surface that as
+ *     `errorText` and wipe `newSessionId` so the dispatcher discards the
+ *     stale entry.
  */
-export class GeminiAdapter {
+export class GeminiAdapter extends NdjsonStreamAdapter {
     id = "gemini";
+    explicitBinary;
+    resolvedBinary = null;
+    constructor(opts) {
+        super();
+        this.explicitBinary = opts?.binary ?? process.env.BOTCORD_GEMINI_BIN;
+    }
     probe() {
         return probeGemini();
     }
-    async run(_opts) {
-        throw new Error("gemini adapter not implemented");
+    async run(opts) {
+        if (opts.sessionId && !isValidGeminiSessionId(opts.sessionId)) {
+            throw new Error(invalidGeminiSessionIdError(opts.sessionId));
+        }
+        return super.run(opts);
+    }
+    resolveBinary() {
+        if (this.explicitBinary)
+            return this.explicitBinary;
+        if (this.resolvedBinary)
+            return this.resolvedBinary;
+        this.resolvedBinary = resolveGeminiCommand() ?? "gemini";
+        return this.resolvedBinary;
+    }
+    buildArgs(opts) {
+        const extraArgs = sanitizeGeminiExtraArgs(opts.extraArgs);
+        const args = [
+            "-p",
+            composePrompt(opts.text, opts.systemContext),
+            "--output-format",
+            "stream-json",
+        ];
+        // Daemon-driven gemini turns are non-interactive. Auto-approve all tool
+        // use to avoid deadlocks; operators with stricter requirements can
+        // override via extraArgs `--approval-mode plan` etc.
+        if (!hasFlag(extraArgs, "--approval-mode") &&
+            !hasFlag(extraArgs, "-y") &&
+            !hasFlag(extraArgs, "--yolo")) {
+            args.push("--yolo");
+        }
+        // Trust the workspace so gemini doesn't downgrade the approval mode the
+        // moment cwd isn't in `~/.gemini/trustedFolders.json`. Without this the
+        // CLI silently flips back to "default" approval — which then deadlocks
+        // on tool calls because we have no prompt relay.
+        if (!hasFlag(extraArgs, "--skip-trust")) {
+            args.push("--skip-trust");
+        }
+        if (opts.sessionId) {
+            if (!isValidGeminiSessionId(opts.sessionId)) {
+                throw new Error(invalidGeminiSessionIdError(opts.sessionId));
+            }
+            args.push("--resume", opts.sessionId);
+        }
+        if (extraArgs.length)
+            args.push(...extraArgs);
+        return args;
+    }
+    spawnEnv(opts) {
+        return {
+            ...super.spawnEnv(opts),
+            // Keep stream-json clean regardless of the user's terminal settings.
+            FORCE_COLOR: "0",
+            NO_COLOR: "1",
+            // Prevent gemini's launcher from re-spawning itself with --max-old-space
+            // tuning; the relaunch races with our stdio piping in tests and shaves
+            // ~200ms off every spawn in production.
+            GEMINI_CLI_NO_RELAUNCH: "1",
+        };
+    }
+    handleEvent(raw, ctx) {
+        const obj = raw;
+        const status = geminiStatusEvent(obj);
+        if (status)
+            ctx.emitStatus(status);
+        ctx.emitBlock(normalizeBlock(obj, ctx.seq));
+        if (obj.type === "init" && typeof obj.session_id === "string") {
+            ctx.state.newSessionId = obj.session_id;
+            return;
+        }
+        if (obj.type === "message" && obj.role === "assistant" && typeof obj.content === "string") {
+            ctx.appendAssistantText(obj.content);
+            return;
+        }
+        if (obj.type === "result") {
+            if (obj.status === "error") {
+                const errMsg = obj.error?.message;
+                ctx.state.errorText =
+                    typeof errMsg === "string" && errMsg ? errMsg : "gemini run failed";
+                // Drop the captured session id so the dispatcher doesn't try to
+                // resume a session that may not have been persisted to disk.
+                ctx.state.newSessionId = "";
+                ctx.state.finalText = "";
+                ctx.state.assistantTextChunks = [];
+                ctx.state.assistantTextBytes = 0;
+            }
+            return;
+        }
+        if (obj.type === "error" && obj.severity === "error" && typeof obj.message === "string") {
+            // Severity "error" is fatal in gemini's classification; "warning" is
+            // recoverable and shouldn't override the assistant's output.
+            ctx.state.errorText = obj.message;
+        }
+    }
+}
+/**
+ * Prepend systemContext to the user prompt. Empty systemContext (the common
+ * case for direct DMs) returns the prompt unchanged so we don't bloat the
+ * token count with a marker prefix that conveys nothing.
+ */
+function composePrompt(text, systemContext) {
+    if (!systemContext || !systemContext.trim())
+        return text;
+    return `${systemContext.trim()}\n\n---\n\n${text}`;
+}
+/**
+ * Map a gemini stream-json event to a `RuntimeStatusEvent`. Only the
+ * lifecycle transitions the dispatcher can't infer from `StreamBlock.kind`
+ * land here; everything else is left to auto-synthesis.
+ */
+function geminiStatusEvent(obj) {
+    if (obj.type === "init") {
+        return { kind: "thinking", phase: "started", label: "Starting session" };
+    }
+    if (obj.type === "tool_use") {
+        const name = typeof obj.tool_name === "string" && obj.tool_name ? obj.tool_name : "tool";
+        return { kind: "thinking", phase: "updated", label: name };
+    }
+    if (obj.type === "message" && obj.role === "assistant") {
+        return { kind: "thinking", phase: "stopped" };
+    }
+    if (obj.type === "result") {
+        return { kind: "thinking", phase: "stopped" };
+    }
+    return undefined;
+}
+function normalizeBlock(obj, seq) {
+    let kind = "other";
+    const type = obj?.type;
+    if (type === "message" && obj?.role === "assistant") {
+        kind = "assistant_text";
+    }
+    else if (type === "tool_use") {
+        kind = "tool_use";
+    }
+    else if (type === "tool_result") {
+        kind = "tool_result";
+    }
+    else if (type === "init" || type === "result") {
+        kind = "system";
     }
+    return { raw: obj, kind, seq };
 }

package/dist/gateway/runtimes/registry.d.ts

@@ -39,7 +39,7 @@ export declare const deepseekTuiModule: RuntimeModule;
 export declare const kimiModule: RuntimeModule;
 /** Built-in runtime module entry for Hermes Agent (ACP stdio). */
 export declare const hermesAgentModule: RuntimeModule;
-/** Built-in runtime module entry for Gemini (probe-only stub). */
+/** Built-in runtime module entry for Gemini CLI. */
 export declare const geminiModule: RuntimeModule;
 /** Built-in runtime module entry for OpenClaw (ACP). */
 export declare const openclawAcpModule: RuntimeModule;

package/dist/gateway/runtimes/registry.js

@@ -51,14 +51,15 @@ export const hermesAgentModule = {
     create: () => new HermesAgentAdapter(),
     installHint: 'Install: pip install "hermes-agent[acp]"  (or set BOTCORD_HERMES_AGENT_BIN to the absolute path of hermes-acp)',
 };
-/** Built-in runtime module entry for Gemini (probe-only stub). */
+/** Built-in runtime module entry for Gemini CLI. */
 export const geminiModule = {
     id: "gemini",
     displayName: "Gemini CLI",
     binary: "gemini",
+    envVar: "BOTCORD_GEMINI_BIN",
     probe: () => probeGemini(),
     create: () => new GeminiAdapter(),
-    supportsRun: false,
+    installHint: "Install with `npm install -g @google/gemini-cli` (or `brew install gemini-cli`) and run `gemini` once to complete authentication. Override the binary with BOTCORD_GEMINI_BIN.",
 };
 /** Built-in runtime module entry for OpenClaw (ACP). */
 export const openclawAcpModule = {

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) {