activeclaw 2026.3.10 → 2026.3.11

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.3.10",
-  "commit": "1ab2fc6ea71de2afec2cccf4285e21f0e527dff4",
-  "builtAt": "2026-03-11T21:16:28.674Z"
+  "version": "2026.3.11",
+  "commit": "0b4519ca6e3061aeee04d634e16d467e934e7516",
+  "builtAt": "2026-03-12T14:55:45.177Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-b0b2172aedd17dc0856c0cdf14d6967801496efd964e8fb717a0cc002c336a0e
+0e9f701206ce2812d0e33952c84b8517021bd775c5fb5b1e0e423e5f9de2d26d

package/dist/plugin-sdk/feishu.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import chalk, { Chalk } from "chalk";
 import { Logger } from "tslog";
-import JSON5 from "json5";
+import json5 from "json5";
 import { promisify } from "node:util";
 import fs$1, { mkdtemp, rm } from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
@@ -372,7 +372,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/dist/plugin-sdk/googlechat.js

@@ -5,7 +5,7 @@ import chalk, { Chalk } from "chalk";
 import fs from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import JSON5 from "json5";
+import json5 from "json5";
 import { promisify } from "node:util";
 import { execFile } from "node:child_process";
 import { getOAuthProviders } from "@mariozechner/pi-ai";
@@ -415,7 +415,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/dist/plugin-sdk/msteams.js

@@ -4,7 +4,7 @@ import fs, { constants } from "node:fs";
 import os from "node:os";
 import chalk, { Chalk } from "chalk";
 import { Logger } from "tslog";
-import JSON5 from "json5";
+import json5 from "json5";
 import { promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import { execFile } from "node:child_process";
@@ -373,7 +373,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/dist/plugin-sdk/nextcloud-talk.js

@@ -6,7 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import chalk, { Chalk } from "chalk";
 import { Logger } from "tslog";
-import JSON5 from "json5";
+import json5 from "json5";
 import { format, promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import process$1 from "node:process";
@@ -722,7 +722,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/dist/plugin-sdk/signal.js

@@ -4,7 +4,7 @@ import chalk, { Chalk } from "chalk";
 import fs, { constants, createWriteStream } from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import json5 from "json5";
+import JSON5 from "json5";
 import { promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import "@clack/prompts";
@@ -780,7 +780,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = json5.parse(raw)?.logging;
+		const logging = JSON5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/dist/plugin-sdk/slack.js

@@ -4,7 +4,7 @@ import chalk, { Chalk } from "chalk";
 import fs from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import JSON5 from "json5";
+import json5 from "json5";
 import { promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
@@ -772,7 +772,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/extensions/hub/src/channel.test.ts

@@ -0,0 +1,166 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  deleteAccountFromConfigSectionMock,
+  listHubAccountIdsMock,
+  resolveDefaultHubAccountIdMock,
+  resolveHubAccountMock,
+  sendMessageHubMock,
+  setAccountEnabledInConfigSectionMock,
+} = vi.hoisted(() => ({
+  deleteAccountFromConfigSectionMock: vi.fn(() => ({})),
+  listHubAccountIdsMock: vi.fn(() => ["default"]),
+  resolveDefaultHubAccountIdMock: vi.fn(() => "default"),
+  resolveHubAccountMock: vi.fn(),
+  sendMessageHubMock: vi.fn(),
+  setAccountEnabledInConfigSectionMock: vi.fn(() => ({})),
+}));
+
+vi.mock("openclaw/plugin-sdk", () => ({
+  buildBaseAccountStatusSnapshot: vi.fn(() => ({})),
+  buildBaseChannelStatusSummary: vi.fn(() => ({})),
+  buildChannelConfigSchema: vi.fn((schema: unknown) => schema),
+  DEFAULT_ACCOUNT_ID: "default",
+  deleteAccountFromConfigSection: deleteAccountFromConfigSectionMock,
+  formatPairingApproveHint: vi.fn(() => "approve via hub"),
+  PAIRING_APPROVED_MESSAGE: "approved",
+  setAccountEnabledInConfigSection: setAccountEnabledInConfigSectionMock,
+}));
+
+vi.mock("./accounts.js", () => ({
+  listHubAccountIds: listHubAccountIdsMock,
+  resolveDefaultHubAccountId: resolveDefaultHubAccountIdMock,
+  resolveHubAccount: resolveHubAccountMock,
+}));
+
+vi.mock("./config-schema.js", () => ({
+  HubConfigSchema: { type: "object" },
+}));
+
+vi.mock("./monitor.js", () => ({
+  monitorHubProvider: vi.fn(),
+}));
+
+vi.mock("./onboarding.js", () => ({
+  hubOnboardingAdapter: {},
+}));
+
+vi.mock("./probe.js", () => ({
+  probeHub: vi.fn(),
+}));
+
+vi.mock("./runtime.js", () => ({
+  getHubRuntime: vi.fn(() => ({
+    channel: {
+      activity: {
+        record: vi.fn(),
+      },
+      text: {
+        chunkMarkdownText: vi.fn(),
+      },
+    },
+  })),
+}));
+
+vi.mock("./send.js", () => ({
+  sendMessageHub: sendMessageHubMock,
+}));
+
+const { hubPlugin } = await import("./channel.js");
+
+describe("hubPlugin normalization", () => {
+  beforeEach(() => {
+    sendMessageHubMock.mockReset();
+    sendMessageHubMock.mockResolvedValue({
+      messageId: "hub-1",
+      target: "brain",
+    });
+    resolveHubAccountMock.mockReset();
+    resolveHubAccountMock.mockReturnValue({
+      accountId: "default",
+      name: "Hub",
+      enabled: true,
+      configured: true,
+      url: "https://hub.example.test",
+      agentId: "sender",
+      secretSource: "inline",
+      config: {
+        allowFrom: [" hub:Brain ", "*", "CombinatorAgent ", "hub:"],
+        defaultTo: " hub:TargetAgent ",
+        dmPolicy: "open",
+      },
+    });
+  });
+
+  it("normalizes outbound hub targets", () => {
+    expect(hubPlugin.messaging?.normalizeTarget?.("  hub:Brain  ")).toBe("Brain");
+    expect(hubPlugin.messaging?.normalizeTarget?.("CombinatorAgent")).toBe("CombinatorAgent");
+    expect(hubPlugin.messaging?.normalizeTarget?.("hub:")).toBeUndefined();
+  });
+
+  it("normalizes pairing allow entries and approval targets", async () => {
+    expect(hubPlugin.pairing?.normalizeAllowEntry?.(" hub:Brain ")).toBe("brain");
+    expect(hubPlugin.pairing?.normalizeAllowEntry?.("hub:*")).toBe("*");
+
+    await hubPlugin.pairing?.notifyApproval?.({ id: " hub:Brain " } as any);
+
+    expect(sendMessageHubMock).toHaveBeenCalledWith("Brain", "approved");
+  });
+
+  it("normalizes config-derived allowFrom and defaultTo values", () => {
+    const cfg = { channels: { hub: {} } };
+
+    expect(hubPlugin.config.resolveAllowFrom({ cfg, accountId: "default" } as any)).toEqual([
+      "brain",
+      "*",
+      "combinatoragent",
+    ]);
+    expect(
+      hubPlugin.config.formatAllowFrom({
+        allowFrom: [" hub:Brain ", "COMBINATORAGENT", "*", "hub:"],
+      } as any),
+    ).toEqual(["brain", "combinatoragent", "*"]);
+    expect(hubPlugin.config.resolveDefaultTo({ cfg, accountId: "default" } as any)).toBe(
+      "TargetAgent",
+    );
+  });
+
+  it("normalizes dm-policy entries, resolver ids, and directory peers", async () => {
+    const cfg = { channels: { hub: {} } };
+    const account = resolveHubAccountMock.mock.results[0]?.value ?? resolveHubAccountMock();
+    const dmPolicy = hubPlugin.security.resolveDmPolicy({
+      cfg,
+      accountId: "default",
+      account,
+    } as any);
+
+    expect(dmPolicy.normalizeEntry(" hub:Brain ")).toBe("brain");
+    expect(dmPolicy.normalizeEntry("hub:*")).toBe("*");
+
+    await expect(
+      hubPlugin.resolver.resolveTargets({
+        inputs: [" hub:Brain ", " hub: ", "CombinatorAgent"],
+      } as any),
+    ).resolves.toEqual([
+      { input: " hub:Brain ", resolved: true, id: "Brain", name: "Brain" },
+      { input: " hub: ", resolved: false, note: "empty target" },
+      {
+        input: "CombinatorAgent",
+        resolved: true,
+        id: "CombinatorAgent",
+        name: "CombinatorAgent",
+      },
+    ]);
+
+    await expect(
+      hubPlugin.directory.listPeers({
+        cfg,
+        accountId: "default",
+        limit: 10,
+      } as any),
+    ).resolves.toEqual([
+      { kind: "user", id: "brain" },
+      { kind: "user", id: "combinatoragent" },
+    ]);
+  });
+});

package/extensions/hub/src/channel.ts

@@ -21,6 +21,7 @@ import { hubOnboardingAdapter } from "./onboarding.js";
 import { probeHub } from "./probe.js";
 import { getHubRuntime } from "./runtime.js";
 import { sendMessageHub } from "./send.js";
+import { normalizeHubAllowEntry, normalizeHubTarget } from "./targets.js";
 import type { CoreConfig, HubProbe } from "./types.js";
 
 export const hubPlugin: ChannelPlugin<ResolvedHubAccount, HubProbe> = {
@@ -38,9 +39,9 @@ export const hubPlugin: ChannelPlugin<ResolvedHubAccount, HubProbe> = {
   onboarding: hubOnboardingAdapter,
   pairing: {
     idLabel: "hubAgent",
-    normalizeAllowEntry: (entry) => String(entry).trim().toLowerCase(),
+    normalizeAllowEntry: (entry) => normalizeHubAllowEntry(entry) ?? "",
     notifyApproval: async ({ id }) => {
-      const target = String(id).trim();
+      const target = normalizeHubTarget(String(id));
       if (!target) {
         throw new Error(`invalid Hub pairing id: ${id}`);
       }
@@ -84,14 +85,15 @@ export const hubPlugin: ChannelPlugin<ResolvedHubAccount, HubProbe> = {
       secretSource: account.secretSource,
     }),
     resolveAllowFrom: ({ cfg, accountId }) =>
-      (resolveHubAccount({ cfg: cfg as CoreConfig, accountId }).config.allowFrom ?? []).map(
-        (entry) => String(entry),
-      ),
+      (resolveHubAccount({ cfg: cfg as CoreConfig, accountId }).config.allowFrom ?? [])
+        .map((entry) => normalizeHubAllowEntry(String(entry)))
+        .filter((entry): entry is string => Boolean(entry)),
     formatAllowFrom: ({ allowFrom }) =>
-      allowFrom.map((entry) => String(entry).trim().toLowerCase()).filter(Boolean),
+      allowFrom
+        .map((entry) => normalizeHubAllowEntry(String(entry)))
+        .filter((entry): entry is string => Boolean(entry)),
     resolveDefaultTo: ({ cfg, accountId }) =>
-      resolveHubAccount({ cfg: cfg as CoreConfig, accountId }).config.defaultTo?.trim() ||
-      undefined,
+      normalizeHubTarget(resolveHubAccount({ cfg: cfg as CoreConfig, accountId }).config.defaultTo),
   },
   security: {
     resolveDmPolicy: ({ cfg, accountId, account }) => {
@@ -106,15 +108,12 @@ export const hubPlugin: ChannelPlugin<ResolvedHubAccount, HubProbe> = {
         policyPath: `${basePath}dmPolicy`,
         allowFromPath: `${basePath}allowFrom`,
         approveHint: formatPairingApproveHint("hub"),
-        normalizeEntry: (raw) => String(raw).trim().toLowerCase(),
+        normalizeEntry: (raw) => normalizeHubAllowEntry(raw) ?? "",
       };
     },
   },
   messaging: {
-    normalizeTarget: (input) => {
-      const trimmed = String(input ?? "").trim();
-      return trimmed || undefined;
-    },
+    normalizeTarget: (input) => normalizeHubTarget(input),
     targetResolver: {
       looksLikeId: (input) => Boolean(String(input ?? "").trim()),
       hint: "<agent-id>",
@@ -123,11 +122,11 @@ export const hubPlugin: ChannelPlugin<ResolvedHubAccount, HubProbe> = {
   resolver: {
     resolveTargets: async ({ inputs }) => {
       return inputs.map((input) => {
-        const trimmed = String(input).trim();
-        if (!trimmed) {
+        const normalized = normalizeHubTarget(String(input));
+        if (!normalized) {
           return { input, resolved: false, note: "empty target" };
         }
-        return { input, resolved: true, id: trimmed, name: trimmed };
+        return { input, resolved: true, id: normalized, name: normalized };
       });
     },
   },
@@ -138,7 +137,7 @@ export const hubPlugin: ChannelPlugin<ResolvedHubAccount, HubProbe> = {
       const q = query?.trim().toLowerCase() ?? "";
       const ids = new Set<string>();
       for (const entry of account.config.allowFrom ?? []) {
-        const normalized = String(entry).trim().toLowerCase();
+        const normalized = normalizeHubAllowEntry(String(entry));
         if (normalized && normalized !== "*") {
           ids.add(normalized);
         }

package/extensions/hub/src/inbound.test.ts

@@ -0,0 +1,172 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  createNormalizedOutboundDelivererMock,
+  createReplyPrefixOptionsMock,
+  createScopedPairingAccessMock,
+  dispatchReplyWithBufferedBlockDispatcherMock,
+  emitInboundHistoryMock,
+  emitOutboundHistoryMock,
+  formatTextWithAttachmentLinksMock,
+  getHubRuntimeMock,
+  logInboundDropMock,
+  readStoreAllowFromForDmPolicyMock,
+  recordInboundSessionMock,
+  resolveControlCommandGateMock,
+  resolveEffectiveAllowFromListsMock,
+  resolveOutboundMediaUrlsMock,
+  sendMessageHubMock,
+} = vi.hoisted(() => ({
+  createNormalizedOutboundDelivererMock: vi.fn(),
+  createReplyPrefixOptionsMock: vi.fn(),
+  createScopedPairingAccessMock: vi.fn(),
+  dispatchReplyWithBufferedBlockDispatcherMock: vi.fn(),
+  emitInboundHistoryMock: vi.fn(),
+  emitOutboundHistoryMock: vi.fn(),
+  formatTextWithAttachmentLinksMock: vi.fn(),
+  getHubRuntimeMock: vi.fn(),
+  logInboundDropMock: vi.fn(),
+  readStoreAllowFromForDmPolicyMock: vi.fn(),
+  recordInboundSessionMock: vi.fn(),
+  resolveControlCommandGateMock: vi.fn(),
+  resolveEffectiveAllowFromListsMock: vi.fn(),
+  resolveOutboundMediaUrlsMock: vi.fn(),
+  sendMessageHubMock: vi.fn(),
+}));
+
+vi.mock("openclaw/plugin-sdk", () => ({
+  createScopedPairingAccess: createScopedPairingAccessMock,
+  createNormalizedOutboundDeliverer: createNormalizedOutboundDelivererMock,
+  createReplyPrefixOptions: createReplyPrefixOptionsMock,
+  emitInboundHistory: emitInboundHistoryMock,
+  emitOutboundHistory: emitOutboundHistoryMock,
+  formatTextWithAttachmentLinks: formatTextWithAttachmentLinksMock,
+  logInboundDrop: logInboundDropMock,
+  readStoreAllowFromForDmPolicy: readStoreAllowFromForDmPolicyMock,
+  resolveControlCommandGate: resolveControlCommandGateMock,
+  resolveOutboundMediaUrls: resolveOutboundMediaUrlsMock,
+  resolveEffectiveAllowFromLists: resolveEffectiveAllowFromListsMock,
+}));
+
+vi.mock("./runtime.js", () => ({
+  getHubRuntime: getHubRuntimeMock,
+}));
+
+vi.mock("./send.js", () => ({
+  sendMessageHub: sendMessageHubMock,
+}));
+
+import { handleHubInbound } from "./inbound.js";
+
+describe("handleHubInbound", () => {
+  beforeEach(() => {
+    createScopedPairingAccessMock.mockReset();
+    createNormalizedOutboundDelivererMock.mockReset();
+    createReplyPrefixOptionsMock.mockReset();
+    dispatchReplyWithBufferedBlockDispatcherMock.mockReset();
+    emitInboundHistoryMock.mockReset();
+    emitOutboundHistoryMock.mockReset();
+    formatTextWithAttachmentLinksMock.mockReset();
+    getHubRuntimeMock.mockReset();
+    logInboundDropMock.mockReset();
+    readStoreAllowFromForDmPolicyMock.mockReset();
+    recordInboundSessionMock.mockReset();
+    resolveControlCommandGateMock.mockReset();
+    resolveEffectiveAllowFromListsMock.mockReset();
+    resolveOutboundMediaUrlsMock.mockReset();
+    sendMessageHubMock.mockReset();
+
+    createScopedPairingAccessMock.mockReturnValue({
+      readStoreForDmPolicy: vi.fn(),
+      upsertPairingRequest: vi.fn(),
+    });
+    createNormalizedOutboundDelivererMock.mockImplementation((deliver: unknown) => deliver);
+    createReplyPrefixOptionsMock.mockReturnValue({
+      onModelSelected: vi.fn(),
+      includePrefix: false,
+    });
+    readStoreAllowFromForDmPolicyMock.mockResolvedValue([]);
+    resolveEffectiveAllowFromListsMock.mockReturnValue({
+      effectiveAllowFrom: ["*"],
+    });
+    resolveControlCommandGateMock.mockReturnValue({
+      commandAuthorized: true,
+      shouldBlock: false,
+    });
+    resolveOutboundMediaUrlsMock.mockReturnValue([]);
+    formatTextWithAttachmentLinksMock.mockImplementation((text: string) => text);
+    recordInboundSessionMock.mockResolvedValue(undefined);
+    dispatchReplyWithBufferedBlockDispatcherMock.mockImplementation(
+      async (params: Record<string, any>) => {
+        await params.dispatcherOptions.deliver({ text: "reply body" });
+      },
+    );
+    getHubRuntimeMock.mockReturnValue({
+      channel: {
+        commands: {
+          shouldHandleTextCommands: vi.fn(() => true),
+        },
+        reply: {
+          dispatchReplyWithBufferedBlockDispatcher: dispatchReplyWithBufferedBlockDispatcherMock,
+          finalizeInboundContext: vi.fn((ctx: Record<string, unknown>) => ctx),
+          formatAgentEnvelope: vi.fn(() => "formatted inbound"),
+          resolveEnvelopeFormatOptions: vi.fn(() => ({})),
+        },
+        routing: {
+          resolveAgentRoute: vi.fn(() => ({
+            agentId: "main",
+            sessionKey: "agent:main:hub:direct:CombinatorAgent",
+            accountId: "default",
+          })),
+        },
+        session: {
+          readSessionUpdatedAt: vi.fn(() => undefined),
+          recordInboundSession: recordInboundSessionMock,
+          resolveStorePath: vi.fn(() => "/tmp/openclaw-store"),
+        },
+        text: {
+          hasControlCommand: vi.fn(() => false),
+        },
+      },
+    });
+  });
+
+  it("replies to the plain Hub id while keeping prefixed conversation history keys", async () => {
+    const sendReplyMock = vi.fn().mockResolvedValue(undefined);
+
+    await handleHubInbound({
+      message: {
+        messageId: "msg-1",
+        from: "CombinatorAgent",
+        text: "hello",
+        timestamp: 123,
+      },
+      account: {
+        accountId: "default",
+        config: {
+          dmPolicy: "open",
+          allowFrom: ["*"],
+        },
+      } as any,
+      config: {
+        commands: {},
+        session: {
+          store: {},
+        },
+      } as any,
+      runtime: {
+        error: vi.fn(),
+        log: vi.fn(),
+      } as any,
+      sendReply: sendReplyMock,
+    });
+
+    expect(sendReplyMock).toHaveBeenCalledWith("CombinatorAgent", "reply body");
+    expect(sendMessageHubMock).not.toHaveBeenCalled();
+    expect(emitOutboundHistoryMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        conversationKey: "hub:CombinatorAgent",
+      }),
+    );
+  });
+});

package/extensions/hub/src/send.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  convertMarkdownTablesMock,
+  fetchWithSsrFGuardMock,
+  getHubRuntimeMock,
+  loadConfigMock,
+  recordActivityMock,
+  resolveHubAccountMock,
+  resolveMarkdownTableModeMock,
+  releaseMock,
+} = vi.hoisted(() => ({
+  convertMarkdownTablesMock: vi.fn(),
+  fetchWithSsrFGuardMock: vi.fn(),
+  getHubRuntimeMock: vi.fn(),
+  loadConfigMock: vi.fn(),
+  recordActivityMock: vi.fn(),
+  resolveHubAccountMock: vi.fn(),
+  resolveMarkdownTableModeMock: vi.fn(),
+  releaseMock: vi.fn(),
+}));
+
+vi.mock("openclaw/plugin-sdk", () => ({
+  fetchWithSsrFGuard: fetchWithSsrFGuardMock,
+}));
+
+vi.mock("./accounts.js", () => ({
+  resolveHubAccount: resolveHubAccountMock,
+}));
+
+vi.mock("./runtime.js", () => ({
+  getHubRuntime: getHubRuntimeMock,
+}));
+
+import { sendMessageHub } from "./send.js";
+
+describe("sendMessageHub", () => {
+  beforeEach(() => {
+    convertMarkdownTablesMock.mockReset();
+    fetchWithSsrFGuardMock.mockReset();
+    getHubRuntimeMock.mockReset();
+    loadConfigMock.mockReset();
+    recordActivityMock.mockReset();
+    releaseMock.mockReset();
+    resolveHubAccountMock.mockReset();
+    resolveMarkdownTableModeMock.mockReset();
+
+    releaseMock.mockResolvedValue(undefined);
+    loadConfigMock.mockReturnValue({});
+    resolveMarkdownTableModeMock.mockReturnValue("off");
+    convertMarkdownTablesMock.mockImplementation((text: string) => text);
+    recordActivityMock.mockReturnValue(undefined);
+    resolveHubAccountMock.mockReturnValue({
+      configured: true,
+      accountId: "default",
+      url: "https://hub.example.test",
+      agentId: "sender",
+      secret: "shared-secret",
+    });
+    getHubRuntimeMock.mockReturnValue({
+      config: { loadConfig: loadConfigMock },
+      channel: {
+        text: {
+          resolveMarkdownTableMode: resolveMarkdownTableModeMock,
+          convertMarkdownTables: convertMarkdownTablesMock,
+        },
+        activity: {
+          record: recordActivityMock,
+        },
+      },
+    });
+    fetchWithSsrFGuardMock.mockResolvedValue({
+      response: {
+        ok: true,
+      },
+      release: releaseMock,
+    });
+  });
+
+  it("posts to the plain agent id when given a hub:-prefixed recipient", async () => {
+    const result = await sendMessageHub("  hub:Brain  ", "hello");
+
+    expect(fetchWithSsrFGuardMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: "https://hub.example.test/agents/Brain/message",
+      }),
+    );
+    expect(result.target).toBe("Brain");
+  });
+
+  it("rejects empty recipients after normalization", async () => {
+    await expect(sendMessageHub("hub:", "hello")).rejects.toThrow(
+      "Hub send target must be non-empty",
+    );
+    expect(fetchWithSsrFGuardMock).not.toHaveBeenCalled();
+  });
+});

package/extensions/hub/src/send.ts

@@ -1,6 +1,7 @@
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk";
 import { resolveHubAccount } from "./accounts.js";
 import { getHubRuntime } from "./runtime.js";
+import { normalizeHubTarget } from "./targets.js";
 import type { CoreConfig } from "./types.js";
 
 type SendHubOptions = {
@@ -27,7 +28,7 @@ export async function sendMessageHub(
     );
   }
 
-  const target = to.trim();
+  const target = normalizeHubTarget(to);
   if (!target) {
     throw new Error("Hub send target must be non-empty");
   }

package/extensions/hub/src/targets.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { normalizeHubAllowEntry, normalizeHubTarget } from "./targets.js";
+
+describe("Hub target normalization", () => {
+  it("strips a leading hub: prefix and trims whitespace", () => {
+    expect(normalizeHubTarget("  hub:Brain  ")).toBe("Brain");
+    expect(normalizeHubTarget("HUB:CombinatorAgent")).toBe("CombinatorAgent");
+  });
+
+  it("keeps plain agent ids intact", () => {
+    expect(normalizeHubTarget("brain")).toBe("brain");
+  });
+
+  it("normalizes allowlist entries to lowercase agent ids", () => {
+    expect(normalizeHubAllowEntry(" hub:Brain ")).toBe("brain");
+    expect(normalizeHubAllowEntry("CombinatorAgent")).toBe("combinatoragent");
+  });
+
+  it("preserves wildcard allowlist entries", () => {
+    expect(normalizeHubAllowEntry("*")).toBe("*");
+    expect(normalizeHubAllowEntry("hub:*")).toBe("*");
+  });
+
+  it("returns undefined for empty values", () => {
+    expect(normalizeHubTarget("")).toBeUndefined();
+    expect(normalizeHubTarget("hub:")).toBeUndefined();
+    expect(normalizeHubAllowEntry("   ")).toBeUndefined();
+  });
+});

package/extensions/hub/src/targets.ts

@@ -0,0 +1,21 @@
+const HUB_PREFIX_RE = /^hub:/i;
+
+export function normalizeHubTarget(raw: string | null | undefined): string | undefined {
+  const trimmed = String(raw ?? "").trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const normalized = trimmed.replace(HUB_PREFIX_RE, "").trim();
+  return normalized || undefined;
+}
+
+export function normalizeHubAllowEntry(raw: string | null | undefined): string | undefined {
+  const normalized = normalizeHubTarget(raw);
+  if (!normalized) {
+    return undefined;
+  }
+  if (normalized === "*") {
+    return normalized;
+  }
+  return normalized.toLowerCase();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "activeclaw",
-  "version": "2026.3.10",
+  "version": "2026.3.11",
   "description": "Multi-channel AI gateway with extensible messaging integrations",
   "keywords": [],
   "homepage": "https://github.com/openclaw/openclaw#readme",