@botcord/daemon 0.2.27 → 0.2.29

package/src/__tests__/openclaw-acp.test.ts

@@ -224,6 +224,8 @@ describe("OpenclawAcpAdapter.run", () => {
         const frame = JSON.parse(line);
         if (frame.method === "initialize") {
           child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/load") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: frame.params.sessionId } }) + "\n");
         } else if (frame.method === "session/new") {
           child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "s1" } }) + "\n");
         } else if (frame.method === "session/prompt") {
@@ -245,4 +247,174 @@ describe("OpenclawAcpAdapter.run", () => {
     await adapter.run({ ...opts, sessionId: "s1" });
     expect(spawnFn).toHaveBeenCalledTimes(1);
   });
+
+  it("loads a cached ACP session id with the stable sessionKey before prompting", async () => {
+    const child = new FakeChild();
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(child) });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "swe",
+    };
+    const seen: any[] = [];
+
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        seen.push(frame);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/load") {
+          expect(frame.params.sessionId).toBe("cached-id");
+          expect(frame.params._meta.sessionKey).toBe(
+            "agent:swe:ag_337518f31844:direct:rm_oc_owner",
+          );
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "cached-id" } }) + "\n");
+        } else if (frame.method === "session/prompt") {
+          expect(frame.params.sessionId).toBe("cached-id");
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "loaded ok" } }) + "\n");
+        }
+      }
+    });
+
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: "cached-id",
+      cwd: "/tmp",
+      accountId: "ag_337518f31844",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+      context: { conversationKey: "direct:rm_oc_owner" },
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.text).toBe("loaded ok");
+    expect(res.newSessionId).toBe("cached-id");
+    expect(seen.map((f) => f.method)).toEqual(["initialize", "session/load", "session/prompt"]);
+  });
+
+  it("discards a cached ACP session id when session/load reports not found", async () => {
+    const child = new FakeChild();
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(child) });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "swe",
+    };
+    const seen: any[] = [];
+
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        seen.push(frame);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/load") {
+          child.stdout.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: frame.id,
+              error: {
+                code: -32603,
+                message: "Internal error",
+                data: { details: "Session cached-id not found" },
+              },
+            }) + "\n",
+          );
+        } else if (frame.method === "session/new") {
+          expect(frame.params._meta.sessionKey).toBe(
+            "agent:swe:ag_337518f31844:direct:rm_oc_owner",
+          );
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "fresh-id" } }) + "\n");
+        } else if (frame.method === "session/prompt") {
+          expect(frame.params.sessionId).toBe("fresh-id");
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "fresh ok" } }) + "\n");
+        }
+      }
+    });
+
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: "cached-id",
+      cwd: "/tmp",
+      accountId: "ag_337518f31844",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+      context: { conversationKey: "direct:rm_oc_owner" },
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.text).toBe("fresh ok");
+    expect(res.newSessionId).toBe("fresh-id");
+    expect(seen.map((f) => f.method)).toEqual([
+      "initialize",
+      "session/load",
+      "session/new",
+      "session/prompt",
+    ]);
+  });
+
+  it("recreates the ACP session and retries once when prompt reports not found", async () => {
+    const child = new FakeChild();
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(child) });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "swe",
+    };
+    const seen: any[] = [];
+
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        seen.push(frame);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/load") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "cached-id" } }) + "\n");
+        } else if (frame.method === "session/new") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "fresh-id" } }) + "\n");
+        } else if (frame.method === "session/prompt" && frame.params.sessionId === "cached-id") {
+          child.stdout.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: frame.id,
+              error: {
+                code: -32603,
+                message: "Internal error",
+                data: { details: "Session cached-id not found" },
+              },
+            }) + "\n",
+          );
+        } else if (frame.method === "session/prompt") {
+          expect(frame.params.sessionId).toBe("fresh-id");
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "retry ok" } }) + "\n");
+        }
+      }
+    });
+
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: "cached-id",
+      cwd: "/tmp",
+      accountId: "ag_337518f31844",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+      context: { conversationKey: "direct:rm_oc_owner" },
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.text).toBe("retry ok");
+    expect(res.newSessionId).toBe("fresh-id");
+    expect(seen.map((f) => f.method)).toEqual([
+      "initialize",
+      "session/load",
+      "session/prompt",
+      "session/new",
+      "session/prompt",
+    ]);
+  });
 });

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   defaultOpenclawDiscoveryPorts,
+  defaultOpenclawDiscoverySystemdUnitPaths,
   defaultOpenclawDiscoveryTokenFilePaths,
   discoverLocalOpenclawGateways,
   mergeOpenclawGateways,
@@ -148,6 +149,69 @@ describe("discoverLocalOpenclawGateways", () => {
     ]);
   });
 
+  it("discovers gateway port and token from a systemd OpenClaw unit", async () => {
+    const dir = tempDir();
+    const unit = path.join(dir, "openclaw.service");
+    writeFileSync(
+      unit,
+      [
+        "[Service]",
+        "User=openclaw",
+        'Environment="OPENCLAW_GATEWAY_TOKEN=systemd-token"',
+        "ExecStart=/usr/bin/openclaw gateway --bind lan --port 16200 --allow-unconfigured",
+      ].join("\n"),
+    );
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [],
+      defaultPorts: [],
+      systemdUnitPaths: [unit],
+      env: {},
+    });
+
+    expect(defaultOpenclawDiscoverySystemdUnitPaths()).toEqual(
+      expect.arrayContaining(["/etc/systemd/system/openclaw.service"]),
+    );
+    expect(found).toEqual([
+      expect.objectContaining({
+        url: "ws://127.0.0.1:16200",
+        token: "systemd-token",
+        source: "systemd-unit",
+      }),
+    ]);
+  });
+
+  it("discovers gateway token from a systemd EnvironmentFile", async () => {
+    const dir = tempDir();
+    const unit = path.join(dir, "openclaw.service");
+    const envFile = path.join(dir, "openclaw.env");
+    writeFileSync(envFile, 'OPENCLAW_GATEWAY_TOKEN="file-token"\n');
+    writeFileSync(
+      unit,
+      [
+        "[Service]",
+        `EnvironmentFile=${envFile}`,
+        "Environment=OPENCLAW_GATEWAY_PORT=16200",
+        "ExecStart=/usr/bin/openclaw gateway --bind lan --allow-unconfigured",
+      ].join("\n"),
+    );
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [],
+      defaultPorts: [],
+      systemdUnitPaths: [unit],
+      env: {},
+    });
+
+    expect(found).toEqual([
+      expect.objectContaining({
+        url: "ws://127.0.0.1:16200",
+        token: "file-token",
+        source: "systemd-unit",
+      }),
+    ]);
+  });
+
   it("prefers OPENCLAW_ACP env vars over OPENCLAW_GATEWAY env vars", async () => {
     const found = await discoverLocalOpenclawGateways({
       searchPaths: [],

package/src/__tests__/provision.test.ts

@@ -1421,3 +1421,167 @@ describe("update_agent handler", () => {
     expect(ack.error?.code).toBe("bad_params");
   });
 });
+
+describe("provision_agent hermes profile attach", () => {
+  it("rejects invalid hermes profile names before resolving HERMES_HOME", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      fs.mkdirSync(nodePath.join(tmp, ".hermes", "profiles"), {
+        recursive: true,
+      });
+      fs.mkdirSync(nodePath.join(tmp, "outside"), { recursive: true });
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+      const privateKey = Buffer.alloc(32, 23).toString("base64");
+      const ack = await provisioner({
+        id: "req_hp_invalid",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "hermes-agent",
+          hermes: { profile: "../../outside" },
+          credentials: {
+            agentId: "ag_hp_invalid",
+            keyId: "k_hp_invalid",
+            privateKey,
+            hubUrl: "https://hub.example",
+            runtime: "hermes-agent",
+          },
+        },
+      });
+      expect(ack.ok).toBe(false);
+      expect(ack.error?.code).toBe("hermes_profile_invalid");
+      expect(gw.addChannel).not.toHaveBeenCalled();
+    });
+  });
+
+  it("rejects with hermes_profile_not_found when the profile does not exist", async () => {
+    await withSandboxHome(async ({ tmp: _tmp }) => {
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+      const privateKey = Buffer.alloc(32, 11).toString("base64");
+      const ack = await provisioner({
+        id: "req_hp_missing",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "hermes-agent",
+          hermes: { profile: "ghost" },
+          credentials: {
+            agentId: "ag_hp_missing",
+            keyId: "k_hp",
+            privateKey,
+            hubUrl: "https://hub.example",
+            runtime: "hermes-agent",
+          },
+        },
+      });
+      expect(ack.ok).toBe(false);
+      expect(ack.error?.code).toBe("hermes_profile_not_found");
+      expect(ack.error?.profile).toBe("ghost");
+      expect(gw.addChannel).not.toHaveBeenCalled();
+    });
+  });
+
+  it("persists hermesProfile to credentials when the profile exists and is free", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      // Lay down ~/.hermes/profiles/coder so validateHermesProfileForProvision
+      // sees it.
+      fs.mkdirSync(nodePath.join(tmp, ".hermes", "profiles", "coder"), {
+        recursive: true,
+      });
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+      const privateKey = Buffer.alloc(32, 13).toString("base64");
+      const ack = await provisioner({
+        id: "req_hp_ok",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "hermes-agent",
+          hermes: { profile: "coder" },
+          credentials: {
+            agentId: "ag_hp_ok",
+            keyId: "k_hp",
+            privateKey,
+            hubUrl: "https://hub.example",
+            displayName: "coder agent",
+            runtime: "hermes-agent",
+          },
+        },
+      });
+      expect(ack.ok).toBe(true);
+      expect(gw.addChannel).toHaveBeenCalledOnce();
+
+      const credFile = nodePath.join(
+        tmp,
+        ".botcord",
+        "credentials",
+        "ag_hp_ok.json",
+      );
+      const saved = JSON.parse(fs.readFileSync(credFile, "utf8")) as Record<
+        string,
+        unknown
+      >;
+      expect(saved.hermesProfile).toBe("coder");
+      expect(saved.runtime).toBe("hermes-agent");
+      expect(
+        fs.existsSync(
+          nodePath.join(tmp, ".hermes", "profiles", "coder", "skills", "botcord", "SKILL.md"),
+        ),
+      ).toBe(true);
+    });
+  });
+
+  it("rejects with hermes_profile_occupied when another agent already binds the profile", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      fs.mkdirSync(nodePath.join(tmp, ".hermes", "profiles", "coder"), {
+        recursive: true,
+      });
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+
+      const privateKey = Buffer.alloc(32, 17).toString("base64");
+      const okAck = await provisioner({
+        id: "req_first",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "hermes-agent",
+          hermes: { profile: "coder" },
+          credentials: {
+            agentId: "ag_first",
+            keyId: "k_first",
+            privateKey,
+            hubUrl: "https://hub.example",
+            runtime: "hermes-agent",
+          },
+        },
+      });
+      expect(okAck.ok).toBe(true);
+
+      const privateKey2 = Buffer.alloc(32, 19).toString("base64");
+      const ack = await provisioner({
+        id: "req_second",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "hermes-agent",
+          hermes: { profile: "coder" },
+          credentials: {
+            agentId: "ag_second",
+            keyId: "k_second",
+            privateKey: privateKey2,
+            hubUrl: "https://hub.example",
+            runtime: "hermes-agent",
+          },
+        },
+      });
+      expect(ack.ok).toBe(false);
+      expect(ack.error?.code).toBe("hermes_profile_occupied");
+      expect(ack.error?.occupiedBy).toBe("ag_first");
+    });
+  });
+});

package/src/agent-discovery.ts

@@ -42,6 +42,8 @@ export interface DiscoveredAgentCredential {
   openclawGateway?: string;
   /** OpenClaw agent profile override from credentials. */
   openclawAgent?: string;
+  /** Hermes profile name from credentials (only meaningful for hermes-agent). */
+  hermesProfile?: 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. */
@@ -182,6 +184,7 @@ export function discoverAgentCredentials(
     if (creds.cwd) entry.cwd = creds.cwd;
     if (creds.openclawGateway) entry.openclawGateway = creds.openclawGateway;
     if (creds.openclawAgent) entry.openclawAgent = creds.openclawAgent;
+    if (creds.hermesProfile) entry.hermesProfile = creds.hermesProfile;
     if (creds.keyId) entry.keyId = creds.keyId;
     if (creds.savedAt) entry.savedAt = creds.savedAt;
     agents.push(entry);

package/src/agent-workspace.ts

@@ -357,14 +357,25 @@ export function ensureAgentCodexHome(agentId: string): string {
  * loader (which only sees this isolated HERMES_HOME, not `~/.hermes`)
  * can discover them.
  */
-export function ensureAgentHermesWorkspace(agentId: string): {
+export function ensureAgentHermesWorkspace(
+  agentId: string,
+  opts: { attached?: boolean } = {},
+): {
   hermesHome: string;
   hermesWorkspace: string;
 } {
   const hermesHome = agentHermesHomeDir(agentId);
   const hermesWorkspace = agentHermesWorkspaceDir(agentId);
-  mkdirTolerant(hermesHome);
   mkdirTolerant(hermesWorkspace);
+  // Attach mode: HERMES_HOME points at the user's `~/.hermes/profiles/<n>/`
+  // so we MUST NOT touch the per-agent isolated home. The cwd
+  // (`hermesWorkspace`) is still ours and `prepareTurn` writes AGENTS.md
+  // there. Profile-owned skill seeding is handled separately by
+  // `ensureAttachedHermesProfileSkills`.
+  if (opts.attached) {
+    return { hermesHome, hermesWorkspace };
+  }
+  mkdirTolerant(hermesHome);
   writeIfMissing(
     path.join(hermesHome, ".env"),
     "# hermes-agent environment overrides for this BotCord agent.\n" +
@@ -451,6 +462,17 @@ function seedHermesAgentSkills(hermesHome: string): void {
   copyBundledSkills(path.join(hermesHome, "skills"));
 }
 
+/**
+ * Seed BotCord's bundled Hermes skills into a user-owned Hermes profile used
+ * by attach mode. Unlike `ensureAgentHermesWorkspace({ attached: true })`,
+ * this intentionally writes only the managed `botcord*` skill directories
+ * under the profile's `skills/` directory; it does not touch `.env`,
+ * `config.yaml`, sessions, or any user-authored skills.
+ */
+export function ensureAttachedHermesProfileSkills(profileHome: string): void {
+  seedHermesAgentSkills(profileHome);
+}
+
 /**
  * Idempotently create the agent's home / workspace / state directories and
  * seed the workspace Markdown files. Existing files are never overwritten —

package/src/daemon-config-map.ts

@@ -27,6 +27,8 @@ export interface AgentRuntimeMeta {
   openclawGateway?: string;
   /** Optional override of the OpenClaw agent profile within the gateway. */
   openclawAgent?: string;
+  /** Hermes profile name to attach to (`runtime === "hermes-agent"` only). */
+  hermesProfile?: string;
 }
 
 /** Profile + tokenFile-resolved bearer token. Exported so other module-boundary
@@ -339,6 +341,9 @@ export function buildManagedRoutes(
       }
       route.gateway = resolved;
     }
+    if (runtime === "hermes-agent" && meta.hermesProfile) {
+      route.hermesProfile = meta.hermesProfile;
+    }
     out.set(agentId, route);
   }
   return out;

package/src/daemon.ts

@@ -562,7 +562,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
  */
 export interface BootBackfillResult {
   credentialPathByAgentId: Map<string, string>;
-  agentRuntimes: Record<string, { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string }>;
+  agentRuntimes: Record<string, { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }>;
 }
 
 /**
@@ -585,12 +585,13 @@ export function backfillBootAgents(
   const failed: string[] = [];
   for (const a of agents) {
     if (a.credentialsFile) credentialPathByAgentId.set(a.agentId, a.credentialsFile);
-    if (a.runtime || a.cwd || a.openclawGateway || a.openclawAgent) {
+    if (a.runtime || a.cwd || a.openclawGateway || a.openclawAgent || a.hermesProfile) {
       agentRuntimes[a.agentId] = {
         ...(a.runtime ? { runtime: a.runtime } : {}),
         ...(a.cwd ? { cwd: a.cwd } : {}),
         ...(a.openclawGateway ? { openclawGateway: a.openclawGateway } : {}),
         ...(a.openclawAgent ? { openclawAgent: a.openclawAgent } : {}),
+        ...(a.hermesProfile ? { hermesProfile: a.hermesProfile } : {}),
       };
     }
     // Seed files are written only when missing (see `ensureAgentWorkspace`),

package/src/gateway/__tests__/hermes-agent-adapter.test.ts

@@ -12,6 +12,8 @@ import os from "node:os";
 import path from "node:path";
 import {
   HermesAgentAdapter,
+  hermesProfileHomeDir,
+  listHermesProfiles,
   resolveHermesAcpCommand,
 } from "../runtimes/hermes-agent.js";
 import { agentHermesWorkspaceDir } from "../../agent-workspace.js";
@@ -367,3 +369,88 @@ describe("HermesAgentAdapter", () => {
     expect(status.some((s) => s.phase === "stopped")).toBe(true);
   });
 });
+
+describe("listHermesProfiles", () => {
+  it("returns the synthetic default entry when only ~/.hermes exists", () => {
+    // beforeAll set HOME to an empty tmp dir; create just ~/.hermes.
+    const root = path.join(agentHomeRoot, ".hermes");
+    mkdirSync(root, { recursive: true });
+    // Drop a config.yaml to exercise the optional model snapshot.
+    writeFileSync(
+      path.join(root, "config.yaml"),
+      "model:\n  default: anthropic/claude-opus-4.6\n  provider: custom\n",
+    );
+    writeFileSync(path.join(root, "SOUL.md"), "test soul");
+    mkdirSync(path.join(root, "sessions"), { recursive: true });
+    writeFileSync(path.join(root, "sessions", "20260101_abc.jsonl"), "{}\n");
+
+    const profiles = listHermesProfiles();
+    const def = profiles.find((p) => p.name === "default");
+    expect(def).toBeDefined();
+    expect(def?.isDefault).toBe(true);
+    expect(def?.home).toBe(root);
+    expect(def?.modelName).toBe("anthropic/claude-opus-4.6");
+    expect(def?.hasSoul).toBe(true);
+    expect(def?.sessionsCount).toBe(1);
+
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("enumerates named profiles and honours active_profile", () => {
+    const root = path.join(agentHomeRoot, ".hermes");
+    mkdirSync(path.join(root, "profiles", "coder"), { recursive: true });
+    mkdirSync(path.join(root, "profiles", "writer"), { recursive: true });
+    // Garbage / invalid profile names should be skipped.
+    mkdirSync(path.join(root, "profiles", "BadName"), { recursive: true });
+    writeFileSync(path.join(root, "active_profile"), "writer\n");
+
+    const profiles = listHermesProfiles();
+    const names = profiles.map((p) => p.name).sort();
+    expect(names).toEqual(["coder", "default", "writer"]);
+    const writer = profiles.find((p) => p.name === "writer");
+    expect(writer?.isActive).toBe(true);
+    expect(writer?.home).toBe(hermesProfileHomeDir("writer"));
+
+    rmSync(root, { recursive: true, force: true });
+  });
+});
+
+describe("HermesAgentAdapter.spawnEnv attach mode", () => {
+  it("points HERMES_HOME at the user profile when hermesProfile is set", () => {
+    const adapter = new HermesAgentAdapter({ binary: "/dev/null" });
+    type EnvProbe = { HERMES_HOME?: string };
+    const env = (
+      adapter as unknown as {
+        spawnEnv: (opts: unknown) => EnvProbe;
+      }
+    ).spawnEnv({
+      text: "",
+      sessionId: null,
+      cwd: tmpRoot,
+      accountId: "ag_attach",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      hermesProfile: "coder",
+    });
+    expect(env.HERMES_HOME).toBe(hermesProfileHomeDir("coder"));
+  });
+
+  it("falls back to per-agent isolated home when hermesProfile is unset", () => {
+    const adapter = new HermesAgentAdapter({ binary: "/dev/null" });
+    type EnvProbe = { HERMES_HOME?: string };
+    const env = (
+      adapter as unknown as {
+        spawnEnv: (opts: unknown) => EnvProbe;
+      }
+    ).spawnEnv({
+      text: "",
+      sessionId: null,
+      cwd: tmpRoot,
+      accountId: "ag_isolated",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+    });
+    expect(env.HERMES_HOME).toContain(path.join(".botcord", "agents", "ag_isolated"));
+    expect(env.HERMES_HOME).not.toBe(hermesProfileHomeDir("default"));
+  });
+});

package/src/gateway/dispatcher.ts

@@ -1050,6 +1050,7 @@ export class Dispatcher {
           onBlock,
           onStatus,
           gateway: route.gateway,
+          ...(route.hermesProfile ? { hermesProfile: route.hermesProfile } : {}),
         });
       } catch (err) {
         threw = err;