fix(skills): load provider skills from active workspace

apps/mobile/src/features/threads/NewTaskDraftScreen.tsx

@@ -1,11 +1,12 @@
 import { NativeHeaderToolbar, NativeStackScreenOptions } from "../../native/StackHeader";
+import type { ProviderWorkspaceContext } from "@t3tools/contracts";
 import {
   StackActions,
   useFocusEffect,
   useNavigation,
   usePreventRemove,
 } from "@react-navigation/native";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Alert, Platform, Pressable, ScrollView, View } from "react-native";
 import {
   KeyboardController,
@@ -218,13 +219,27 @@ export function NewTaskDraftScreen(props: {
   const isIncomingShareTransferPending = Boolean(
     incomingShare && cancelledIncomingShareId !== props.incomingShareId,
   );
+  const providerWorkspaceContext = useMemo<ProviderWorkspaceContext | null>(
+    () =>
+      selectedProject === null
+        ? null
+        : flow.workspaceMode === "local" && flow.selectedWorktreePath !== null
+          ? {
+              _tag: "worktree",
+              projectId: selectedProject.id,
+              worktreePath: flow.selectedWorktreePath,
+            }
+          : { _tag: "project", projectId: selectedProject.id },
+    [flow.selectedWorktreePath, flow.workspaceMode, selectedProject?.id],
+  );
   const composerMenu = useComposerCommandMenu({
     draftMessage: flow.prompt,
     environmentId: selectedProject?.environmentId ?? null,
     projectCwd:
       (flow.workspaceMode === "worktree"
         ? selectedProject?.workspaceRoot
         : (flow.selectedWorktreePath ?? selectedProject?.workspaceRoot)) || null,
+    workspaceContext: providerWorkspaceContext,
     selectedProviderStatus: flow.selectedProviderStatus,
     hasThread: false,
     enabled: isComposerFocused && !isIncomingShareTransferPending,
@@ -843,7 +858,7 @@ export function NewTaskDraftScreen(props: {
       multiline
       scrollEnabled
       value={flow.prompt}
-      skills={flow.selectedProviderStatus?.skills ?? []}
+      skills={composerMenu.editorSkills}
       selection={composerMenu.selection}
       onChangeText={flow.setPrompt}
       onSelectionChange={composerMenu.onSelectionChange}

apps/mobile/src/features/threads/ThreadComposer.tsx

@@ -313,6 +313,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
     draftMessage: props.draftMessage,
     environmentId: props.environmentId,
     projectCwd: props.projectCwd,
+    workspaceContext: { _tag: "thread", threadId: props.selectedThread.id },
     selectedProviderStatus,
     hasThread: true,
     onChangeDraftMessage: props.onChangeDraftMessage,
@@ -523,7 +524,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
               ref={inputRef}
               multiline
               value={props.draftMessage}
-              skills={selectedProviderStatus?.skills ?? []}
+              skills={composerMenu.editorSkills}
               selection={composerMenu.selection}
               onChangeText={props.onChangeDraftMessage}
               onSelectionChange={composerMenu.onSelectionChange}

apps/mobile/src/features/threads/use-composer-command-menu.ts

@@ -1,9 +1,16 @@
-import type { EnvironmentId, ProviderInteractionMode, ServerProvider } from "@t3tools/contracts";
+import type {
+  EnvironmentId,
+  ProviderInteractionMode,
+  ProviderWorkspaceContext,
+  ServerProvider,
+  ServerProviderSkill,
+} from "@t3tools/contracts";
 import {
   detectComposerTrigger,
   replaceTextRange,
   serializeComposerFileLink,
 } from "@t3tools/shared/composerTrigger";
+import { collectComposerInlineTokens } from "@t3tools/shared/composerInlineTokens";
 import {
   insertRankedSearchResult,
   normalizeSearchQuery,
@@ -12,15 +19,20 @@ import {
 import { useCallback, useEffect, useMemo, useState } from "react";
 
 import type { ComposerEditorSelection } from "../../components/ComposerEditor";
+import { useEnvironmentQuery } from "../../state/query";
+import { serverEnvironment } from "../../state/server";
 import { useComposerPathSearch } from "../../state/use-composer-path-search";
 import type { ComposerCommandItem } from "./ComposerCommandPopover";
 import { matchesSlashSkillQuery } from "./composerSlashSkillSearch";
 
+const EMPTY_PROVIDER_SKILLS: ReadonlyArray<ServerProviderSkill> = [];
+
 /** Shared autocomplete for thread composers and unsent new-task drafts. */
 export function useComposerCommandMenu({
   draftMessage,
   environmentId,
   projectCwd,
+  workspaceContext,
   selectedProviderStatus,
   hasThread,
   enabled = true,
@@ -30,6 +42,7 @@ export function useComposerCommandMenu({
   readonly draftMessage: string;
   readonly environmentId: EnvironmentId | null;
   readonly projectCwd: string | null;
+  readonly workspaceContext: ProviderWorkspaceContext | null;
   readonly selectedProviderStatus: ServerProvider | null;
   readonly hasThread: boolean;
   readonly enabled?: boolean;
@@ -66,6 +79,42 @@ export function useComposerCommandMenu({
     cwd: trigger?.kind === "path" ? projectCwd : null,
     query: trigger?.kind === "path" ? trigger.query : null,
   });
+  const hasProviderSkillToken = useMemo(
+    () => collectComposerInlineTokens(draftMessage).some((token) => token.type === "skill"),
+    [draftMessage],
+  );
+  const workspaceSkillsTarget =
+    environmentId !== null &&
+    selectedProviderStatus !== null &&
+    workspaceContext !== null &&
+    (trigger?.kind === "skill" || trigger?.kind === "slash-command" || hasProviderSkillToken)
+      ? {
+          environmentId,
+          input: {
+            instanceId: selectedProviderStatus.instanceId,
+            context: workspaceContext,
+          },
+        }
+      : null;
+  const workspaceSkillsQuery = useEnvironmentQuery(
+    workspaceSkillsTarget === null
+      ? null
+      : serverEnvironment.workspaceSkills(workspaceSkillsTarget),
+  );
+  const providerSkills =
+    workspaceSkillsTarget === null
+      ? (selectedProviderStatus?.skills ?? EMPTY_PROVIDER_SKILLS)
+      : workspaceSkillsQuery.data === null
+        ? workspaceSkillsQuery.error === null
+          ? EMPTY_PROVIDER_SKILLS
+          : (selectedProviderStatus?.skills ?? EMPTY_PROVIDER_SKILLS)
+        : (workspaceSkillsQuery.data.skills ??
+          selectedProviderStatus?.skills ??
+          EMPTY_PROVIDER_SKILLS);
+  const editorSkills =
+    providerSkills.length > 0
+      ? providerSkills
+      : (selectedProviderStatus?.skills ?? EMPTY_PROVIDER_SKILLS);
 
   const items = useMemo<ComposerCommandItem[]>(() => {
     if (!trigger) return [];
@@ -121,7 +170,7 @@ export function useComposerCommandMenu({
         });
       }
 
-      const skillItems = (selectedProviderStatus?.skills ?? [])
+      const skillItems = providerSkills
         .filter((skill) => matchesSlashSkillQuery(skill, q))
         .map((skill) => ({
           id: `skill:${skill.name}`,
@@ -135,7 +184,7 @@ export function useComposerCommandMenu({
     }
 
     if (trigger.kind === "skill") {
-      const enabledSkills = (selectedProviderStatus?.skills ?? []).filter((skill) => skill.enabled);
+      const enabledSkills = providerSkills.filter((skill) => skill.enabled);
       const normalizedQuery = normalizeSearchQuery(trigger.query, {
         trimLeadingPattern: /^\$+/,
       });
@@ -232,7 +281,14 @@ export function useComposerCommandMenu({
     }
 
     return [];
-  }, [hasThread, onUpdateInteractionMode, pathSearch.entries, selectedProviderStatus, trigger]);
+  }, [
+    hasThread,
+    onUpdateInteractionMode,
+    pathSearch.entries,
+    providerSkills,
+    selectedProviderStatus,
+    trigger,
+  ]);
 
   const onSelect = useCallback(
     (item: ComposerCommandItem) => {
@@ -277,7 +333,12 @@ export function useComposerCommandMenu({
     onSelectionChange,
     trigger,
     items,
-    isLoading: pathSearch.isPending,
+    providerSkills,
+    editorSkills,
+    isLoading:
+      (trigger?.kind === "path" && trigger.query.length > 0 && pathSearch.isPending) ||
+      ((trigger?.kind === "skill" || trigger?.kind === "slash-command") &&
+        workspaceSkillsQuery.isPending),
     onSelect,
   };
 }

apps/server/src/auth/RpcAuthorization.test.ts

@@ -43,6 +43,12 @@ describe("RPC authorization scopes", () => {
     );
   });
 
+  it("reads workspace skills under the orchestration read scope", () => {
+    expect(requiredScopeForRpcMethod(WS_METHODS.providerGetWorkspaceSkills)).toBe(
+      AuthOrchestrationReadScope,
+    );
+  });
+
   it("reads the reviewer menu under the same scope as the pull request it belongs to", () => {
     // The candidate list is a read like the detail beside it, and asking somebody for a review is
     // a write like every other pull request operation.

apps/server/src/auth/RpcAuthorization.ts

@@ -87,6 +87,7 @@ export const RPC_REQUIRED_SCOPES = {
   [WS_METHODS.attachmentsCreateUploadUrl]: AuthOrchestrationOperateScope,
   [WS_METHODS.attachmentsDelete]: AuthOrchestrationOperateScope,
   [WS_METHODS.providerUploadFeedback]: AuthOrchestrationOperateScope,
+  [WS_METHODS.providerGetWorkspaceSkills]: AuthOrchestrationReadScope,
   [WS_METHODS.subscribeVcsStatus]: AuthOrchestrationReadScope,
   [WS_METHODS.subscribeResourceTelemetry]: AuthOrchestrationReadScope,
   [WS_METHODS.vcsRefreshStatus]: AuthOrchestrationReadScope,

apps/server/src/provider/Drivers/ClaudeDriver.ts

@@ -56,6 +56,7 @@ import {
   type ProviderSnapshotSettings,
 } from "../providerUpdateSettings.ts";
 import { makeClaudeCapabilitiesCacheKey, makeClaudeContinuationGroupKey } from "./ClaudeHome.ts";
+import { discoverClaudeSkills } from "./ClaudeSkills.ts";
 const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings);
 
 const DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
@@ -221,6 +222,11 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
             }),
         ),
       );
+      const loadWorkspaceSkills = (workspaceCwd: string) =>
+        discoverClaudeSkills(effectiveConfig, workspaceCwd, processEnv).pipe(
+          Effect.provideService(FileSystem.FileSystem, fileSystem),
+          Effect.provideService(Path.Path, path),
+        );
 
       return {
         instanceId,
@@ -235,6 +241,7 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
         snapshot,
         adapter,
         textGeneration,
+        loadWorkspaceSkills,
       } satisfies ProviderInstance;
     }),
 };

apps/server/src/provider/Drivers/CodexDriver.ts

@@ -21,7 +21,12 @@
  *
  * @module provider/Drivers/CodexDriver
  */
-import { CodexSettings, ProviderDriverKind, type ServerProvider } from "@t3tools/contracts";
+import {
+  CodexSettings,
+  ProviderDriverKind,
+  ProviderWorkspaceSkillsError,
+  type ServerProvider,
+} from "@t3tools/contracts";
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
@@ -36,7 +41,11 @@ import { ServerConfig } from "../../config.ts";
 import { ServerSettingsService } from "../../serverSettings.ts";
 import { ProviderDriverError } from "../Errors.ts";
 import { makeCodexAdapter } from "../Layers/CodexAdapter.ts";
-import { checkCodexProviderStatus, makePendingCodexProvider } from "../Layers/CodexProvider.ts";
+import {
+  checkCodexProviderStatus,
+  loadCodexWorkspaceSkills,
+  makePendingCodexProvider,
+} from "../Layers/CodexProvider.ts";
 import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
 import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
 import * as ModelManifest from "../ModelManifest.ts";
@@ -216,6 +225,18 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = {
             }),
         ),
       );
+      const loadWorkspaceSkills = (workspaceCwd: string) =>
+        loadCodexWorkspaceSkills(effectiveConfig, workspaceCwd, processEnv).pipe(
+          Effect.mapError(
+            (cause) =>
+              new ProviderWorkspaceSkillsError({
+                instanceId,
+                cwd: workspaceCwd,
+                cause,
+              }),
+          ),
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        );
 
       return {
         instanceId,
@@ -227,6 +248,7 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = {
         snapshot,
         adapter,
         textGeneration,
+        loadWorkspaceSkills,
       } satisfies ProviderInstance;
     }),
 };

apps/server/src/provider/Layers/CodexProvider.ts

@@ -318,14 +318,28 @@ export function buildCodexInitializeParams(): CodexSchema.V1InitializeParams {
   };
 }
 
-const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(function* (input: {
+const CODEX_PROVIDER_PROBE_INITIALIZE_PARAMS = {
+  clientInfo: {
+    name: "t3code_desktop",
+    title: "T3 Code Desktop",
+    version: "0.1.0",
+  },
+  capabilities: {
+    experimentalApi: true,
+  },
+} satisfies CodexSchema.V1InitializeParams;
+
+type CodexProviderClientInput = {
   readonly binaryPath: string;
   readonly homePath?: string;
   readonly launchArgs?: string;
   readonly cwd: string;
-  readonly customModels?: ReadonlyArray<string>;
   readonly environment?: NodeJS.ProcessEnv;
-}) {
+};
+
+const openCodexProviderClient = Effect.fn("openCodexProviderClient")(function* (
+  input: CodexProviderClientInput,
+) {
   // `~` is not shell-expanded when env vars are set via `child_process.spawn`,
   // so `CODEX_HOME=~/.codex_work` would reach codex verbatim and trip
   // "CODEX_HOME points to '~/.codex_work', but that path does not exist".
@@ -368,18 +382,22 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
     Effect.provide(clientContext),
   );
 
-  const initialize = yield* client.request("initialize", {
-    clientInfo: {
-      name: "t3code_desktop",
-      title: "T3 Code Desktop",
-      version: "0.1.0",
-    },
-    capabilities: {
-      experimentalApi: true,
-    },
-  });
+  const initialize = yield* client.request("initialize", CODEX_PROVIDER_PROBE_INITIALIZE_PARAMS);
   yield* client.notify("initialized", undefined);
 
+  return { client, initialize };
+});
+
+const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(function* (input: {
+  readonly binaryPath: string;
+  readonly homePath?: string;
+  readonly launchArgs?: string;
+  readonly cwd: string;
+  readonly customModels?: ReadonlyArray<string>;
+  readonly environment?: NodeJS.ProcessEnv;
+}) {
+  const { client, initialize } = yield* openCodexProviderClient(input);
+
   // Extract the version string after the first '/' in userAgent, up to the next space or the end
   const versionMatch = initialize.userAgent.match(/\/([^\s]+)/);
   const version = versionMatch ? versionMatch[1] : undefined;
@@ -414,6 +432,23 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
   } satisfies CodexAppServerProviderSnapshot;
 });
 
+export const loadCodexWorkspaceSkills = Effect.fn("loadCodexWorkspaceSkills")(
+  function* (codexSettings: CodexSettings, cwd: string, environment?: NodeJS.ProcessEnv) {
+    const resolvedEnvironment = environment ?? process.env;
+    const { client } = yield* openCodexProviderClient({
+      binaryPath: codexSettings.binaryPath,
+      homePath: codexSettings.homePath,
+      launchArgs: resolveCodexLaunchArgs(codexSettings.launchArgs, resolvedEnvironment),
+      cwd,
+      environment: resolvedEnvironment,
+    });
+    const response = yield* client.request("skills/list", { cwds: [cwd] });
+    return parseCodexSkillsListResponse(response, cwd);
+  },
+  Effect.scoped,
+  Effect.timeout(Duration.millis(AUTH_PROBE_TIMEOUT_MS)),
+);
+
 const emptyCodexModelsFromSettings = (codexSettings: CodexSettings): ServerProvider["models"] => {
   const models = new Set<string>();
   for (const model of codexSettings.customModels) {