@aexol/opencode-wizard 0.1.14 → 0.1.15

package/dist/server.js

@@ -54,6 +54,7 @@ const statusPathLoginBootstrap = {
 };
 const importOpencodePluginModule = new Function('specifier', 'return import(specifier)');
 export const AVAILABLE_PUBLISHED_SKILL_TOOLS = ['opencode_wizard_published_skills_fetch', 'opencode_wizard_status'];
+let publishedSkillPreferenceCacheVersion = 0;
 export const NATIVE_SKILLS_URL_COMPATIBILITY = {
   configKey: 'skills.urls',
   deliveryMode: 'public_static_registry',
@@ -114,6 +115,137 @@ const PUBLISHED_SKILLS_CATALOG_QUERY = `
           publishedAt
         }
       }
+      catalogSkills {
+        skill {
+          id
+          slug
+          name
+          summary
+          whenToUse
+          status
+          installPolicy
+          tags {
+            id
+            slug
+            label
+            description
+            facet {
+              id
+              slug
+              label
+              description
+            }
+          }
+        }
+        skillVersion {
+          id
+          version
+          title
+          summary
+          status
+        }
+        publishedArtifact {
+          id
+          frontmatterName
+          frontmatterDescription
+          checksum
+          publishedAt
+        }
+      }
+      userPreferences {
+        scopeKey
+        userKey
+        ignoredSkills {
+          assignmentSource
+          assignmentType
+          scopePath
+          includeChildren
+          skill {
+            id
+            slug
+            name
+            summary
+            whenToUse
+            status
+            installPolicy
+            tags {
+              id
+              slug
+              label
+              description
+              facet {
+                id
+                slug
+                label
+                description
+              }
+            }
+          }
+          skillVersion {
+            id
+            version
+            title
+            summary
+            status
+          }
+          publishedArtifact {
+            id
+            frontmatterName
+            frontmatterDescription
+            checksum
+            publishedAt
+          }
+        }
+      }
+    }
+  }
+`;
+const SET_PUBLISHED_SKILL_PREFERENCE_MUTATION = `
+  mutation SetPublishedSkillPreference($input: SetPublishedSkillPreferenceInput!) {
+    setPublishedSkillPreference(input: $input) {
+      scopeKey
+      userKey
+      ignoredSkills {
+        assignmentSource
+        assignmentType
+        scopePath
+        includeChildren
+        skill {
+          id
+          slug
+          name
+          summary
+          whenToUse
+          status
+          installPolicy
+          tags {
+            id
+            slug
+            label
+            description
+            facet {
+              id
+              slug
+              label
+              description
+            }
+          }
+        }
+        skillVersion {
+          id
+          version
+          title
+          summary
+          status
+        }
+        publishedArtifact {
+          id
+          frontmatterName
+          frontmatterDescription
+          checksum
+          publishedAt
+        }
+      }
     }
   }
 `;
@@ -342,13 +474,31 @@ const readGlobalConfig = async configFile => {
 const writeGlobalConfig = async (configFile, config) => {
   await writeJsonFile(configFile, config);
 };
+const withoutLegacyPublishedSkillPreferences = config => {
+  const {
+    publishedSkillPreferences,
+    ignoredPublishedSkills,
+    ...safeConfig
+  } = config;
+  void publishedSkillPreferences;
+  void ignoredPublishedSkills;
+  return safeConfig;
+};
+const hasLegacyPublishedSkillPreferences = config => {
+  return Object.prototype.hasOwnProperty.call(config, 'publishedSkillPreferences') || Object.prototype.hasOwnProperty.call(config, 'ignoredPublishedSkills');
+};
 const readGlobalAuthState = async configFile => {
   const storedConfig = await readGlobalConfig(configFile);
   const storedAuthState = storedConfig.auth;
   if (storedAuthState === undefined || storedAuthState === null) return null;
-  if (isAuthState(storedAuthState)) return storedAuthState;
+  if (isAuthState(storedAuthState)) {
+    if (hasLegacyPublishedSkillPreferences(storedConfig)) {
+      await writeGlobalConfig(configFile, withoutLegacyPublishedSkillPreferences(storedConfig));
+    }
+    return storedAuthState;
+  }
   await writeGlobalConfig(configFile, {
-    ...storedConfig,
+    ...withoutLegacyPublishedSkillPreferences(storedConfig),
     auth: null
   });
   return null;
@@ -363,17 +513,43 @@ const readLegacyAuthState = async authStateFile => {
 const writeAuthState = async (configFile, authState) => {
   const storedConfig = await readGlobalConfig(configFile);
   await writeGlobalConfig(configFile, {
-    ...storedConfig,
+    ...withoutLegacyPublishedSkillPreferences(storedConfig),
     auth: authState
   });
 };
 const clearAuthState = async configFile => {
   const storedConfig = await readGlobalConfig(configFile);
   await writeGlobalConfig(configFile, {
-    ...storedConfig,
+    ...withoutLegacyPublishedSkillPreferences(storedConfig),
     auth: null
   });
 };
+const toIgnoredSkillSlug = value => {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return null;
+  return normalized;
+};
+const getPublishedSkillIgnoreScopeKey = (resolution, payload) => {
+  const workspaceSlug = payload?.workspace?.slug ?? resolution.fallbackWorkspaceSlug;
+  if (workspaceSlug) return `workspace:${toWorkspaceSlug(workspaceSlug)}`;
+  if (resolution.repositoryUrl) return `repository:${resolution.repositoryUrl}`;
+  return `path:${toWorkspaceSlug(path.basename(resolution.repositoryRoot))}`;
+};
+const toStoredUserKey = authState => {
+  if (authState?.userId) return authState.userId;
+  if (authState?.email) return authState.email.toLowerCase();
+  return 'anonymous';
+};
+const resolvePublishedSkillPreferenceCacheContext = async config => {
+  const authState = await readGlobalAuthState(config.authStatePath);
+  return {
+    userKey: toStoredUserKey(authState),
+    preferenceVersion: publishedSkillPreferenceCacheVersion
+  };
+};
+const getCatalogCacheKey = (workspaceResolution, preferenceContext) => {
+  return JSON.stringify([workspaceResolution.cacheKey, preferenceContext.userKey, preferenceContext.preferenceVersion]);
+};
 const toAuthState = session => ({
   pluginId: PLUGIN_ID,
   sessionToken: session.jwtToken,
@@ -475,11 +651,12 @@ const getPublishedSkillAssignmentCounts = items => items.reduce((counts, item) =
   other: 0
 });
 const getSkillContextKind = item => {
-  if (item.assignmentSource === 'GLOBAL') return 'global';
+  if (item.assignmentSource === 'GLOBAL' || item.assignmentSource === 'USER_GLOBAL') return 'global';
   return 'project';
 };
 const getSkillPolicyLabel = (policy, contextKind) => {
   if (policy === 'GLOBAL_CONTEXT') return 'GLOBAL_CONTEXT · active context only, not project-installable';
+  if (contextKind === 'installable') return 'PROJECT_INSTALLABLE · available to install';
   if (contextKind === 'global') return 'PROJECT_INSTALLABLE · active global assignment';
   return 'PROJECT_INSTALLABLE · active project/workspace assignment';
 };
@@ -514,10 +691,35 @@ export const toPublishedSkillDetail = item => ({
   markdownBody: item.publishedArtifact.markdownBody,
   renderedContent: item.publishedArtifact.renderedContent
 });
+const toInstallableSkillSummary = item => ({
+  skillSlug: item.skill.slug,
+  skillName: item.skill.name,
+  artifactName: item.publishedArtifact.frontmatterName,
+  artifactDescription: item.publishedArtifact.frontmatterDescription,
+  whenToUse: item.skill.whenToUse ?? null,
+  version: item.skillVersion.version,
+  assignmentSource: 'CATALOG',
+  assignmentType: 'PATH',
+  scopePath: '',
+  includeChildren: true,
+  checksum: item.publishedArtifact.checksum,
+  publishedAt: item.publishedArtifact.publishedAt,
+  identifiers: getSkillIdentifiers({
+    ...item,
+    assignmentSource: 'CATALOG',
+    assignmentType: 'PATH',
+    scopePath: '',
+    includeChildren: true
+  }),
+  tags: item.skill.tags.map(toPublishedSkillTagSummary),
+  contextKind: 'installable',
+  installPolicy: item.skill.installPolicy,
+  policyLabel: getSkillPolicyLabel(item.skill.installPolicy, 'installable')
+});
 export const toPublishedSkillCatalog = payload => ({
   pluginId: PLUGIN_ID,
   runtimeMode: 'tool_fetch_only',
-  deliveryModel: 'backend_published_global_project_assignments',
+  deliveryModel: 'backend_published_installed_effective_skills',
   workspace: payload.workspace,
   directoryPath: payload.directoryPath,
   rootSkillSeedPath: ROOT_SKILL_SEED_PATH,
@@ -527,6 +729,36 @@ export const toPublishedSkillCatalog = payload => ({
   facets: getPublishedSkillFacets(payload.skills),
   skills: payload.skills.map(toPublishedSkillSummary)
 });
+const filterIgnoredPublishedSkills = async (config, result) => {
+  const authState = await readGlobalAuthState(config.authStatePath);
+  const userKey = toStoredUserKey(authState);
+  if (!result.fetchResult.ok) {
+    return {
+      ...result,
+      ignoreState: {
+        scopeKey: getPublishedSkillIgnoreScopeKey(result.workspaceResolution),
+        userKey,
+        ignoredSkillSlugs: [],
+        installedGlobalSkillSlugs: [],
+        installedWorkspaceSkillSlugs: []
+      },
+      ignoredSkills: []
+    };
+  }
+  const ignoredSkills = result.fetchResult.payload.userPreferences.ignoredSkills.map(toPublishedSkillSummary);
+  const ignoredSkillSlugs = ignoredSkills.map(skill => skill.skillSlug);
+  return {
+    ...result,
+    ignoreState: {
+      scopeKey: result.fetchResult.payload.userPreferences.scopeKey,
+      userKey: result.fetchResult.payload.userPreferences.userKey || userKey,
+      ignoredSkillSlugs,
+      installedGlobalSkillSlugs: [],
+      installedWorkspaceSkillSlugs: []
+    },
+    ignoredSkills
+  };
+};
 const getWorkspaceUnavailableMessage = payload => {
   if (payload.workspace) return null;
   return 'Workspace-specific skills are unavailable because the workspace was not found; global skills are still loaded.';
@@ -629,6 +861,7 @@ const toWorkspaceResolutionMetadata = resolution => ({
 });
 const formatStatusOutput = async (worktree, config, publishedSkillsResult, loginBootstrapSnapshot) => {
   const authState = await resolveStoredAuthState(worktree, config);
+  const filteredResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
   const base = {
     pluginId: PLUGIN_ID,
     runtimeMode: 'tool_fetch_only',
@@ -657,21 +890,26 @@ const formatStatusOutput = async (worktree, config, publishedSkillsResult, login
       email: loginBootstrapSnapshot.email,
       message: loginBootstrapSnapshot.message
     },
-    status: publishedSkillsResult.fetchResult.status,
-    fetchedAt: publishedSkillsResult.fetchResult.fetchedAt,
-    source: publishedSkillsResult.fetchResult.source,
-    availableTools: AVAILABLE_PUBLISHED_SKILL_TOOLS
+    status: filteredResult.fetchResult.status,
+    fetchedAt: filteredResult.fetchResult.fetchedAt,
+    source: filteredResult.fetchResult.source,
+    availableTools: AVAILABLE_PUBLISHED_SKILL_TOOLS,
+    ignoredPublishedSkills: {
+      scopeKey: filteredResult.ignoreState.scopeKey,
+      userKey: filteredResult.ignoreState.userKey,
+      count: filteredResult.ignoreState.ignoredSkillSlugs.length
+    }
   };
-  if (!publishedSkillsResult.fetchResult.ok) {
+  if (!filteredResult.fetchResult.ok) {
     return JSON.stringify({
       ...base,
-      message: publishedSkillsResult.fetchResult.message
+      message: filteredResult.fetchResult.message
     }, null, 2);
   }
   return JSON.stringify({
     ...base,
-    ...toPublishedSkillCatalog(publishedSkillsResult.fetchResult.payload),
-    message: getWorkspaceUnavailableMessage(publishedSkillsResult.fetchResult.payload)
+    ...toPublishedSkillCatalog(filteredResult.fetchResult.payload),
+    message: getWorkspaceUnavailableMessage(filteredResult.fetchResult.payload)
   }, null, 2);
 };
 export const toPluginAuthStateSummary = authState => {
@@ -703,6 +941,11 @@ export const resolvePluginStatusSnapshot = async ({
     directory
   });
   const fetchResult = await fetchPublishedSkillsCatalog(worktree, config, workspaceResolution, signal);
+  const filteredResult = await filterIgnoredPublishedSkills(config, {
+    directoryPath: workspaceResolution.directoryPath,
+    workspaceResolution,
+    fetchResult
+  });
   const authState = await resolveStoredAuthState(worktree, config);
   return {
     pluginId: PLUGIN_ID,
@@ -715,19 +958,43 @@ export const resolvePluginStatusSnapshot = async ({
     rootSkillSeedPath: config.rootSkillSeedPath,
     authStatePath: config.authStatePath,
     authState: toPluginAuthStateSummary(authState),
-    status: fetchResult.status,
-    authMode: fetchResult.authMode,
-    fetchedAt: fetchResult.fetchedAt,
-    source: fetchResult.source,
+    status: filteredResult.fetchResult.status,
+    authMode: filteredResult.fetchResult.authMode,
+    fetchedAt: filteredResult.fetchResult.fetchedAt,
+    source: filteredResult.fetchResult.source,
     availableTools: AVAILABLE_PUBLISHED_SKILL_TOOLS,
-    message: fetchResult.ok ? getWorkspaceUnavailableMessage(fetchResult.payload) : fetchResult.message,
-    catalog: fetchResult.ok ? toPublishedSkillCatalog(fetchResult.payload) : null
+    message: filteredResult.fetchResult.ok ? getWorkspaceUnavailableMessage(filteredResult.fetchResult.payload) : filteredResult.fetchResult.message,
+    catalog: filteredResult.fetchResult.ok ? toPublishedSkillCatalog(filteredResult.fetchResult.payload) : null,
+    installableCatalog: filteredResult.fetchResult.ok ? {
+      count: filteredResult.fetchResult.payload.catalogSkills.length,
+      skills: filteredResult.fetchResult.payload.catalogSkills.map(toInstallableSkillSummary)
+    } : null,
+    ignoredPublishedSkills: {
+      scopeKey: filteredResult.ignoreState.scopeKey,
+      userKey: filteredResult.ignoreState.userKey,
+      count: filteredResult.ignoreState.ignoredSkillSlugs.length,
+      skills: filteredResult.ignoredSkills
+    }
   };
 };
 const withStatusMessage = (snapshot, message) => ({
   ...snapshot,
   message
 });
+const toAiFacingPluginStatusSnapshot = snapshot => {
+  const {
+    ignoredPublishedSkills,
+    installableCatalog: _installableCatalog,
+    ...safeSnapshot
+  } = snapshot;
+  return {
+    ...safeSnapshot,
+    ignoredPublishedSkills: {
+      scopeKey: ignoredPublishedSkills.scopeKey,
+      count: ignoredPublishedSkills.count
+    }
+  };
+};
 const startStatusPathLoginBootstrap = (worktree, config) => {
   if (statusPathLoginBootstrap.promise) return;
   if (statusPathLoginBootstrap.status === 'failed' && statusPathLoginBootstrap.failedAt && Date.now() - statusPathLoginBootstrap.failedAt < STATUS_PATH_LOGIN_RETRY_COOLDOWN_MS) {
@@ -794,6 +1061,93 @@ export const resolvePluginStatusSnapshotWithAuthBootstrap = async ({
   }
   return withStatusMessage(snapshot, 'Browser login is pending from the TUI/status path.');
 };
+const toBackendPreferenceScope = preferenceScope => {
+  if (preferenceScope === 'global') return 'GLOBAL';
+  return 'WORKSPACE';
+};
+const setPublishedSkillPreference = async ({
+  worktree,
+  directory,
+  config,
+  skillSlug,
+  preferenceScope,
+  installed,
+  ignored
+}) => {
+  const workspaceResolution = await resolveWorkspace({
+    config,
+    directory
+  });
+  const response = await fetchPublishedSkillsGraphQl({
+    worktree,
+    config,
+    query: SET_PUBLISHED_SKILL_PREFERENCE_MUTATION,
+    variables: {
+      input: {
+        ...toDeliveryInput(workspaceResolution),
+        skillSlug,
+        preferenceScope: toBackendPreferenceScope(preferenceScope),
+        installed,
+        ignored
+      }
+    },
+    signal: AbortSignal.timeout(PRESENCE_EVENT_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(response.result.message);
+  }
+  const preferences = response.data.setPublishedSkillPreference;
+  publishedSkillPreferenceCacheVersion += 1;
+  return {
+    scopeKey: preferences.scopeKey,
+    userKey: preferences.userKey,
+    ignoredSkillSlugs: preferences.ignoredSkills.map(item => item.skill.slug),
+    installedGlobalSkillSlugs: [],
+    installedWorkspaceSkillSlugs: []
+  };
+};
+export const setPublishedSkillIgnored = async ({
+  worktree,
+  directory,
+  skillSlug,
+  ignored,
+  preferenceScope
+}) => {
+  const config = await resolveConfig(worktree);
+  const normalizedSkillSlug = toIgnoredSkillSlug(skillSlug);
+  if (!normalizedSkillSlug) {
+    throw new Error('Cannot toggle an empty published skill slug.');
+  }
+  return setPublishedSkillPreference({
+    worktree,
+    directory,
+    config,
+    skillSlug: normalizedSkillSlug,
+    preferenceScope: preferenceScope ?? 'project',
+    ignored
+  });
+};
+export const setPublishedSkillInstalled = async ({
+  worktree,
+  directory,
+  skillSlug,
+  installed,
+  preferenceScope
+}) => {
+  const config = await resolveConfig(worktree);
+  const normalizedSkillSlug = toIgnoredSkillSlug(skillSlug);
+  if (!normalizedSkillSlug) {
+    throw new Error('Cannot toggle an empty published skill slug.');
+  }
+  return setPublishedSkillPreference({
+    worktree,
+    directory,
+    config,
+    skillSlug: normalizedSkillSlug,
+    preferenceScope,
+    installed
+  });
+};
 const toPluginStatusMetadata = snapshot => ({
   backendOrigin: snapshot.backendOrigin,
   graphqlUrl: snapshot.graphqlUrl,
@@ -1503,11 +1857,11 @@ const openBrowser = async url => {
 const normalizeDirectoryArg = (contextDirectory, directory) => {
   return normalizeAbsolutePath(directory ? path.resolve(contextDirectory, directory) : contextDirectory);
 };
-const getDetailCacheKey = (workspaceResolution, skillVersionId) => {
-  return JSON.stringify([workspaceResolution.cacheKey, skillVersionId]);
+const getDetailCacheKey = (catalogCacheKey, skillVersionId) => {
+  return JSON.stringify([catalogCacheKey, skillVersionId]);
 };
-const getDetailInflightKey = (workspaceResolution, skillVersionId, purpose) => {
-  return JSON.stringify([workspaceResolution.cacheKey, skillVersionId, purpose]);
+const getDetailInflightKey = (catalogCacheKey, skillVersionId, purpose) => {
+  return JSON.stringify([catalogCacheKey, skillVersionId, purpose]);
 };
 const OpencodeWizardSkillsPlugin = async input => {
   const {
@@ -1727,7 +2081,8 @@ const OpencodeWizardSkillsPlugin = async input => {
       directory
     });
     const directoryPath = workspaceResolution.directoryPath;
-    const cacheKey = workspaceResolution.cacheKey;
+    const preferenceContext = await resolvePublishedSkillPreferenceCacheContext(config);
+    const cacheKey = getCatalogCacheKey(workspaceResolution, preferenceContext);
     const cached = cache.get(cacheKey);
     if (useCache && cached && cached.expiresAt > Date.now()) {
       return {
@@ -1770,8 +2125,10 @@ const OpencodeWizardSkillsPlugin = async input => {
     purpose
   }) => {
     const directoryPath = workspaceResolution.directoryPath;
-    const cacheKey = getDetailCacheKey(workspaceResolution, item.skillVersion.id);
-    const inflightKey = getDetailInflightKey(workspaceResolution, item.skillVersion.id, purpose);
+    const preferenceContext = await resolvePublishedSkillPreferenceCacheContext(config);
+    const catalogCacheKey = getCatalogCacheKey(workspaceResolution, preferenceContext);
+    const cacheKey = getDetailCacheKey(catalogCacheKey, item.skillVersion.id);
+    const inflightKey = getDetailInflightKey(catalogCacheKey, item.skillVersion.id, purpose);
     const cached = detailCache.get(cacheKey);
     if (purpose === 'SYSTEM_CONTEXT' && useCache && cached && cached.expiresAt > Date.now()) {
       return {
@@ -1911,18 +2268,29 @@ const OpencodeWizardSkillsPlugin = async input => {
         loginBootstrapSnapshot: loginBootstrap.snapshot
       });
     }
-    const selection = selectPublishedSkills(publishedSkillsResult.fetchResult.payload, requestedSkills);
+    const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
+    if (!filteredPublishedSkillsResult.fetchResult.ok) {
+      await emitFetchOutcome('FETCH_FAILED');
+      return toFetchFailureOutput({
+        worktree: input.worktree,
+        config,
+        publishedSkillsResult: filteredPublishedSkillsResult,
+        loginBootstrapSnapshot: loginBootstrap.snapshot
+      });
+    }
+    const selection = selectPublishedSkills(filteredPublishedSkillsResult.fetchResult.payload, requestedSkills);
     const isSingleRequest = requestedSkills.length === 1;
     if (requestedSkills.length === 0) {
-      const catalog = toPublishedSkillCatalog(publishedSkillsResult.fetchResult.payload);
+      const catalog = toPublishedSkillCatalog(filteredPublishedSkillsResult.fetchResult.payload);
       context.metadata({
-        title: `opencode-wizard published skills catalog: ${catalog.publishedSkillCount}`,
+        title: `opencode-wizard published skills catalog: ${catalog.publishedSkillCount} active`,
         metadata: {
-          ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
           status: 'ready',
           publishedSkillCount: catalog.publishedSkillCount.toString(),
           globalAssignmentCount: catalog.assignmentCounts.global.toString(),
-          projectAssignmentCount: catalog.assignmentCounts.project.toString()
+          projectAssignmentCount: catalog.assignmentCounts.project.toString(),
+          ignoredSkillCount: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length.toString()
         }
       });
       await emitFetchOutcome('FETCH_SUCCESS');
@@ -1930,16 +2298,21 @@ const OpencodeWizardSkillsPlugin = async input => {
         output: JSON.stringify({
           ...catalog,
           status: 'ready',
-          requestedDirectoryPath: publishedSkillsResult.directoryPath,
-          workspaceResolution: toWorkspaceResolutionOutput(publishedSkillsResult.workspaceResolution),
-          fetchedAt: publishedSkillsResult.fetchResult.fetchedAt,
-          source: publishedSkillsResult.fetchResult.source,
+          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+          ignoredPublishedSkills: {
+            scopeKey: filteredPublishedSkillsResult.ignoreState.scopeKey,
+            count: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length
+          },
+          fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
+          source: filteredPublishedSkillsResult.fetchResult.source,
           message: 'Catalog discovery only. Provide `skill` or `skills` to fetch markdown bodies/details for selected skills.'
         }, null, 2),
         metadata: {
           status: 'ready',
-          ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
-          publishedSkillCount: catalog.publishedSkillCount.toString()
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          publishedSkillCount: catalog.publishedSkillCount.toString(),
+          ignoredSkillCount: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length.toString()
         }
       };
     }
@@ -1950,19 +2323,23 @@ const OpencodeWizardSkillsPlugin = async input => {
           pluginId: PLUGIN_ID,
           runtimeMode: 'tool_fetch_only',
           status: 'not_found',
-          requestedDirectoryPath: publishedSkillsResult.directoryPath,
-          workspaceResolution: toWorkspaceResolutionOutput(publishedSkillsResult.workspaceResolution),
+          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
           requestedSkill: requestedSkills[0],
-          availableSkills: publishedSkillsResult.fetchResult.payload.skills.map(toPublishedSkillSummary)
+          availableSkills: filteredPublishedSkillsResult.fetchResult.payload.skills.map(toPublishedSkillSummary),
+          ignoredPublishedSkills: {
+            scopeKey: filteredPublishedSkillsResult.ignoreState.scopeKey,
+            count: filteredPublishedSkillsResult.ignoreState.ignoredSkillSlugs.length
+          }
         }, null, 2),
         metadata: {
           status: 'not_found',
-          ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution)
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution)
         }
       };
     }
     let skillDetailResults = await Promise.all(selection.selectedItems.map(item => loadPublishedSkillDetail({
-      workspaceResolution: publishedSkillsResult.workspaceResolution,
+      workspaceResolution: filteredPublishedSkillsResult.workspaceResolution,
       item,
       signal: context.abort,
       useCache: !args.refresh,
@@ -1974,7 +2351,7 @@ const OpencodeWizardSkillsPlugin = async input => {
           await schedulePresenceStart(authState);
         });
         skillDetailResults = await Promise.all(selection.selectedItems.map(item => loadPublishedSkillDetail({
-          workspaceResolution: publishedSkillsResult.workspaceResolution,
+          workspaceResolution: filteredPublishedSkillsResult.workspaceResolution,
           item,
           signal: context.abort,
           useCache: false,
@@ -2000,7 +2377,7 @@ const OpencodeWizardSkillsPlugin = async input => {
       context.metadata({
         title: `opencode-wizard published skill: ${detail.artifactName || detail.skillName}`,
         metadata: {
-          ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
           skillSlug: detail.skillSlug,
           version: detail.version
         }
@@ -2010,16 +2387,16 @@ const OpencodeWizardSkillsPlugin = async input => {
         output: JSON.stringify({
           pluginId: PLUGIN_ID,
           runtimeMode: 'tool_fetch_only',
-          requestedDirectoryPath: publishedSkillsResult.directoryPath,
-          workspaceResolution: toWorkspaceResolutionOutput(publishedSkillsResult.workspaceResolution),
-          workspace: publishedSkillsResult.fetchResult.payload.workspace,
-          fetchedAt: publishedSkillsResult.fetchResult.fetchedAt,
-          source: publishedSkillsResult.fetchResult.source,
+          requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+          workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+          workspace: filteredPublishedSkillsResult.fetchResult.payload.workspace,
+          fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
+          source: filteredPublishedSkillsResult.fetchResult.source,
           skill: detail
         }, null, 2),
         metadata: {
           status: 'ready',
-          ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
+          ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
           skillSlug: detail.skillSlug
         }
       };
@@ -2027,7 +2404,7 @@ const OpencodeWizardSkillsPlugin = async input => {
     context.metadata({
       title: `opencode-wizard published skills fetch: ${skillDetails.length}`,
       metadata: {
-        ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
+        ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
         requestedCount: requestedSkills.length.toString(),
         matchedCount: skillDetails.length.toString()
       }
@@ -2037,18 +2414,18 @@ const OpencodeWizardSkillsPlugin = async input => {
       output: JSON.stringify({
         pluginId: PLUGIN_ID,
         runtimeMode: 'tool_fetch_only',
-        requestedDirectoryPath: publishedSkillsResult.directoryPath,
-        workspaceResolution: toWorkspaceResolutionOutput(publishedSkillsResult.workspaceResolution),
-        workspace: publishedSkillsResult.fetchResult.payload.workspace,
-        fetchedAt: publishedSkillsResult.fetchResult.fetchedAt,
-        source: publishedSkillsResult.fetchResult.source,
+        requestedDirectoryPath: filteredPublishedSkillsResult.directoryPath,
+        workspaceResolution: toWorkspaceResolutionOutput(filteredPublishedSkillsResult.workspaceResolution),
+        workspace: filteredPublishedSkillsResult.fetchResult.payload.workspace,
+        fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
+        source: filteredPublishedSkillsResult.fetchResult.source,
         requestedSkills,
         missingSkills: selection.missingIdentifiers,
         skills: skillDetails
       }, null, 2),
       metadata: {
         status: selection.missingIdentifiers.length > 0 ? 'partial' : 'ready',
-        ...toWorkspaceResolutionMetadata(publishedSkillsResult.workspaceResolution),
+        ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
         matchedCount: skillDetails.length.toString()
       }
     };
@@ -2083,7 +2460,7 @@ const OpencodeWizardSkillsPlugin = async input => {
       metadata
     });
     return {
-      output: JSON.stringify(snapshot, null, 2),
+      output: JSON.stringify(toAiFacingPluginStatusSnapshot(snapshot), null, 2),
       metadata
     };
   };
@@ -2143,11 +2520,12 @@ const OpencodeWizardSkillsPlugin = async input => {
           return;
         }
       }
+      const filteredPublishedSkillsResult = await filterIgnoredPublishedSkills(config, publishedSkillsResult);
       const details = await loadSystemNoteDetails({
-        publishedSkillsResult,
+        publishedSkillsResult: filteredPublishedSkillsResult,
         signal: AbortSignal.timeout(5_000)
       });
-      const systemNote = buildSystemNote(publishedSkillsResult, config, details);
+      const systemNote = buildSystemNote(filteredPublishedSkillsResult, config, details);
       if (!systemNote) return;
       output.system.push(systemNote);
     }