@@ -352,23 +352,64 @@ function nonEmptyProbeString(value: string): string | undefined {
 function parseClaudeInitializationCommands(
   commands: ReadonlyArray<ClaudeSlashCommand> | undefined,
 ): ReadonlyArray<ServerProviderSlashCommand> {
-  return (commands ?? []).flatMap((command) => {
+  return dedupeSlashCommands(
+    (commands ?? []).flatMap((command) => {
+      const name = nonEmptyProbeString(command.name);
+      if (!name) {
+        return [];
+      }
+
+      const description = nonEmptyProbeString(command.description);
+      const argumentHint = nonEmptyProbeString(command.argumentHint);
+
+      return [
+        {
+          name,
+          ...(description ? { description } : {}),
+          ...(argumentHint ? { input: { hint: argumentHint } } : {}),
+        } satisfies ServerProviderSlashCommand,
+      ];
+    }),
+  );
+}
+
+function dedupeSlashCommands(
+  commands: ReadonlyArray<ServerProviderSlashCommand>,
+): ReadonlyArray<ServerProviderSlashCommand> {
+  const commandsByName = new Map<string, ServerProviderSlashCommand>();
+
+  for (const command of commands) {
     const name = nonEmptyProbeString(command.name);
     if (!name) {
-      return [];
+      continue;
     }
 
-    const description = nonEmptyProbeString(command.description);
-    const argumentHint = nonEmptyProbeString(command.argumentHint);
-
-    return [
-      {
+    const key = name.toLowerCase();
+    const existing = commandsByName.get(key);
+    if (!existing) {
+      commandsByName.set(key, {
+        ...command,
         name,
-        ...(description ? { description } : {}),
-        ...(argumentHint ? { input: { hint: argumentHint } } : {}),
-      } satisfies ServerProviderSlashCommand,
-    ];
-  });
+      });
+      continue;
+    }
+
+    commandsByName.set(key, {
+      ...existing,
+      ...(existing.description
+        ? {}
+        : command.description
+          ? { description: command.description }
+          : {}),
+      ...(existing.input?.hint
+        ? {}
+        : command.input?.hint
+          ? { input: { hint: command.input.hint } }
+          : {}),
+    });
+  }
+
+  return [...commandsByName.values()];
 }
 
 /**
@@ -534,6 +575,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
           Effect.orElseSucceed(() => undefined),
         )
       : undefined) ?? [];
+  const dedupedSlashCommands = dedupeSlashCommands(slashCommands);
 
   // ── Auth check + subscription detection ────────────────────────────
 
@@ -569,7 +611,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
       enabled: claudeSettings.enabled,
       checkedAt,
       models,
-      slashCommands,
+      slashCommands: dedupedSlashCommands,
       probe: {
         installed: true,
         version: parsedVersion,
@@ -589,7 +631,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
       enabled: claudeSettings.enabled,
       checkedAt,
       models,
-      slashCommands,
+      slashCommands: dedupedSlashCommands,
       probe: {
         installed: true,
         version: parsedVersion,
@@ -607,7 +649,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
     enabled: claudeSettings.enabled,
     checkedAt,
     models,
-    slashCommands,
+    slashCommands: dedupedSlashCommands,
     probe: {
       installed: true,
       version: parsedVersion,
 
@@ -972,6 +972,47 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsService.layerTest()))(
         ),
       );
 
+      it.effect("deduplicates probed claude slash commands by name", () =>
+        Effect.gen(function* () {
+          const status = yield* checkClaudeProviderStatus(
+            () => Effect.succeed("maxplan"),
+            () =>
+              Effect.succeed([
+                {
+                  name: "ui",
+                  description: "Explore and refine UI",
+                },
+                {
+                  name: "ui",
+                  input: { hint: "component-or-screen" },
+                },
+              ]),
+          );
+
+          assert.deepStrictEqual(status.slashCommands, [
+            {
+              name: "ui",
+              description: "Explore and refine UI",
+              input: { hint: "component-or-screen" },
+            },
+          ]);
+        }).pipe(
+          Effect.provide(
+            mockSpawnerLayer((args) => {
+              const joined = args.join(" ");
+              if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 };
+              if (joined === "auth status")
+                return {
+                  stdout: '{"loggedIn":true,"authMethod":"claude.ai"}\n',
+                  stderr: "",
+                  code: 0,
+                };
+              throw new Error(`Unexpected args: ${joined}`);
+            }),
+          ),
+        ),
+      );
+
       it.effect("returns an api key label for claude api key auth", () =>
         Effect.gen(function* () {
           const status = yield* checkClaudeProviderStatus();
 
@@ -69,6 +69,7 @@ import { ComposerPrimaryActions } from "./ComposerPrimaryActions";
 import { ComposerPendingApprovalPanel } from "./ComposerPendingApprovalPanel";
 import { ComposerPendingUserInputPanel } from "./ComposerPendingUserInputPanel";
 import { ComposerPlanFollowUpBanner } from "./ComposerPlanFollowUpBanner";
+import { searchSlashCommandItems } from "./composerSlashCommandSearch";
 import {
   getComposerProviderState,
   renderProviderTraitsMenuContent,
@@ -748,14 +749,7 @@ export const ChatComposer = memo(
         if (!query) {
           return slashCommandItems;
         }
-        return slashCommandItems.filter(
-          (item) =>
-            item.label.slice(1).toLowerCase().includes(query) ||
-            item.description.toLowerCase().includes(query) ||
-            (item.type === "slash-command"
-              ? item.command.includes(query)
-              : item.command.name.toLowerCase().includes(query)),
-        );
+        return searchSlashCommandItems(slashCommandItems, query);
       }
       if (composerTrigger.kind === "skill") {
         return searchProviderSkills(
@@ -868,7 +862,7 @@ export const ChatComposer = memo(
     // ------------------------------------------------------------------
     const setPromptFromTraits = useCallback(
       (nextPrompt: string) => {
-        if (nextPrompt === prompt) {
+        if (nextPrompt === promptRef.current) {
           scheduleComposerFocus();
           return;
         }
@@ -879,7 +873,7 @@ export const ChatComposer = memo(
         setComposerTrigger(detectComposerTrigger(nextPrompt, nextPrompt.length));
         scheduleComposerFocus();
       },
-      [composerDraftTarget, prompt, promptRef, scheduleComposerFocus, setComposerDraftPrompt],
+      [composerDraftTarget, promptRef, scheduleComposerFocus, setComposerDraftPrompt],
     );
 
     const providerTraitsMenuContent = renderProviderTraitsMenuContent({
@@ -1763,6 +1757,10 @@ export const ChatComposer = memo(
                     resolvedTheme={resolvedTheme}
                     isLoading={isComposerMenuLoading}
                     triggerKind={composerTriggerKind}
+                    groupSlashCommandSections={
+                      composerTrigger?.kind === "slash-command" &&
+                      composerTrigger.query.trim().length === 0
+                    }
                     emptyStateText={composerMenuEmptyState}
                     activeItemId={activeComposerMenuItem?.id ?? null}
                     onHighlightedItemChange={onComposerMenuItemHighlighted}
 
@@ -90,11 +90,12 @@ function SkillGlyph(props: { className?: string }) {
 function groupCommandItems(
   items: ComposerCommandItem[],
   triggerKind: ComposerTriggerKind | null,
+  groupSlashCommandSections: boolean,
 ): ComposerCommandGroup[] {
   if (triggerKind === "skill") {
     return items.length > 0 ? [{ id: "skills", label: "Skills", items }] : [];
   }
-  if (triggerKind !== "slash-command") {
+  if (triggerKind !== "slash-command" || !groupSlashCommandSections) {
     return [{ id: "default", label: null, items }];
   }
 
@@ -116,15 +117,17 @@ export const ComposerCommandMenu = memo(function ComposerCommandMenu(props: {
   resolvedTheme: "light" | "dark";
   isLoading: boolean;
   triggerKind: ComposerTriggerKind | null;
+  groupSlashCommandSections?: boolean;
   emptyStateText?: string;
   activeItemId: string | null;
   onHighlightedItemChange: (itemId: string | null) => void;
   onSelect: (item: ComposerCommandItem) => void;
 }) {
   const listRef = useRef<HTMLDivElement>(null);
   const groups = useMemo(
-    () => groupCommandItems(props.items, props.triggerKind),
-    [props.items, props.triggerKind],
+    () =>
+      groupCommandItems(props.items, props.triggerKind, props.groupSlashCommandSections ?? true),
+    [props.groupSlashCommandSections, props.items, props.triggerKind],
   );
 
   useLayoutEffect(() => {
 
@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+
+import type { ComposerCommandItem } from "./ComposerCommandMenu";
+import { searchSlashCommandItems } from "./composerSlashCommandSearch";
+
+describe("searchSlashCommandItems", () => {
+  it("moves exact provider command matches ahead of broader description matches", () => {
+    const items = [
+      {
+        id: "slash:default",
+        type: "slash-command",
+        command: "default",
+        label: "/default",
+        description: "Switch this thread back to normal build mode",
+      },
+      {
+        id: "provider-slash-command:claudeAgent:ui",
+        type: "provider-slash-command",
+        provider: "claudeAgent",
+        command: { name: "ui" },
+        label: "/ui",
+        description: "Explore, build, and refine UI.",
+      },
+      {
+        id: "provider-slash-command:claudeAgent:frontend-design",
+        type: "provider-slash-command",
+        provider: "claudeAgent",
+        command: { name: "frontend-design" },
+        label: "/frontend-design",
+        description: "Create distinctive, production-grade frontend interfaces",
+      },
+    ] satisfies Array<
+      Extract<ComposerCommandItem, { type: "slash-command" | "provider-slash-command" }>
+    >;
+
+    expect(searchSlashCommandItems(items, "ui").map((item) => item.id)).toEqual([
+      "provider-slash-command:claudeAgent:ui",
+      "slash:default",
+    ]);
+  });
+
+  it("supports fuzzy provider command matches", () => {
+    const items = [
+      {
+        id: "provider-slash-command:claudeAgent:gh-fix-ci",
+        type: "provider-slash-command",
+        provider: "claudeAgent",
+        command: { name: "gh-fix-ci" },
+        label: "/gh-fix-ci",
+        description: "Fix failing GitHub Actions",
+      },
+      {
+        id: "provider-slash-command:claudeAgent:github",
+        type: "provider-slash-command",
+        provider: "claudeAgent",
+        command: { name: "github" },
+        label: "/github",
+        description: "General GitHub help",
+      },
+    ] satisfies Array<
+      Extract<ComposerCommandItem, { type: "slash-command" | "provider-slash-command" }>
+    >;
+
+    expect(searchSlashCommandItems(items, "gfc").map((item) => item.id)).toEqual([
+      "provider-slash-command:claudeAgent:gh-fix-ci",
+    ]);
+  });
+});
@@ -0,0 +1,83 @@
+import {
+  insertRankedSearchResult,
+  normalizeSearchQuery,
+  scoreQueryMatch,
+} from "@t3tools/shared/searchRanking";
+
+import type { ComposerCommandItem } from "./ComposerCommandMenu";
+
+function scoreSlashCommandItem(
+  item: Extract<ComposerCommandItem, { type: "slash-command" | "provider-slash-command" }>,
+  query: string,
+): number | null {
+  const primaryValue =
+    item.type === "slash-command" ? item.command.toLowerCase() : item.command.name.toLowerCase();
+  const description = item.description.toLowerCase();
+
+  const scores = [
+    scoreQueryMatch({
+      value: primaryValue,
+      query,
+      exactBase: 0,
+      prefixBase: 2,
+      boundaryBase: 4,
+      includesBase: 6,
+      fuzzyBase: 100,
+      boundaryMarkers: ["-", "_", "/"],
+    }),
+    scoreQueryMatch({
+      value: description,
+      query,
+      exactBase: 20,
+      prefixBase: 22,
+      boundaryBase: 24,
+      includesBase: 26,
+    }),
+  ].filter((score): score is number => score !== null);
+
+  if (scores.length === 0) {
+    return null;
+  }
+
+  return Math.min(...scores);
+}
+
+export function searchSlashCommandItems(
+  items: ReadonlyArray<
+    Extract<ComposerCommandItem, { type: "slash-command" | "provider-slash-command" }>
+  >,
+  query: string,
+): Array<Extract<ComposerCommandItem, { type: "slash-command" | "provider-slash-command" }>> {
+  const normalizedQuery = normalizeSearchQuery(query, { trimLeadingPattern: /^\/+/ });
+  if (!normalizedQuery) {
+    return [...items];
+  }
+
+  const ranked: Array<{
+    item: Extract<ComposerCommandItem, { type: "slash-command" | "provider-slash-command" }>;
+    score: number;
+    tieBreaker: string;
+  }> = [];
+
+  for (const item of items) {
+    const score = scoreSlashCommandItem(item, normalizedQuery);
+    if (score === null) {
+      continue;
+    }
+
+    insertRankedSearchResult(
+      ranked,
+      {
+        item,
+        score,
+        tieBreaker:
+          item.type === "slash-command"
+            ? `0\u0000${item.command}`
+            : `1\u0000${item.command.name}\u0000${item.provider}`,
+      },
+      Number.POSITIVE_INFINITY,
+    );
+  }
+
+  return ranked.map((entry) => entry.item);
+}