fix(skills): deduplicate slash commands by skillName across all interfaces

Shivam · claude · Shivam · commit 976d8e91ae0a · 2026-02-26T09:20:13.000+05:30
Move skill-command deduplication by skillName from the Discord-only
`dedupeSkillCommandsForDiscord` into `listSkillCommandsForAgents` so
every interface (TUI, Slack, text) consistently sees a clean command
list without platform-specific workarounds.

When multiple agents share a skill with the same name the old code
emitted `github` + `github_2` and relied on Discord to collapse them.
Now `listSkillCommandsForAgents` returns only the first registration
per skillName, and the Discord-specific wrapper is removed.

Co-Authored-By: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/auto-reply/skill-commands.test.ts b/src/auto-reply/skill-commands.test.ts
@@ -62,9 +62,10 @@ vi.mock("../agents/skills.js", () => {
 
 let listSkillCommandsForAgents: typeof import("./skill-commands.js").listSkillCommandsForAgents;
 let resolveSkillCommandInvocation: typeof import("./skill-commands.js").resolveSkillCommandInvocation;
+let skillCommandsTesting: typeof import("./skill-commands.js").__testing;
 
 beforeAll(async () => {
-  ({ listSkillCommandsForAgents, resolveSkillCommandInvocation } =
+  ({ listSkillCommandsForAgents, resolveSkillCommandInvocation, __testing: skillCommandsTesting } =
     await import("./skill-commands.js"));
 });
 
@@ -106,7 +107,7 @@ describe("resolveSkillCommandInvocation", () => {
 });
 
 describe("listSkillCommandsForAgents", () => {
-  it("merges command names across agents and de-duplicates", async () => {
+  it("deduplicates by skillName across agents, keeping the first registration", async () => {
     const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-skills-"));
     const mainWorkspace = path.join(baseDir, "main");
     const researchWorkspace = path.join(baseDir, "research");
@@ -124,8 +125,45 @@ describe("listSkillCommandsForAgents", () => {
       },
     });
     const names = commands.map((entry) => entry.name);
+    // demo-skill appears in both workspaces; only the first registration (demo_skill) survives.
     expect(names).toContain("demo_skill");
-    expect(names).toContain("demo_skill_2");
+    expect(names).not.toContain("demo_skill_2");
+    // extra-skill is unique to the research workspace and should be present.
     expect(names).toContain("extra_skill");
   });
 });
+
+describe("dedupeBySkillName", () => {
+  it("keeps the first entry when multiple commands share a skillName", () => {
+    const input = [
+      { name: "github", skillName: "github", description: "GitHub" },
+      { name: "github_2", skillName: "github", description: "GitHub" },
+      { name: "weather", skillName: "weather", description: "Weather" },
+      { name: "weather_2", skillName: "weather", description: "Weather" },
+    ];
+    const output = skillCommandsTesting.dedupeBySkillName(input);
+    expect(output.map((e) => e.name)).toEqual(["github", "weather"]);
+  });
+
+  it("matches skillName case-insensitively", () => {
+    const input = [
+      { name: "ClawHub", skillName: "ClawHub", description: "ClawHub" },
+      { name: "clawhub_2", skillName: "clawhub", description: "ClawHub" },
+    ];
+    const output = skillCommandsTesting.dedupeBySkillName(input);
+    expect(output).toHaveLength(1);
+    expect(output[0]?.name).toBe("ClawHub");
+  });
+
+  it("passes through commands with an empty skillName", () => {
+    const input = [
+      { name: "a", skillName: "", description: "A" },
+      { name: "b", skillName: "", description: "B" },
+    ];
+    expect(skillCommandsTesting.dedupeBySkillName(input)).toHaveLength(2);
+  });
+
+  it("returns an empty array for empty input", () => {
+    expect(skillCommandsTesting.dedupeBySkillName([])).toEqual([]);
+  });
+});
diff --git a/src/auto-reply/skill-commands.ts b/src/auto-reply/skill-commands.ts
@@ -41,6 +41,26 @@ export function listSkillCommandsForWorkspace(params: {
   });
 }
 
+// Deduplicate skill commands by skillName, keeping the first registration.
+// When multiple agents have a skill with the same name (e.g. one with a
+// workspace override and one from bundled), the suffix-renamed entries
+// (github_2, github_3…) are dropped so every interface sees a clean list.
+function dedupeBySkillName(commands: SkillCommandSpec[]): SkillCommandSpec[] {
+  const seen = new Set<string>();
+  const out: SkillCommandSpec[] = [];
+  for (const cmd of commands) {
+    const key = cmd.skillName.trim().toLowerCase();
+    if (key && seen.has(key)) {
+      continue;
+    }
+    if (key) {
+      seen.add(key);
+    }
+    out.push(cmd);
+  }
+  return out;
+}
+
 export function listSkillCommandsForAgents(params: {
   cfg: OpenClawConfig;
   agentIds?: string[];
@@ -72,9 +92,16 @@ export function listSkillCommandsForAgents(params: {
       entries.push(command);
     }
   }
-  return entries;
+  // Dedupe by skillName across workspaces so every interface (Discord, TUI,
+  // Slack, text) sees a consistent command list without platform-specific
+  // workarounds.
+  return dedupeBySkillName(entries);
 }
 
+export const __testing = {
+  dedupeBySkillName,
+};
+
 function normalizeSkillCommandLookup(value: string): string {
   return value
     .trim()
diff --git a/src/discord/monitor/provider.skill-dedupe.test.ts b/src/discord/monitor/provider.skill-dedupe.test.ts
@@ -1,30 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { __testing } from "./provider.js";
 
-describe("dedupeSkillCommandsForDiscord", () => {
-  it("keeps first command per skillName and drops suffix duplicates", () => {
-    const input = [
-      { name: "github", skillName: "github", description: "GitHub" },
-      { name: "github_2", skillName: "github", description: "GitHub" },
-      { name: "weather", skillName: "weather", description: "Weather" },
-      { name: "weather_2", skillName: "weather", description: "Weather" },
-    ];
-
-    const output = __testing.dedupeSkillCommandsForDiscord(input);
-    expect(output.map((entry) => entry.name)).toEqual(["github", "weather"]);
-  });
-
-  it("treats skillName case-insensitively", () => {
-    const input = [
-      { name: "ClawHub", skillName: "ClawHub", description: "ClawHub" },
-      { name: "clawhub_2", skillName: "clawhub", description: "ClawHub" },
-    ];
-    const output = __testing.dedupeSkillCommandsForDiscord(input);
-    expect(output).toHaveLength(1);
-    expect(output[0]?.name).toBe("ClawHub");
-  });
-});
-
 describe("resolveThreadBindingsEnabled", () => {
   it("defaults to enabled when unset", () => {
     expect(
diff --git a/src/discord/monitor/provider.ts b/src/discord/monitor/provider.ts
@@ -149,25 +149,6 @@ function formatThreadBindingSessionTtlLabel(ttlMs: number): string {
   return label === "disabled" ? "off" : label;
 }
 
-function dedupeSkillCommandsForDiscord(
-  skillCommands: ReturnType<typeof listSkillCommandsForAgents>,
-) {
-  const seen = new Set<string>();
-  const deduped: ReturnType<typeof listSkillCommandsForAgents> = [];
-  for (const command of skillCommands) {
-    const key = command.skillName.trim().toLowerCase();
-    if (!key) {
-      deduped.push(command);
-      continue;
-    }
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    deduped.push(command);
-  }
-  return deduped;
-}
 
 async function deployDiscordCommands(params: {
   client: Client;
@@ -334,7 +315,7 @@ export async function monitorDiscordProvider(opts: MonitorDiscordOpts = {}) {
   const maxDiscordCommands = 100;
   let skillCommands =
     nativeEnabled && nativeSkillsEnabled
-      ? dedupeSkillCommandsForDiscord(listSkillCommandsForAgents({ cfg }))
+      ? listSkillCommandsForAgents({ cfg })
       : [];
   let commandSpecs = nativeEnabled
     ? listNativeCommandSpecsForConfig(cfg, { skillCommands, provider: "discord" })
@@ -637,7 +618,6 @@ async function clearDiscordNativeCommands(params: {
 
 export const __testing = {
   createDiscordGatewayPlugin,
-  dedupeSkillCommandsForDiscord,
   resolveDiscordRuntimeGroupPolicy: resolveOpenProviderRuntimeGroupPolicy,
   resolveDefaultGroupPolicy,
   resolveDiscordRestFetch,
