@aexol/opencode-wizard 0.1.12 → 0.1.15

package/dist/server.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import http from 'node:http';
+import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { execFile } from 'node:child_process';
@@ -11,7 +12,8 @@ const PACKAGE_ROOT_PATH = path.resolve(path.dirname(MODULE_FILE_PATH), '..');
 export const PLUGIN_ID = 'opencode-wizard';
 const CACHE_TTL_MS = 30_000;
 const ROOT_SKILL_SEED_PATH = '.opencode/skills';
-const AUTH_STATE_PATH = 'plugin/opencode-wizard/.generated/auth-state.json';
+const GLOBAL_CONFIG_PATH = path.join(os.homedir(), '.config', 'opencode', 'opencode-wizard.json');
+const LEGACY_AUTH_STATE_PATH = 'plugin/opencode-wizard/.generated/auth-state.json';
 const PUBLISHED_BACKEND_ORIGIN = 'https://opencode-wizard.aexol.work';
 const OIDC_ISSUER = 'https://login.microsoftonline.com/86f4caf4-0d6f-4682-9a06-ea57f3e4e76c/v2.0';
 const OIDC_CLIENT_ID = 'da963901-2375-442b-9e99-14e59f43eda2';
@@ -52,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',
@@ -112,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
+        }
+      }
     }
   }
 `;
@@ -208,7 +342,7 @@ export const resolveConfig = async worktree => {
     actionsUrl: `${backendOrigin}/api/opencode-plugin/actions`,
     fallbackWorkspaceSlug: resolveFallbackWorkspaceSlug(worktree),
     rootSkillSeedPath: ROOT_SKILL_SEED_PATH,
-    authStatePath: AUTH_STATE_PATH
+    authStatePath: GLOBAL_CONFIG_PATH
   };
 };
 const normalizeAbsolutePath = value => path.resolve(value);
@@ -332,15 +466,89 @@ const isAuthState = value => {
   if (!isRecord(value)) return false;
   return value.pluginId === PLUGIN_ID && typeof value.sessionToken === 'string' && isValidIsoDateString(value.expiresAt) && isValidIsoDateString(value.authenticatedAt) && typeof value.userId === 'string' && typeof value.email === 'string';
 };
-const readAuthState = async authStateFile => {
+const readGlobalConfig = async configFile => {
+  const storedConfig = await readJsonFile(configFile);
+  if (isRecord(storedConfig)) return storedConfig;
+  return {};
+};
+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)) {
+    if (hasLegacyPublishedSkillPreferences(storedConfig)) {
+      await writeGlobalConfig(configFile, withoutLegacyPublishedSkillPreferences(storedConfig));
+    }
+    return storedAuthState;
+  }
+  await writeGlobalConfig(configFile, {
+    ...withoutLegacyPublishedSkillPreferences(storedConfig),
+    auth: null
+  });
+  return null;
+};
+const readLegacyAuthState = async authStateFile => {
   const storedAuthState = await readJsonFile(authStateFile);
   if (storedAuthState === null) return null;
   if (isAuthState(storedAuthState)) return storedAuthState;
   await deleteFileIfExists(authStateFile);
   return null;
 };
-const writeAuthState = async (authStateFile, authState) => {
-  await writeJsonFile(authStateFile, authState);
+const writeAuthState = async (configFile, authState) => {
+  const storedConfig = await readGlobalConfig(configFile);
+  await writeGlobalConfig(configFile, {
+    ...withoutLegacyPublishedSkillPreferences(storedConfig),
+    auth: authState
+  });
+};
+const clearAuthState = async configFile => {
+  const storedConfig = await readGlobalConfig(configFile);
+  await writeGlobalConfig(configFile, {
+    ...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,
@@ -351,16 +559,24 @@ const toAuthState = session => ({
   email: session.user.email
 });
 const resolveStoredAuthState = async (worktree, config) => {
-  const authStateFile = path.resolve(worktree, config.authStatePath);
-  const authState = await readAuthState(authStateFile);
-  if (!authState) {
+  const authState = await readGlobalAuthState(config.authStatePath);
+  if (authState && Date.parse(authState.expiresAt) > Date.now()) {
+    return authState;
+  }
+  if (authState) {
+    await clearAuthState(config.authStatePath);
     return null;
   }
-  if (Date.parse(authState.expiresAt) > Date.now()) {
-    return authState;
+  const legacyAuthStateFile = path.resolve(worktree, LEGACY_AUTH_STATE_PATH);
+  const legacyAuthState = await readLegacyAuthState(legacyAuthStateFile);
+  if (!legacyAuthState) return null;
+  if (Date.parse(legacyAuthState.expiresAt) <= Date.now()) {
+    await deleteFileIfExists(legacyAuthStateFile);
+    return null;
   }
-  await deleteFileIfExists(authStateFile);
-  return null;
+  await writeAuthState(config.authStatePath, legacyAuthState);
+  await deleteFileIfExists(legacyAuthStateFile);
+  return legacyAuthState;
 };
 export const buildSkillMarkdown = item => {
   const artifactBody = item.publishedArtifact.markdownBody.trim();
@@ -435,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';
 };
@@ -474,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,
@@ -487,6 +729,40 @@ 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.';
+};
 const normalizeSkillIdentifier = value => value.trim().toLowerCase();
 const parseSkillIdentifiers = value => {
   const seen = new Set();
@@ -568,7 +844,7 @@ const buildSystemNote = (result, config, details) => {
   const projectSkills = catalog.skills.filter(skill => skill.contextKind === 'project').slice(0, 5).map(buildSkillCatalogLine);
   const detailLines = details.slice(0, SYSTEM_NOTE_DETAIL_LIMIT).map(buildSkillDetailSnippetLine);
   const detailBlock = detailLines.length > 0 ? ` Loaded body snippets (capped):\n${truncateText(detailLines.join('\n'), SYSTEM_NOTE_DETAIL_CHAR_LIMIT)}` : '';
-  return [`opencode-wizard published skills are available from backend runtime delivery for workspace ${result.fetchResult.payload.workspace.slug}.`, `Current directory: ${result.directoryPath}.`, `Published skills for this scope: ${renderedSkillNames}${renderedCountSuffix}; counts: ${catalog.assignmentCounts.global} global, ${catalog.assignmentCounts.project} project, ${catalog.assignmentCounts.other} other.`, 'Catalog lines use short whenToUse guidance when available; fetch the full skill only when that guidance matches the task.', 'GLOBAL_CONTEXT skills are active context skills and are not project-installable; PROJECT_INSTALLABLE skills can be assigned globally or to project/workspace scopes; assignment rows decide which skills are active here.', globalSkills.length > 0 ? `Global context skills:\n${globalSkills.join('\n')}` : 'Global context skills: none.', projectSkills.length > 0 ? `Project-scoped active skills:\n${projectSkills.join('\n')}` : 'Project-scoped active skills: none.', detailBlock, 'Use opencode_wizard_published_skills_fetch for one or multiple skills.', `Root source seed path remains non-runtime input only: ${config.rootSkillSeedPath}/**.`].filter(line => line.length > 0).join(' ');
+  return [result.fetchResult.payload.workspace ? `opencode-wizard published skills are available from backend runtime delivery for workspace ${result.fetchResult.payload.workspace.slug}.` : 'opencode-wizard published global skills are available from backend runtime delivery; workspace-specific skills are unavailable because the workspace was not found.', `Current directory: ${result.directoryPath}.`, `Published skills for this scope: ${renderedSkillNames}${renderedCountSuffix}; counts: ${catalog.assignmentCounts.global} global, ${catalog.assignmentCounts.project} project, ${catalog.assignmentCounts.other} other.`, 'Catalog lines use short whenToUse guidance when available; fetch the full skill only when that guidance matches the task.', 'GLOBAL_CONTEXT skills are active context skills and are not project-installable; PROJECT_INSTALLABLE skills can be assigned globally or to project/workspace scopes; assignment rows decide which skills are active here.', globalSkills.length > 0 ? `Global context skills:\n${globalSkills.join('\n')}` : 'Global context skills: none.', projectSkills.length > 0 ? `Project-scoped active skills:\n${projectSkills.join('\n')}` : 'Project-scoped active skills: none.', detailBlock, 'Use opencode_wizard_published_skills_fetch for one or multiple skills.', `Root source seed path remains non-runtime input only: ${config.rootSkillSeedPath}/**.`].filter(line => line.length > 0).join(' ');
 };
 const toWorkspaceResolutionOutput = resolution => ({
   requestedDirectory: resolution.requestedDirectory,
@@ -585,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',
@@ -613,20 +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)
+    ...toPublishedSkillCatalog(filteredResult.fetchResult.payload),
+    message: getWorkspaceUnavailableMessage(filteredResult.fetchResult.payload)
   }, null, 2);
 };
 export const toPluginAuthStateSummary = authState => {
@@ -658,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,
@@ -670,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 ? null : 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) {
@@ -714,7 +1026,7 @@ const startStatusPathLoginBootstrap = (worktree, config) => {
         signal: loginSignal
       });
       const authState = toAuthState(pluginSession);
-      await writeAuthState(path.resolve(worktree, config.authStatePath), authState);
+      await writeAuthState(config.authStatePath, authState);
       statusPathLoginBootstrap.status = 'authenticated';
       statusPathLoginBootstrap.message = `Browser login completed successfully for ${authState.email}.`;
       return authState;
@@ -749,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,
@@ -791,12 +1190,204 @@ const fetchOidcDiscoveryDocument = async signal => {
   }
   return await response.json();
 };
+const isCallbackPortInUseError = error => {
+  if (!error || typeof error !== 'object') return false;
+  if (!('code' in error)) return false;
+  return error.code === 'EADDRINUSE';
+};
+const toCallbackServerStartError = error => {
+  if (!isCallbackPortInUseError(error)) {
+    return error instanceof Error ? error : new Error('Failed to start local OAuth callback server.');
+  }
+  return new Error('OAuth login cannot start because localhost:24953 is already in use. Another OpenCode login is likely in progress; finish it or close the other instance, then retry.');
+};
+const escapeHtml = value => {
+  return value.replace(/[&<>'"]/g, character => {
+    const replacements = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      "'": '&#39;',
+      '"': '&quot;'
+    };
+    return replacements[character] ?? character;
+  });
+};
 const sendHtmlResponse = (response, statusCode, title, message) => {
+  const escapedTitle = escapeHtml(title);
+  const escapedMessage = escapeHtml(message);
+  const isSuccess = statusCode >= 200 && statusCode < 300;
+  const pageState = isSuccess ? 'success' : statusCode === 404 ? 'not-found' : 'error';
+  const cardTitle = isSuccess ? 'Authorization successful' : statusCode === 404 ? 'Callback not found' : 'Authorization failed';
+  const escapedCardTitle = escapeHtml(cardTitle);
+  const eyebrow = isSuccess ? 'Authorization complete' : statusCode === 404 ? 'Callback route not found' : 'Authorization needs attention';
+  const actionText = isSuccess ? 'This window will close automatically in a moment. You can also close it now and return to OpenCode.' : 'You can close this window and return to OpenCode to try again.';
+  const autoCloseScript = isSuccess ? `<script>
+      window.setTimeout(() => window.close(), 2000);
+    </script>` : '';
+  const stateIcon = isSuccess ? '<path d="M7 12.5l3.1 3.1L17.5 8" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"/>' : statusCode === 404 ? '<path d="M10.5 17a6.5 6.5 0 1 0 0-13 6.5 6.5 0 0 0 0 13Z" stroke="currentColor" stroke-width="2.2"/><path d="m15.5 15.5 4 4" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"/>' : '<path d="M12 7v6" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"/><path d="M12 17.2v.1" stroke="currentColor" stroke-width="3.2" stroke-linecap="round"/>';
   response.writeHead(statusCode, {
     'content-type': 'text/html; charset=utf-8',
     'cache-control': 'no-store'
   });
-  response.end(`<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body><h1>${title}</h1><p>${message}</p><p>You can close this window and return to OpenCode.</p></body></html>`);
+  response.end(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="color-scheme" content="light dark">
+    <title>${escapedTitle}</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+        --page-bg: #f2efe7;
+        --page-ink: #211d18;
+        --muted: #6c6258;
+        --panel: rgba(255, 252, 245, 0.82);
+        --panel-border: rgba(78, 66, 52, 0.16);
+        --success: #167848;
+        --error: #ba3329;
+        --not-found: #986614;
+        --glow: rgba(22, 120, 72, 0.18);
+      }
+
+      @media (prefers-color-scheme: dark) {
+        :root {
+          --page-bg: #12100d;
+          --page-ink: #f7efe2;
+          --muted: #b8aa98;
+          --panel: rgba(30, 26, 22, 0.78);
+          --panel-border: rgba(255, 244, 224, 0.14);
+          --success: #71e0a6;
+          --error: #ff897e;
+          --not-found: #f7c96f;
+          --glow: rgba(113, 224, 166, 0.2);
+        }
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        min-height: 100vh;
+        margin: 0;
+        display: grid;
+        place-items: center;
+        padding: 24px;
+        overflow: hidden;
+        background:
+          radial-gradient(circle at 18% 18%, var(--glow), transparent 34rem),
+          radial-gradient(circle at 82% 12%, rgba(209, 142, 72, 0.18), transparent 30rem),
+          linear-gradient(135deg, var(--page-bg), color-mix(in srgb, var(--page-bg) 76%, #000 24%));
+        color: var(--page-ink);
+        font-family: ui-rounded, "SF Pro Rounded", "Segoe UI", system-ui, sans-serif;
+      }
+
+      body::before {
+        content: "";
+        position: fixed;
+        inset: -20%;
+        pointer-events: none;
+        background-image:
+          linear-gradient(rgba(128, 104, 74, 0.08) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(128, 104, 74, 0.08) 1px, transparent 1px);
+        background-size: 42px 42px;
+        mask-image: radial-gradient(circle at center, black, transparent 68%);
+      }
+
+      main {
+        position: relative;
+        width: min(100%, 560px);
+        padding: clamp(28px, 7vw, 56px);
+        border: 1px solid var(--panel-border);
+        border-radius: 32px;
+        background: var(--panel);
+        box-shadow: 0 24px 90px rgba(0, 0, 0, 0.24);
+        text-align: center;
+        backdrop-filter: blur(18px) saturate(1.2);
+      }
+
+      .mark {
+        width: 72px;
+        height: 72px;
+        margin: 0 auto 24px;
+        display: grid;
+        place-items: center;
+        border-radius: 24px;
+        color: var(--state-color);
+        background: color-mix(in srgb, var(--state-color) 16%, transparent);
+        box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--state-color) 28%, transparent);
+      }
+
+      [data-state="success"] { --state-color: var(--success); }
+      [data-state="error"] { --state-color: var(--error); }
+      [data-state="not-found"] { --state-color: var(--not-found); }
+
+      .eyebrow {
+        margin: 0 0 10px;
+        color: var(--state-color);
+        font-size: 0.78rem;
+        font-weight: 800;
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+      }
+
+      h1 {
+        margin: 0;
+        font-size: clamp(2rem, 7vw, 3.35rem);
+        line-height: 0.95;
+        letter-spacing: -0.06em;
+      }
+
+      .message {
+        margin: 22px auto 0;
+        max-width: 38rem;
+        color: var(--muted);
+        font-size: clamp(1rem, 2.5vw, 1.1rem);
+        line-height: 1.65;
+      }
+
+      .next-step {
+        margin: 26px 0 0;
+        padding: 14px 18px;
+        border-radius: 999px;
+        background: color-mix(in srgb, var(--state-color) 12%, transparent);
+        color: var(--page-ink);
+        font-size: 0.94rem;
+        line-height: 1.5;
+      }
+
+      @media (max-width: 520px) {
+        body {
+          padding: 16px;
+        }
+
+        main {
+          border-radius: 24px;
+        }
+
+        .next-step {
+          border-radius: 18px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main data-state="${pageState}" aria-labelledby="callback-title">
+      <div class="mark" aria-hidden="true">
+        <svg width="34" height="34" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+          ${stateIcon}
+        </svg>
+      </div>
+      <p class="eyebrow">${eyebrow}</p>
+      <h1 id="callback-title">${escapedCardTitle}</h1>
+      <p class="message">${escapedMessage}</p>
+      <p class="next-step">${actionText}</p>
+    </main>
+    ${autoCloseScript}
+  </body>
+</html>`);
 };
 const startLocalCallbackServer = async ({
   expectedState,
@@ -861,9 +1452,6 @@ const startLocalCallbackServer = async ({
       state
     });
   });
-  server.on('error', error => {
-    fail(error instanceof Error ? error : new Error('Failed to start local OAuth callback server.'));
-  });
   const close = async () => {
     await new Promise((resolve, reject) => {
       server.close(error => {
@@ -876,8 +1464,17 @@ const startLocalCallbackServer = async ({
     });
   };
   await new Promise((resolve, reject) => {
-    server.listen(24953, 'localhost', () => resolve());
-    server.once('error', reject);
+    const rejectStart = error => {
+      reject(toCallbackServerStartError(error));
+    };
+    server.once('error', rejectStart);
+    server.listen(24953, 'localhost', () => {
+      server.off('error', rejectStart);
+      server.on('error', error => {
+        fail(error instanceof Error ? error : new Error('Local OAuth callback server failed.'));
+      });
+      resolve();
+    });
   });
   signal.addEventListener('abort', () => {
     fail(signal.reason instanceof Error ? signal.reason : new Error('OAuth login aborted.'));
@@ -941,7 +1538,7 @@ const fetchPublishedSkillsGraphQl = async ({
     };
   }
   if (response.status === 401 || response.status === 403) {
-    await deleteFileIfExists(path.resolve(worktree, config.authStatePath));
+    await clearAuthState(config.authStatePath);
     onAuthStateChanged?.();
     return {
       ok: false,
@@ -987,7 +1584,7 @@ const fetchPublishedSkillsGraphQl = async ({
   if (body.errors?.length) {
     const message = body.errors.map(error => error.message).join('; ');
     if (body.errors.some(error => isUnauthorizedGraphQlMessage(error.message))) {
-      await deleteFileIfExists(path.resolve(worktree, config.authStatePath));
+      await clearAuthState(config.authStatePath);
       onAuthStateChanged?.();
       return {
         ok: false,
@@ -1260,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 {
@@ -1276,7 +1873,6 @@ const OpencodeWizardSkillsPlugin = async input => {
   const catalogInflight = new Map();
   const detailCache = new Map();
   const detailInflight = new Map();
-  const authStateFile = path.resolve(input.worktree, config.authStatePath);
   const initialAuthState = await resolveStoredAuthState(input.worktree, config);
   const loginBootstrap = {
     promise: null,
@@ -1375,7 +1971,7 @@ const OpencodeWizardSkillsPlugin = async input => {
   };
   const persistAuthState = async session => {
     const authState = toAuthState(session);
-    await writeAuthState(authStateFile, authState);
+    await writeAuthState(config.authStatePath, authState);
     clearPublishedSkillState();
     return authState;
   };
@@ -1396,19 +1992,20 @@ const OpencodeWizardSkillsPlugin = async input => {
     };
     const loginPromise = (async () => {
       const loginSignal = AbortSignal.timeout(LOGIN_TIMEOUT_MS);
-      const loginStart = await startLoginFlow(loginSignal);
-      const browserOpenError = await openBrowser(loginStart.browserUrl);
-      loginBootstrap.snapshot = {
-        status: 'pending',
-        trigger,
-        startedAt,
-        expiresAt: loginStart.expiresAt,
-        browserUrl: loginStart.browserUrl,
-        browserOpenError,
-        email: null,
-        message: browserOpenError ? `Automatic browser open failed. Open ${loginStart.browserUrl} manually.` : `Browser login started for published skill ${trigger}.`
-      };
+      let loginStart = null;
       try {
+        loginStart = await startLoginFlow(loginSignal);
+        const browserOpenError = await openBrowser(loginStart.browserUrl);
+        loginBootstrap.snapshot = {
+          status: 'pending',
+          trigger,
+          startedAt,
+          expiresAt: loginStart.expiresAt,
+          browserUrl: loginStart.browserUrl,
+          browserOpenError,
+          email: null,
+          message: browserOpenError ? `Automatic browser open failed. Open ${loginStart.browserUrl} manually.` : `Browser login started for published skill ${trigger}.`
+        };
         const callbackPayload = await loginStart.callbackPromise;
         if (callbackPayload.status === 'error') {
           throw new Error(callbackPayload.message);
@@ -1467,7 +2064,7 @@ const OpencodeWizardSkillsPlugin = async input => {
         };
         throw error;
       } finally {
-        await loginStart.closeCallbackServer().catch(() => undefined);
+        await loginStart?.closeCallbackServer().catch(() => undefined);
         loginBootstrap.promise = null;
       }
     })();
@@ -1484,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 {
@@ -1527,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 {
@@ -1668,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');
@@ -1687,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()
         }
       };
     }
@@ -1707,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,
@@ -1731,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,
@@ -1757,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
         }
@@ -1767,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
         }
       };
@@ -1784,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()
       }
@@ -1794,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()
       }
     };
@@ -1840,7 +2460,7 @@ const OpencodeWizardSkillsPlugin = async input => {
       metadata
     });
     return {
-      output: JSON.stringify(snapshot, null, 2),
+      output: JSON.stringify(toAiFacingPluginStatusSnapshot(snapshot), null, 2),
       metadata
     };
   };
@@ -1900,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);
     }