@botcord/daemon 0.2.5 → 0.2.6

package/dist/agent-discovery.d.ts

@@ -24,6 +24,10 @@ export interface DiscoveredAgentCredential {
     runtime?: string;
     /** Working directory cached alongside `runtime`. */
     cwd?: string;
+    /** OpenClaw gateway profile name from credentials (only meaningful for openclaw-acp). */
+    openclawGateway?: string;
+    /** OpenClaw agent profile override from credentials. */
+    openclawAgent?: string;
     /** Key id from the credentials file — surfaced so boot-time workspace
      * seeding (see daemon-agent-workspace-plan.md §9) can render identity.md
      * without re-reading the file. */

package/dist/agent-discovery.js

@@ -94,6 +94,10 @@ export function discoverAgentCredentials(opts = {}) {
             entry.runtime = creds.runtime;
         if (creds.cwd)
             entry.cwd = creds.cwd;
+        if (creds.openclawGateway)
+            entry.openclawGateway = creds.openclawGateway;
+        if (creds.openclawAgent)
+            entry.openclawAgent = creds.openclawAgent;
         if (creds.keyId)
             entry.keyId = creds.keyId;
         if (creds.savedAt)
@@ -153,6 +157,10 @@ export function resolveBootAgents(cfg, opts = {}) {
                     entry.runtime = creds.runtime;
                 if (creds.cwd)
                     entry.cwd = creds.cwd;
+                if (creds.openclawGateway)
+                    entry.openclawGateway = creds.openclawGateway;
+                if (creds.openclawAgent)
+                    entry.openclawAgent = creds.openclawAgent;
                 if (creds.keyId)
                     entry.keyId = creds.keyId;
                 if (creds.savedAt)

package/dist/agent-workspace.d.ts

@@ -8,6 +8,20 @@ export declare function agentStateDir(agentId: string): string;
  * here — neither touching `~/.codex/` nor the agent's `workspace/` cwd.
  */
 export declare function agentCodexHomeDir(agentId: string): string;
+/**
+ * Per-agent HERMES_HOME. Carries the hermes-acp `.env`, `state.db`, and
+ * `skills/` so each daemon-managed agent has an isolated hermes config
+ * tree and never reads/writes the user's `~/.hermes`.
+ */
+export declare function agentHermesHomeDir(agentId: string): string;
+/**
+ * Per-agent runtime cwd for hermes-acp. Distinct from `workspace/` so the
+ * adapter can rewrite `AGENTS.md` here every turn (carrying the dynamic
+ * systemContext) without clobbering the user/agent-editable workspace
+ * `AGENTS.md`. hermes discovers `AGENTS.md` from cwd upward, so the file
+ * must live alongside the spawn cwd.
+ */
+export declare function agentHermesWorkspaceDir(agentId: string): string;
 export interface WorkspaceSeed {
     displayName?: string;
     bio?: string;
@@ -22,6 +36,16 @@ export interface WorkspaceSeed {
  * — the codex adapter writes it fresh per turn from `systemContext`.
  */
 export declare function ensureAgentCodexHome(agentId: string): string;
+/**
+ * Idempotently create the per-agent HERMES_HOME and HERMES workspace
+ * directories. Writes a stub `.env` inside HERMES_HOME so hermes-acp's
+ * `_load_env` does not log "No .env found" on every spawn; users can edit
+ * this file to add API keys / model overrides.
+ */
+export declare function ensureAgentHermesWorkspace(agentId: string): {
+    hermesHome: string;
+    hermesWorkspace: string;
+};
 /**
  * Idempotently create the agent's home / workspace / state directories and
  * seed the workspace Markdown files. Existing files are never overwritten —
@@ -29,3 +53,41 @@ export declare function ensureAgentCodexHome(agentId: string): string;
  * State files are not touched here; working-memory.ts owns `state/`.
  */
 export declare function ensureAgentWorkspace(agentId: string, seed: WorkspaceSeed): void;
+/** Patch fields accepted by {@link applyAgentIdentity}. `bio = null` clears it. */
+export interface AgentIdentityPatch {
+    displayName?: string;
+    bio?: string | null;
+}
+/**
+ * Result of applying an identity patch. `changed` is true only when the
+ * file was rewritten on disk; `skipped` reports why (no-op vs. unable).
+ */
+export interface AgentIdentityApplyResult {
+    changed: boolean;
+    skipped?: "missing-file" | "no-change" | "unparseable";
+}
+/**
+ * Surgically rewrite the `Display name` and `Bio` fields inside an existing
+ * `identity.md`, preserving anything the user has authored elsewhere
+ * (Role / Boundaries / arbitrary new sections). No-op when the file is
+ * missing — provisioning will create it with the correct values, and
+ * subsequent hello snapshots simply reapply the dashboard truth.
+ *
+ * The identity.md template carries `Role` / `Boundaries` headings after
+ * `## Bio`; we anchor the Bio rewrite on "next `##`" so user-added
+ * paragraphs inside Bio are replaced wholesale (the dashboard is the
+ * source of truth) without disturbing siblings.
+ */
+export declare function applyAgentIdentity(agentId: string, patch: AgentIdentityPatch): AgentIdentityApplyResult;
+/**
+ * Read the agent's `identity.md` verbatim, if it exists. Returns the raw
+ * contents (including the leading `# Identity` heading) so callers can
+ * splice it into the system context. Returns `null` when the workspace
+ * has not been provisioned yet, the file is empty, or the read fails.
+ *
+ * Each call hits disk — same contract as `readWorkingMemory`, so a
+ * dashboard-driven edit (`applyAgentIdentity` from a control frame, or
+ * a hello-snapshot reapply, or the agent's own self-edit) is visible
+ * on the very next turn without restarting the gateway.
+ */
+export declare function readIdentity(agentId: string): string | null;

package/dist/agent-workspace.js

@@ -7,8 +7,16 @@
  *   codex-home/  — per-agent CODEX_HOME used by the codex adapter so codex
  *                  reads a daemon-written AGENTS.md (systemContext carrier)
  *                  and stores its sessions/ without touching ~/.codex.
+ *   hermes-home/      — per-agent HERMES_HOME used by the hermes-acp
+ *                       adapter (carries .env, state.db, skills/) so
+ *                       hermes-acp's per-user state stays isolated.
+ *   hermes-workspace/ — per-agent runtime cwd for hermes-acp; the adapter
+ *                       writes systemContext into AGENTS.md here every turn.
+ *                       Kept separate from `workspace/` so daemon-written
+ *                       systemContext does not clobber the user/agent-
+ *                       editable workspace AGENTS.md.
  */
-import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 // Accepted agent id pattern. Enforced at every path-builder entry so a
@@ -42,6 +50,24 @@ export function agentStateDir(agentId) {
 export function agentCodexHomeDir(agentId) {
     return path.join(agentHomeDir(agentId), "codex-home");
 }
+/**
+ * Per-agent HERMES_HOME. Carries the hermes-acp `.env`, `state.db`, and
+ * `skills/` so each daemon-managed agent has an isolated hermes config
+ * tree and never reads/writes the user's `~/.hermes`.
+ */
+export function agentHermesHomeDir(agentId) {
+    return path.join(agentHomeDir(agentId), "hermes-home");
+}
+/**
+ * Per-agent runtime cwd for hermes-acp. Distinct from `workspace/` so the
+ * adapter can rewrite `AGENTS.md` here every turn (carrying the dynamic
+ * systemContext) without clobbering the user/agent-editable workspace
+ * `AGENTS.md`. hermes discovers `AGENTS.md` from cwd upward, so the file
+ * must live alongside the spawn cwd.
+ */
+export function agentHermesWorkspaceDir(agentId) {
+    return path.join(agentHomeDir(agentId), "hermes-workspace");
+}
 const AGENTS_MD = `# Agent Workspace
 
 This directory is your persistent workspace. You run with \`cwd\` set here.
@@ -62,19 +88,23 @@ This directory is your persistent workspace. You run with \`cwd\` set here.
 
 ## How to use this
 
-You are **instructed** to skim \`identity.md\`, \`memory.md\`, \`task.md\` before each
-response and to write back what changed after meaningful turns. Nothing in the
-runtime enforces this — the daemon does not auto-load these files into your
-context. Treat AGENTS.md as a convention, not a mechanism.
+- \`identity.md\` is **auto-loaded** by the daemon and injected into every turn's
+  system context as the \`[BotCord Identity]\` block. Edits to this file (yours,
+  the dashboard's via \`applyAgentIdentity\`, or a hello-snapshot reapply) take
+  effect on the next turn — no restart needed.
+- \`memory.md\` and \`task.md\` are **convention, not mechanism**. The daemon does
+  not auto-load them; you are instructed to skim them before responding and to
+  write back what changed after meaningful turns. Keep them tight enough to be
+  worth re-reading.
 `;
 const MEMORY_MD = `# Memory
 
 <!--
 Long-lived facts about the user, past decisions, and preferences that should
 survive across conversations. Organize by topic. Keep entries short. Prune
-regularly — AGENTS.md instructs the runtime to consult this file before each
-response, but nothing loads it automatically; keep it short enough to be
-worth re-reading.
+regularly — AGENTS.md instructs you to consult this file before each
+response, but nothing loads it automatically (unlike identity.md); keep it
+short enough to be worth re-reading.
 -->
 `;
 const TASK_MD = `# Current Task
@@ -190,6 +220,21 @@ export function ensureAgentCodexHome(agentId) {
     linkCodexAuth(dir);
     return dir;
 }
+/**
+ * Idempotently create the per-agent HERMES_HOME and HERMES workspace
+ * directories. Writes a stub `.env` inside HERMES_HOME so hermes-acp's
+ * `_load_env` does not log "No .env found" on every spawn; users can edit
+ * this file to add API keys / model overrides.
+ */
+export function ensureAgentHermesWorkspace(agentId) {
+    const hermesHome = agentHermesHomeDir(agentId);
+    const hermesWorkspace = agentHermesWorkspaceDir(agentId);
+    mkdirTolerant(hermesHome);
+    mkdirTolerant(hermesWorkspace);
+    writeIfMissing(path.join(hermesHome, ".env"), "# hermes-agent environment overrides for this BotCord agent.\n" +
+        "# Add e.g. HERMES_INFERENCE_PROVIDER=openrouter, OPENROUTER_API_KEY=...\n");
+    return { hermesHome, hermesWorkspace };
+}
 /**
  * Idempotently create the agent's home / workspace / state directories and
  * seed the workspace Markdown files. Existing files are never overwritten —
@@ -208,6 +253,7 @@ export function ensureAgentWorkspace(agentId, seed) {
     mkdirTolerant(notes);
     mkdirTolerant(state);
     ensureAgentCodexHome(agentId);
+    ensureAgentHermesWorkspace(agentId);
     const agentsMdPath = path.join(workspace, "AGENTS.md");
     const claudeMdPath = path.join(workspace, "CLAUDE.md");
     writeIfMissing(agentsMdPath, AGENTS_MD);
@@ -217,3 +263,89 @@ export function ensureAgentWorkspace(agentId, seed) {
     writeIfMissing(path.join(workspace, "task.md"), TASK_MD);
     writeIfMissing(path.join(notes, ".gitkeep"), "");
 }
+const DISPLAY_NAME_LINE = /^- \*\*Display name\*\*: .*$/m;
+// Match the Bio section's body. Anchor on the next `##` heading when one
+// exists, otherwise consume to end-of-file — keeps the rewrite working when
+// the user has stripped Role/Boundaries sections.
+const BIO_SECTION = /(## Bio\n\n)([\s\S]*?)(\n+##\s|$)/;
+/**
+ * Surgically rewrite the `Display name` and `Bio` fields inside an existing
+ * `identity.md`, preserving anything the user has authored elsewhere
+ * (Role / Boundaries / arbitrary new sections). No-op when the file is
+ * missing — provisioning will create it with the correct values, and
+ * subsequent hello snapshots simply reapply the dashboard truth.
+ *
+ * The identity.md template carries `Role` / `Boundaries` headings after
+ * `## Bio`; we anchor the Bio rewrite on "next `##`" so user-added
+ * paragraphs inside Bio are replaced wholesale (the dashboard is the
+ * source of truth) without disturbing siblings.
+ */
+export function applyAgentIdentity(agentId, patch) {
+    assertSafeAgentId(agentId);
+    const file = path.join(agentWorkspaceDir(agentId), "identity.md");
+    if (!existsSync(file)) {
+        return { changed: false, skipped: "missing-file" };
+    }
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        return { changed: false, skipped: "missing-file" };
+    }
+    const original = text;
+    let touched = false;
+    if (typeof patch.displayName === "string") {
+        const value = patch.displayName.length > 0 ? patch.displayName : FIELD_PLACEHOLDER;
+        if (DISPLAY_NAME_LINE.test(text)) {
+            // Use a function replacer so `$1`, `$&` etc. inside the value are
+            // treated literally rather than as backreferences.
+            text = text.replace(DISPLAY_NAME_LINE, () => `- **Display name**: ${value}`);
+            touched = true;
+        }
+        else {
+            // Heavily-edited file without the canonical metadata block — bail
+            // out rather than guess where to splice.
+            return { changed: false, skipped: "unparseable" };
+        }
+    }
+    if (patch.bio !== undefined) {
+        const bioText = patch.bio !== null && patch.bio.trim().length > 0
+            ? patch.bio.trim()
+            : BIO_PLACEHOLDER;
+        if (BIO_SECTION.test(text)) {
+            text = text.replace(BIO_SECTION, (_match, head, _body, tail) => `${head}${bioText}${tail}`);
+            touched = true;
+        }
+        else {
+            return { changed: false, skipped: "unparseable" };
+        }
+    }
+    if (!touched || text === original) {
+        return { changed: false, skipped: "no-change" };
+    }
+    writeFileSync(file, text, { mode: 0o600 });
+    return { changed: true };
+}
+/**
+ * Read the agent's `identity.md` verbatim, if it exists. Returns the raw
+ * contents (including the leading `# Identity` heading) so callers can
+ * splice it into the system context. Returns `null` when the workspace
+ * has not been provisioned yet, the file is empty, or the read fails.
+ *
+ * Each call hits disk — same contract as `readWorkingMemory`, so a
+ * dashboard-driven edit (`applyAgentIdentity` from a control frame, or
+ * a hello-snapshot reapply, or the agent's own self-edit) is visible
+ * on the very next turn without restarting the gateway.
+ */
+export function readIdentity(agentId) {
+    assertSafeAgentId(agentId);
+    const file = path.join(agentWorkspaceDir(agentId), "identity.md");
+    try {
+        const raw = readFileSync(file, "utf8");
+        return raw.trim().length > 0 ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/config.d.ts

@@ -5,7 +5,23 @@ export declare const SNAPSHOT_PATH: string;
  * Adapter ids. Built-in adapters are enumerated for editor hints; any string
  * accepted by the registry is valid at runtime.
  */
-export type AdapterName = "claude-code" | "codex" | "gemini" | (string & {});
+export type AdapterName = "claude-code" | "codex" | "gemini" | "openclaw-acp" | (string & {});
+/**
+ * One OpenClaw gateway profile. Referenced by `RouteRule.gateway` and
+ * `DaemonRouteDefault.gateway` (and `StoredBotCordCredentials.openclawGateway`)
+ * via `name`. `tokenFile` is `~`-expanded and read at `toGatewayConfig` time;
+ * read failures do not block boot — the gateway becomes unusable but other
+ * gateways still work.
+ */
+export interface OpenclawGatewayProfile {
+    name: string;
+    url: string;
+    /** Bearer token; mutually-exclusive priority is `token > tokenFile`. */
+    token?: string;
+    tokenFile?: string;
+    /** Default OpenClaw agent profile name when a route does not pin one. */
+    defaultAgent?: string;
+}
 /**
  * Predicates selecting messages for a route. `roomId` / `roomPrefix` are
  * legacy aliases retained for backward compatibility with pre-P1 daemon
@@ -31,11 +47,22 @@ export interface RouteRule {
     cwd: string;
     /** Extra CLI flags appended to the adapter invocation. */
     extraArgs?: string[];
+    /**
+     * Required when `adapter === "openclaw-acp"`: name of an entry in
+     * `DaemonConfig.openclawGateways[]`.
+     */
+    gateway?: string;
+    /** Overrides `OpenclawGatewayProfile.defaultAgent` when set. */
+    openclawAgent?: string;
 }
 export interface DaemonRouteDefault {
     adapter: AdapterName;
     cwd: string;
     extraArgs?: string[];
+    /** Same semantics as `RouteRule.gateway`. */
+    gateway?: string;
+    /** Same semantics as `RouteRule.openclawAgent`. */
+    openclawAgent?: string;
 }
 /**
  * Daemon-layer hook controlling credential auto-discovery at boot. Kept
@@ -74,6 +101,26 @@ export interface DaemonConfig {
     routes: RouteRule[];
     /** If true, stream blocks (only meaningful for rm_oc_* rooms). */
     streamBlocks: boolean;
+    /**
+     * Persistent transcript-logging settings (design §3 / §6). Defaults to
+     * disabled — see `BOTCORD_TRANSCRIPT` for env-driven temporary overrides.
+     */
+    transcript?: TranscriptConfig;
+    /**
+     * Optional registry of OpenClaw gateway endpoints. Routes / managed routes
+     * with `adapter === "openclaw-acp"` reference these by `name`. Resolution
+     * to {@link ResolvedOpenclawGateway} happens eagerly in `toGatewayConfig`
+     * so the dispatcher never re-queries this list.
+     */
+    openclawGateways?: OpenclawGatewayProfile[];
+}
+/**
+ * Persistent transcript settings (design §6). Default-off — `botcord-daemon
+ * transcript enable` flips `enabled` and `transcript disable` flips it back.
+ * The env var `BOTCORD_TRANSCRIPT` can override at boot.
+ */
+export interface TranscriptConfig {
+    enabled?: boolean;
 }
 /**
  * Return the explicit agent-id list written to disk, or `null` when the
@@ -97,6 +144,7 @@ export declare function resolveConfiguredAgentIds(cfg: DaemonConfig): string[] |
  * before discovery). Throws when neither `agents` nor `agentId` is set.
  */
 export declare function resolveAgentIds(cfg: DaemonConfig): string[];
+export declare const CONFIG_MISSING = "CONFIG_MISSING";
 export declare function loadConfig(): DaemonConfig;
 export declare function saveConfig(cfg: DaemonConfig): void;
 /**

package/dist/config.js

@@ -70,9 +70,12 @@ function ensureDir() {
         // best-effort
     }
 }
+export const CONFIG_MISSING = "CONFIG_MISSING";
 export function loadConfig() {
     if (!existsSync(CONFIG_PATH)) {
-        throw new Error(`daemon config not found at ${CONFIG_PATH}. Run \`botcord-daemon init\` first.`);
+        const err = new Error(`daemon config not found at ${CONFIG_PATH}`);
+        err.code = CONFIG_MISSING;
+        throw err;
     }
     const raw = readFileSync(CONFIG_PATH, "utf8");
     const parsed = JSON.parse(raw);
@@ -96,6 +99,40 @@ export function loadConfig() {
         throw new Error(`daemon config missing defaultRoute.adapter/cwd (${CONFIG_PATH})`);
     }
     validateAdapter(parsed.defaultRoute.adapter, "defaultRoute.adapter");
+    const gatewaysRaw = parsed.openclawGateways;
+    const gatewayNames = new Set();
+    if (gatewaysRaw !== undefined) {
+        if (!Array.isArray(gatewaysRaw)) {
+            throw new Error(`daemon config "openclawGateways" must be an array (${CONFIG_PATH})`);
+        }
+        for (const [i, g] of gatewaysRaw.entries()) {
+            if (!g || typeof g !== "object") {
+                throw new Error(`daemon config openclawGateways[${i}] is not an object (${CONFIG_PATH})`);
+            }
+            const gg = g;
+            if (typeof gg.name !== "string" || gg.name.length === 0) {
+                throw new Error(`daemon config openclawGateways[${i}].name must be a non-empty string (${CONFIG_PATH})`);
+            }
+            if (typeof gg.url !== "string" || gg.url.length === 0) {
+                throw new Error(`daemon config openclawGateways[${i}].url must be a non-empty string (${CONFIG_PATH})`);
+            }
+            if (gatewayNames.has(gg.name)) {
+                throw new Error(`daemon config openclawGateways[${i}].name "${gg.name}" duplicated (${CONFIG_PATH})`);
+            }
+            gatewayNames.add(gg.name);
+        }
+    }
+    const validateGatewayRef = (adapter, gateway, where) => {
+        if (adapter === "openclaw-acp") {
+            if (typeof gateway !== "string" || gateway.length === 0) {
+                throw new Error(`daemon config ${where} adapter "openclaw-acp" requires a "gateway" name (${CONFIG_PATH})`);
+            }
+            if (!gatewayNames.has(gateway)) {
+                throw new Error(`daemon config ${where}.gateway "${gateway}" not in openclawGateways (${CONFIG_PATH})`);
+            }
+        }
+    };
+    validateGatewayRef(parsed.defaultRoute.adapter, parsed.defaultRoute.gateway, "defaultRoute");
     const routesRaw = parsed.routes ?? [];
     if (!Array.isArray(routesRaw)) {
         throw new Error(`daemon config "routes" must be an array (${CONFIG_PATH})`);
@@ -108,6 +145,7 @@ export function loadConfig() {
             throw new Error(`daemon config routes[${i}] missing string adapter/cwd (${CONFIG_PATH})`);
         }
         validateAdapter(r.adapter, `routes[${i}].adapter`);
+        validateGatewayRef(r.adapter, r.gateway, `routes[${i}]`);
     }
     // Preserve the on-disk shape as-is so `config` prints what the user wrote.
     // Resolution of agents vs agentId happens at the consumption boundary
@@ -117,6 +155,24 @@ export function loadConfig() {
         routes: routesRaw,
         streamBlocks: parsed.streamBlocks ?? true,
     };
+    if (parsed.transcript && typeof parsed.transcript === "object") {
+        const t = {};
+        if (typeof parsed.transcript.enabled === "boolean")
+            t.enabled = parsed.transcript.enabled;
+        out.transcript = t;
+    }
+    if (gatewaysRaw && Array.isArray(gatewaysRaw)) {
+        out.openclawGateways = gatewaysRaw.map((g) => {
+            const copy = { name: g.name, url: g.url };
+            if (typeof g.token === "string")
+                copy.token = g.token;
+            if (typeof g.tokenFile === "string")
+                copy.tokenFile = g.tokenFile;
+            if (typeof g.defaultAgent === "string")
+                copy.defaultAgent = g.defaultAgent;
+            return copy;
+        });
+    }
     if (hasAgents)
         out.agents = parsed.agents.slice();
     if (hasLegacy)

package/dist/daemon-config-map.d.ts

@@ -1,5 +1,29 @@
 import type { GatewayConfig, GatewayRoute } from "./gateway/index.js";
-import type { DaemonConfig } from "./config.js";
+import type { DaemonConfig, OpenclawGatewayProfile } from "./config.js";
+/** Per-agent metadata cached from credentials, used by `buildManagedRoutes`. */
+export interface AgentRuntimeMeta {
+    runtime?: string;
+    cwd?: string;
+    /** OpenClaw gateway profile name to lookup in the registry. */
+    openclawGateway?: string;
+    /** Optional override of the OpenClaw agent profile within the gateway. */
+    openclawAgent?: string;
+}
+/** Profile + tokenFile-resolved bearer token. Exported so other module-boundary
+ *  paths (runtime probing, post-provision hot-add) reuse the same resolver
+ *  instead of duplicating tokenFile semantics. */
+export interface PreparedGatewayProfile extends OpenclawGatewayProfile {
+    /** Token actually usable at dispatch time; empty when load failed. */
+    resolvedToken?: string;
+    /** Reason `resolvedToken` is empty, for logs. */
+    tokenError?: string;
+}
+/** Resolve one profile's token (inline > tokenFile). Failures are swallowed
+ *  into `tokenError`; `resolvedToken` is left undefined. Logs at warn for ops
+ *  visibility. */
+export declare function prepareGatewayProfile(p: OpenclawGatewayProfile): PreparedGatewayProfile;
+/** Build a name → prepared-profile map for a config's gateway registry. */
+export declare function prepareGatewayProfiles(profiles: OpenclawGatewayProfile[] | undefined): Map<string, PreparedGatewayProfile>;
 /** Options accepted by {@link toGatewayConfig}. */
 export interface ToGatewayConfigOptions {
     /**
@@ -14,10 +38,7 @@ export interface ToGatewayConfigOptions {
      * turns to its runtime. Explicit `cfg.routes` entries still win because
      * synthesized routes are appended after them.
      */
-    agentRuntimes?: Record<string, {
-        runtime?: string;
-        cwd?: string;
-    }>;
+    agentRuntimes?: Record<string, AgentRuntimeMeta>;
 }
 /**
  * Historical channel id used when the daemon bound a single agent. Kept as a
@@ -54,7 +75,4 @@ export declare function toGatewayConfig(cfg: DaemonConfig, opts?: ToGatewayConfi
  * Exported so `reload_config` and `provisionAgent` hot-add can share the
  * same synthesis logic (plan §10.5).
  */
-export declare function buildManagedRoutes(agentIds: string[], agentRuntimes: Record<string, {
-    runtime?: string;
-    cwd?: string;
-}>, defaultRoute: GatewayRoute): Map<string, GatewayRoute>;
+export declare function buildManagedRoutes(agentIds: string[], agentRuntimes: Record<string, AgentRuntimeMeta>, defaultRoute: GatewayRoute, openclawProfiles?: Map<string, PreparedGatewayProfile>): Map<string, GatewayRoute>;