@@ -12,6 +12,7 @@ import {
 import {
   dedupeProviderSkillsByName,
   getProviderSkillsForSlashMenu,
+  isProviderSkillUserInvocable,
 } from "@t3tools/client-runtime/providerSkills";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
@@ -114,8 +115,14 @@ export function useComposerCommandMenu({
           (item.command === "model" || onUpdateInteractionMode !== undefined),
       );
 
+      // A provider expands a slash command only when it opens the whole
+      // message; elsewhere it arrives as literal text. Built-ins apply
+      // locally and skills insert a `$` mention the server dispatches from
+      // any position, so only provider commands are position-gated.
       const providerCommands: ComposerCommandItem[] = [];
-      for (const command of selectedProviderStatus?.slashCommands ?? []) {
+      const expandableCommands =
+        trigger.rangeStart === 0 ? (selectedProviderStatus?.slashCommands ?? []) : [];
+      for (const command of expandableCommands) {
         if (!command.name.toLowerCase().includes(q)) continue;
         // Codex feedback uploads an existing thread's session and logs.
         if (
@@ -149,7 +156,7 @@ export function useComposerCommandMenu({
 
     if (trigger.kind === "skill") {
       const enabledSkills = dedupeProviderSkillsByName(
-        (selectedProviderStatus?.skills ?? []).filter((skill) => skill.enabled),
+        (selectedProviderStatus?.skills ?? []).filter(isProviderSkillUserInvocable),
       );
       const normalizedQuery = normalizeSearchQuery(trigger.query, {
         trimLeadingPattern: /^\$+/,
 
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { planClaudeSkillDispatch } from "./ClaudeSkillDispatch.ts";
+
+const SKILLS = new Set(["implement", "review", "re-release-version"]);
+
+describe("planClaudeSkillDispatch", () => {
+  it("leaves a prompt without a known skill untouched", () => {
+    expect(planClaudeSkillDispatch("fix the build", SKILLS)).toBeUndefined();
+    // Not a discovered skill, so it stays prose rather than becoming a command.
+    expect(planClaudeSkillDispatch("echo $HOME then $unknown", SKILLS)).toBeUndefined();
+  });
+
+  it("moves a mid-prompt mention into a trailing slash command", () => {
+    expect(planClaudeSkillDispatch("ok, now $implement all the tickets", SKILLS)).toEqual({
+      leadingText: "ok, now",
+      commandText: "/implement all the tickets",
+      skillName: "implement",
+    });
+  });
+
+  it("keeps a mention that opens the prompt as a single command block", () => {
+    expect(planClaudeSkillDispatch("$review\nfocus on auth", SKILLS)).toEqual({
+      leadingText: undefined,
+      commandText: "/review\nfocus on auth",
+      skillName: "review",
+    });
+  });
+
+  it("dispatches the last mention and rewrites earlier ones inline", () => {
+    expect(planClaudeSkillDispatch("$review the diff, then $implement the fixes", SKILLS)).toEqual({
+      leadingText: "/review the diff, then",
+      commandText: "/implement the fixes",
+      skillName: "implement",
+    });
+  });
+
+  it("ignores a dollar token glued to other text", () => {
+    expect(planClaudeSkillDispatch("cost is 5$implement", SKILLS)).toBeUndefined();
+  });
+});
@@ -0,0 +1,78 @@
+/**
+ * ClaudeSkillDispatch — turns `$skill` mentions in a composer prompt into the
+ * slash invocation Claude Code actually runs.
+ *
+ * The composer inserts `$name` for every provider. Codex parses that natively;
+ * Claude Code does not, and treats it as prose. Claude Code's only user-side
+ * invocation is a text block whose first character is `/`: the harness
+ * expands `/name args` into the SKILL.md body, and every character after the
+ * name (newlines included) arrives as `ARGUMENTS`. Verified against the CLI in
+ * stream-json mode, which is what the Agent SDK uses:
+ *
+ *  - The check runs on the LAST text block of the message. Earlier text
+ *    blocks are preserved verbatim, and image blocks may sit before it.
+ *  - Leading whitespace, or a `/name` that starts a later line of the same
+ *    block, is literal text.
+ *  - Only one skill expands per message; a second `/x` becomes argument text
+ *    (anthropics/claude-code#87113). The model still starts the rest through
+ *    its Skill tool when it reads `/name` in the prompt, so earlier mentions
+ *    are rewritten to `/name` inline.
+ *
+ * So one mention anywhere in the prompt becomes a guaranteed invocation, and
+ * the user's text on either side is kept in order.
+ *
+ * @module provider/Drivers/ClaudeSkillDispatch
+ */
+
+/**
+ * Same token shape the composer and timeline chips recognise
+ * (`packages/shared/src/composerInlineTokens.ts`), so a rendered chip and a
+ * dispatched skill are always the same set.
+ */
+const SKILL_MENTION_PATTERN = /(^|\s)\$([a-zA-Z][a-zA-Z0-9:_-]*)(?=\s|$)/g;
+
+export interface ClaudeSkillDispatch {
+  /** Text before the dispatched mention, or `undefined` when it opens the prompt. */
+  readonly leadingText: string | undefined;
+  /** `/name` plus the trailing text, ready to be the message's last text block. */
+  readonly commandText: string;
+  readonly skillName: string;
+}
+
+/**
+ * Split `prompt` around the last `$skill` mention that names a known skill.
+ * Returns `undefined` when there is nothing to dispatch, in which case the
+ * prompt should go out unchanged. Mentions that do not match a discovered
+ * skill stay literal: a `$HOME` in prose must not become a command.
+ */
+export function planClaudeSkillDispatch(
+  prompt: string,
+  skillNames: ReadonlySet<string>,
+): ClaudeSkillDispatch | undefined {
+  const mentions = [...prompt.matchAll(SKILL_MENTION_PATTERN)].flatMap((match) => {
+    const name = match[2] ?? "";
+    if (!skillNames.has(name)) return [];
+    const start = (match.index ?? 0) + (match[1]?.length ?? 0);
+    return [{ name, start, end: start + name.length + 1 }];
+  });
+  const last = mentions.at(-1);
+  if (!last) {
+    return undefined;
+  }
+
+  const leading = prompt.slice(0, last.start);
+  const trailing = prompt.slice(last.end);
+  const leadingWithInlineSlashes = mentions
+    .slice(0, -1)
+    .reduceRight(
+      (text, mention) => `${text.slice(0, mention.start)}/${text.slice(mention.start + 1)}`,
+      leading,
+    )
+    .trimEnd();
+
+  return {
+    leadingText: leadingWithInlineSlashes.length > 0 ? leadingWithInlineSlashes : undefined,
+    commandText: `/${last.name}${trailing}`.trimEnd(),
+    skillName: last.name,
+  };
+}