ccski 2.0.0 → 2.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 jixoai-labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,8 @@
 # ccski – Claude Code Skills Manager
 
-ccski is a CLI + MCP server to discover, install, enable/disable, and serve Claude Code-compatible skills. This README covers install and usage. For architecture and UX philosophy, see `SPEC.md`.
+ccski is a CLI + MCP server to discover, install, enable/disable, and serve Claude/Codex-compatible skills. This README covers install and usage. For architecture and UX philosophy, see `SPEC.md`.
+
+Documentation site: https://jixoai-labs.github.io/ccski/
 
 ## Install
 
@@ -75,8 +77,14 @@ ccski disable --all
 
 ## More
 
+- Programmatic API is available from the package export; see the docs site for API usage examples.
 - Claude users: prefer `ccski mcp --exclude=claude` to avoid echoing built-in Claude skills.
 - Codex users: prefer `ccski mcp --exclude=codex` when avoid echoing built-in Codex skills.
 - All commands support `--json` for scripting.
 - Use `--no-color` to disable colors or `--color` to force them.
 - Read `SPEC.md` for deep technical details and design philosophy.
+
+## Acknowledgements
+
+- [openskills](https://github.com/numman-ali/openskills) — established the SKILL.md authoring pattern; ccski aligns with that spec.
+- [universal-skills](https://github.com/klaudworks/universal-skills) — MCP-first skill set; ccski focuses on management, not bundling content.

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { n as __require, r as __toESM, t as __commonJS } from "./chunk-B7onSSqq.mjs";
-import { A as arrayType, B as recordType, C as warn, E as validateSkillFile, F as intersectionType, H as unionType, I as literalType, L as numberType, M as custom, N as discriminatedUnionType, P as enumType, R as objectType, S as tone, T as parseSkillFile, U as unknownType, V as stringType, W as AmbiguousSkillNameError, _ as highlight, a as containsCaseInsensitive, b as setColorEnabled, d as colors$1, f as dim, g as heading, h as formatBytes, i as skillAliases, j as booleanType, m as error, n as formatSkillId, o as rankStrings, p as duplicateBadge, q as SkillNotFoundError, r as formatSkillLabel, t as SkillRegistry, v as info, w as wrap, x as success, y as renderList, z as optionalType } from "./registry-Do2Htns7.mjs";
+import { B as optionalType, C as warn, E as validateSkillFile, F as enumType, G as AmbiguousSkillNameError, H as stringType, I as intersectionType, J as SkillNotFoundError, L as literalType, M as booleanType, N as custom, P as discriminatedUnionType, R as numberType, S as tone, T as parseSkillFile, U as unionType, V as recordType, W as unknownType, _ as highlight, a as containsCaseInsensitive, b as setColorEnabled, d as colors$1, f as dim, g as heading, h as formatBytes, i as skillAliases, j as arrayType, m as error, n as formatSkillId, o as rankStrings, p as duplicateBadge, r as formatSkillLabel, t as SkillRegistry, v as info, w as wrap, x as success, y as renderList, z as objectType } from "./registry-DNMfmLqa.mjs";
 import { _ as isSpaceKey, a as useRef, c as esm_default$1, d as useState, f as withPointer, g as isNumberKey, h as isEnterKey, i as useKeypress, l as require_yoctocolors_cjs, m as isDownKey, n as breakLines, o as usePrefix, p as ValidationError, r as readlineWidth, s as makeTheme, t as createPrompt, u as useEffect, y as isUpKey } from "./create-prompt-CkW5qmPT.mjs";
 import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "node:fs";
 import { readFileSync as readFileSync$1, readdirSync as readdirSync$1, statSync as statSync$1, writeFile } from "fs";

package/dist/index.d.mts

@@ -62,13 +62,14 @@ interface PluginEntry {
   installPath: string;
   gitCommitSha: string;
   isLocal: boolean;
+  scope?: string;
 }
 /**
  * Installed plugins JSON structure
  */
 interface InstalledPlugins {
   version: number;
-  plugins: Record<string, PluginEntry>;
+  plugins: Record<string, PluginEntry | PluginEntry[]>;
 }
 //#endregion
 //#region src/types/errors.d.ts
@@ -135,75 +136,134 @@ declare const PluginEntrySchema: z.ZodObject<{
   installPath: z.ZodString;
   gitCommitSha: z.ZodString;
   isLocal: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-  version: string;
-  installedAt: string;
-  lastUpdated: string;
-  installPath: string;
-  gitCommitSha: string;
-  isLocal: boolean;
-}, {
-  version: string;
-  installedAt: string;
-  lastUpdated: string;
-  installPath: string;
-  gitCommitSha: string;
-  isLocal: boolean;
-}>;
+  scope: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+  version: z.ZodString;
+  installedAt: z.ZodString;
+  lastUpdated: z.ZodString;
+  installPath: z.ZodString;
+  gitCommitSha: z.ZodString;
+  isLocal: z.ZodBoolean;
+  scope: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+  version: z.ZodString;
+  installedAt: z.ZodString;
+  lastUpdated: z.ZodString;
+  installPath: z.ZodString;
+  gitCommitSha: z.ZodString;
+  isLocal: z.ZodBoolean;
+  scope: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
 /**
  * Schema for installed_plugins.json
  */
 declare const InstalledPluginsSchema: z.ZodObject<{
   version: z.ZodNumber;
-  plugins: z.ZodRecord<z.ZodString, z.ZodObject<{
+  plugins: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
     version: z.ZodString;
     installedAt: z.ZodString;
     lastUpdated: z.ZodString;
     installPath: z.ZodString;
     gitCommitSha: z.ZodString;
     isLocal: z.ZodBoolean;
-  }, "strip", z.ZodTypeAny, {
-    version: string;
-    installedAt: string;
-    lastUpdated: string;
-    installPath: string;
-    gitCommitSha: string;
-    isLocal: boolean;
-  }, {
-    version: string;
-    installedAt: string;
-    lastUpdated: string;
-    installPath: string;
-    gitCommitSha: string;
-    isLocal: boolean;
-  }>>;
+    scope: z.ZodOptional<z.ZodString>;
+  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodObject<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough">>, "many">]>>;
 }, "strip", z.ZodTypeAny, {
   version: number;
-  plugins: Record<string, {
-    version: string;
-    installedAt: string;
-    lastUpdated: string;
-    installPath: string;
-    gitCommitSha: string;
-    isLocal: boolean;
-  }>;
+  plugins: Record<string, z.objectOutputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough"> | z.objectOutputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough">[]>;
 }, {
   version: number;
-  plugins: Record<string, {
-    version: string;
-    installedAt: string;
-    lastUpdated: string;
-    installPath: string;
-    gitCommitSha: string;
-    isLocal: boolean;
-  }>;
+  plugins: Record<string, z.objectInputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+    version: z.ZodString;
+    installedAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    installPath: z.ZodString;
+    gitCommitSha: z.ZodString;
+    isLocal: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.ZodTypeAny, "passthrough">[]>;
 }>;
+/**
+ * Schema for Claude settings.json (subset we care about)
+ */
+declare const ClaudeSettingsSchema: z.ZodObject<{
+  enabledPlugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+  enabledPlugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+  enabledPlugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.ZodTypeAny, "passthrough">>;
 /**
  * Infer TypeScript types from Zod schemas
  */
 type SkillFrontmatterType = z.infer<typeof SkillFrontmatterSchema>;
 type PluginEntryType = z.infer<typeof PluginEntrySchema>;
 type InstalledPluginsType = z.infer<typeof InstalledPluginsSchema>;
+type ClaudeSettingsType = z.infer<typeof ClaudeSettingsSchema>;
 //#endregion
 //#region src/core/parser.d.ts
 /**
@@ -299,6 +359,7 @@ declare function loadSkill(metadata: SkillMetadata): Skill;
 interface PluginDiscoveryOptions {
   pluginsFile?: string;
   pluginsRoot?: string;
+  settingsFile?: string;
   userDir?: string;
 }
 //#endregion
@@ -351,5 +412,5 @@ declare class SkillRegistry {
   };
 }
 //#endregion
-export { AmbiguousSkillNameError, CcskiError, DiscoveryDiagnostics, DiscoveryOptions, DiscoveryResult, InstalledPlugins, InstalledPluginsSchema, InstalledPluginsType, ParseError, ParseResult, PluginEntry, PluginEntrySchema, PluginEntryType, Skill, SkillFrontmatter, SkillFrontmatterSchema, SkillFrontmatterType, SkillLocation, SkillMetadata, SkillNotFoundError, SkillProvider, SkillRegistry, SkillRegistryOptions, ValidationError, discoverSkills, getDefaultSkillDirectories, loadSkill, parseSkillFile, scanSkillDirectory, validateSkillFile };
+export { AmbiguousSkillNameError, CcskiError, ClaudeSettingsSchema, ClaudeSettingsType, DiscoveryDiagnostics, DiscoveryOptions, DiscoveryResult, InstalledPlugins, InstalledPluginsSchema, InstalledPluginsType, ParseError, ParseResult, PluginEntry, PluginEntrySchema, PluginEntryType, Skill, SkillFrontmatter, SkillFrontmatterSchema, SkillFrontmatterType, SkillLocation, SkillMetadata, SkillNotFoundError, SkillProvider, SkillRegistry, SkillRegistryOptions, ValidationError, discoverSkills, getDefaultSkillDirectories, loadSkill, parseSkillFile, scanSkillDirectory, validateSkillFile };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/skill.ts","../src/types/errors.ts","../src/types/schemas.ts","../src/core/parser.ts","../src/core/discovery.ts","../src/core/plugins.ts","../src/core/registry.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/skill.ts","../src/types/errors.ts","../src/types/schemas.ts","../src/core/parser.ts","../src/core/discovery.ts","../src/core/plugins.ts","../src/core/registry.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { D as InstalledPluginsSchema, E as validateSkillFile, G as CcskiError, J as ValidationError, K as ParseError, O as PluginEntrySchema, T as parseSkillFile, W as AmbiguousSkillNameError, c as getDefaultSkillDirectories, k as SkillFrontmatterSchema, l as loadSkill, q as SkillNotFoundError, s as discoverSkills, t as SkillRegistry, u as scanSkillDirectory } from "./registry-Do2Htns7.mjs";
+import { A as SkillFrontmatterSchema, D as ClaudeSettingsSchema, E as validateSkillFile, G as AmbiguousSkillNameError, J as SkillNotFoundError, K as CcskiError, O as InstalledPluginsSchema, T as parseSkillFile, Y as ValidationError, c as getDefaultSkillDirectories, k as PluginEntrySchema, l as loadSkill, q as ParseError, s as discoverSkills, t as SkillRegistry, u as scanSkillDirectory } from "./registry-DNMfmLqa.mjs";
 
-export { AmbiguousSkillNameError, CcskiError, InstalledPluginsSchema, ParseError, PluginEntrySchema, SkillFrontmatterSchema, SkillNotFoundError, SkillRegistry, ValidationError, discoverSkills, getDefaultSkillDirectories, loadSkill, parseSkillFile, scanSkillDirectory, validateSkillFile };
+export { AmbiguousSkillNameError, CcskiError, ClaudeSettingsSchema, InstalledPluginsSchema, ParseError, PluginEntrySchema, SkillFrontmatterSchema, SkillNotFoundError, SkillRegistry, ValidationError, discoverSkills, getDefaultSkillDirectories, loadSkill, parseSkillFile, scanSkillDirectory, validateSkillFile };

package/dist/{registry-Do2Htns7.mjs → registry-DNMfmLqa.mjs}

@@ -3657,15 +3657,20 @@ const PluginEntrySchema = objectType({
 	lastUpdated: stringType(),
 	installPath: stringType(),
 	gitCommitSha: stringType(),
-	isLocal: booleanType()
-});
+	isLocal: booleanType(),
+	scope: stringType().optional()
+}).passthrough();
 /**
 * Schema for installed_plugins.json
 */
 const InstalledPluginsSchema = objectType({
 	version: numberType(),
-	plugins: recordType(stringType(), PluginEntrySchema)
+	plugins: recordType(stringType(), unionType([PluginEntrySchema, arrayType(PluginEntrySchema)]))
 });
+/**
+* Schema for Claude settings.json (subset we care about)
+*/
+const ClaudeSettingsSchema = objectType({ enabledPlugins: recordType(stringType(), booleanType()).optional() }).passthrough();
 
 //#endregion
 //#region node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
@@ -12558,9 +12563,42 @@ function defaultPluginsFile(userDir) {
 function defaultPluginsRoot(userDir) {
 	return join(userDir, ".claude/plugins");
 }
+function defaultSettingsFile(userDir) {
+	return join(userDir, ".claude/settings.json");
+}
 function resolveInstallPath(rawPath, pluginsRoot) {
 	return isAbsolute(rawPath) ? rawPath : join(pluginsRoot, rawPath);
 }
+function normalizePluginEntries(entry) {
+	return Array.isArray(entry) ? entry : [entry];
+}
+function loadClaudeSettings(settingsFile, diagnostics) {
+	if (!existsSync(settingsFile)) {
+		diagnostics?.warnings.push(`Settings file not found at ${settingsFile}`);
+		return null;
+	}
+	try {
+		const content = readFileSync(settingsFile, "utf-8");
+		const json = JSON.parse(content);
+		const validation = ClaudeSettingsSchema.safeParse(json);
+		if (!validation.success) {
+			console.warn(colors.yellow(`Warning: Invalid settings.json format:`), validation.error);
+			diagnostics?.warnings.push("Invalid settings.json format");
+			return null;
+		}
+		return validation.data;
+	} catch (error$1) {
+		console.warn(colors.yellow(`Warning: Failed to load settings.json:`), error$1);
+		diagnostics?.warnings.push(`Failed to load settings.json: ${error$1 instanceof Error ? error$1.message : String(error$1)}`);
+		return null;
+	}
+}
+function resolveEnabledPlugins(settings) {
+	const enabledPlugins = settings?.enabledPlugins;
+	if (!enabledPlugins) return null;
+	const enabled = Object.entries(enabledPlugins).filter(([, isEnabled]) => isEnabled).map(([pluginKey]) => pluginKey);
+	return new Set(enabled);
+}
 /**
 * Parse installed_plugins.json
 */
@@ -12617,54 +12655,64 @@ function discoverPluginSkills(options = {}) {
 	const userDir = options.userDir ? resolve(options.userDir) : homedir();
 	const pluginsFile = options.pluginsFile ?? defaultPluginsFile(userDir);
 	diagnostics.scannedPlugins.push(pluginsFile);
+	const settingsFile = options.settingsFile ?? defaultSettingsFile(userDir);
 	const skills = [];
 	const seenPaths = /* @__PURE__ */ new Set();
 	const pluginsRoot = options.pluginsRoot ?? defaultPluginsRoot(userDir);
 	let missingOrEmpty = false;
 	const plugins = loadInstalledPlugins(pluginsFile, diagnostics);
+	const enabledPlugins = resolveEnabledPlugins(loadClaudeSettings(settingsFile, diagnostics));
 	log("plugins file=%s loaded=%s", pluginsFile, Boolean(plugins));
+	log("settings file=%s enabledPlugins=%s", settingsFile, enabledPlugins?.size ?? "all");
 	if (plugins) for (const [pluginKey, plugin] of Object.entries(plugins.plugins)) {
+		if (enabledPlugins && !enabledPlugins.has(pluginKey)) {
+			log("plugin %s disabled by settings", pluginKey);
+			continue;
+		}
 		const [pluginName, marketplace] = pluginKey.split("@");
 		if (!pluginName || !marketplace) continue;
-		const installPath = resolveInstallPath(plugin.installPath, pluginsRoot);
-		const skillFiles = findSkillFiles(installPath, diagnostics);
-		if (!skillFiles.length) {
-			if (!existsSync(installPath)) {
-				diagnostics.warnings.push(`Plugin install path not found: ${installPath}`);
-				log("missing installPath: %s", installPath);
-			} else {
-				diagnostics.warnings.push(`No skills found in plugin install path: ${installPath}`);
-				log("empty installPath: %s", installPath);
-			}
-			missingOrEmpty = true;
-		}
-		diagnostics.scannedPlugins.push(installPath);
-		log("scanned manifest plugin=%s skills=%d", pluginName, skillFiles.length);
-		for (const skillFile of skillFiles) try {
-			const parsed = parseSkillFile(skillFile);
-			const skillDir = dirname(skillFile);
-			if (seenPaths.has(skillDir)) continue;
-			const skillName = parsed.frontmatter.name;
-			const namespaced = skillName.includes(":") ? skillName : pluginName === skillName ? skillName : `${pluginName}:${skillName}`;
-			skills.push({
-				name: namespaced,
-				description: parsed.frontmatter.description,
-				provider: "claude",
-				location: "plugin",
-				path: skillDir,
-				hasReferences: existsSync(join(skillDir, "references")),
-				hasScripts: existsSync(join(skillDir, "scripts")),
-				hasAssets: existsSync(join(skillDir, "assets")),
-				pluginInfo: {
-					pluginName,
-					marketplace,
-					version: plugin.version
+		const entries = normalizePluginEntries(plugin);
+		for (const entry of entries) {
+			const installPath = resolveInstallPath(entry.installPath, pluginsRoot);
+			const skillFiles = findSkillFiles(installPath, diagnostics);
+			if (!skillFiles.length) {
+				if (!existsSync(installPath)) {
+					diagnostics.warnings.push(`Plugin install path not found: ${installPath}`);
+					log("missing installPath: %s", installPath);
+				} else {
+					diagnostics.warnings.push(`No skills found in plugin install path: ${installPath}`);
+					log("empty installPath: %s", installPath);
 				}
-			});
-			seenPaths.add(skillDir);
-		} catch (error$1) {
-			console.warn(colors.yellow(`Warning: Failed to parse plugin skill ${skillFile}:`), error$1);
-			diagnostics.warnings.push(`Failed to parse plugin skill ${skillFile}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`);
+				missingOrEmpty = true;
+			}
+			diagnostics.scannedPlugins.push(installPath);
+			log("scanned manifest plugin=%s skills=%d", pluginName, skillFiles.length);
+			for (const skillFile of skillFiles) try {
+				const parsed = parseSkillFile(skillFile);
+				const skillDir = dirname(skillFile);
+				if (seenPaths.has(skillDir)) continue;
+				const skillName = parsed.frontmatter.name;
+				const namespaced = skillName.includes(":") ? skillName : pluginName === skillName ? skillName : `${pluginName}:${skillName}`;
+				skills.push({
+					name: namespaced,
+					description: parsed.frontmatter.description,
+					provider: "claude",
+					location: "plugin",
+					path: skillDir,
+					hasReferences: existsSync(join(skillDir, "references")),
+					hasScripts: existsSync(join(skillDir, "scripts")),
+					hasAssets: existsSync(join(skillDir, "assets")),
+					pluginInfo: {
+						pluginName,
+						marketplace,
+						version: entry.version
+					}
+				});
+				seenPaths.add(skillDir);
+			} catch (error$1) {
+				console.warn(colors.yellow(`Warning: Failed to parse plugin skill ${skillFile}:`), error$1);
+				diagnostics.warnings.push(`Failed to parse plugin skill ${skillFile}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`);
+			}
 		}
 	}
 	if (!(process.env.CCSKI_CLAUDE_PLUGINS_FALLBACK === "true")) {
@@ -12674,6 +12722,13 @@ function discoverPluginSkills(options = {}) {
 			diagnostics
 		};
 	}
+	if (enabledPlugins) {
+		log("fallback scan skipped (enabledPlugins present)");
+		return {
+			skills,
+			diagnostics
+		};
+	}
 	if (!plugins || skills.length === 0 || missingOrEmpty) {
 		const fallbackRoot = join(pluginsRoot, "skills");
 		diagnostics.scannedPlugins.push(fallbackRoot);
@@ -13522,5 +13577,5 @@ var SkillRegistry = class {
 };
 
 //#endregion
-export { arrayType as A, recordType as B, warn as C, InstalledPluginsSchema as D, validateSkillFile as E, intersectionType as F, CcskiError as G, unionType as H, literalType as I, ValidationError as J, ParseError as K, numberType as L, custom as M, discriminatedUnionType as N, PluginEntrySchema as O, enumType as P, objectType as R, tone as S, parseSkillFile as T, unknownType as U, stringType as V, AmbiguousSkillNameError as W, highlight$1 as _, containsCaseInsensitive as a, setColorEnabled as b, getDefaultSkillDirectories as c, colors as d, dim as f, heading as g, formatBytes as h, skillAliases as i, booleanType as j, SkillFrontmatterSchema as k, loadSkill as l, error as m, formatSkillId as n, rankStrings as o, duplicateBadge as p, SkillNotFoundError as q, formatSkillLabel as r, discoverSkills as s, SkillRegistry as t, scanSkillDirectory as u, info as v, wrap as w, success as x, renderList as y, optionalType as z };
-//# sourceMappingURL=registry-Do2Htns7.mjs.map
+export { SkillFrontmatterSchema as A, optionalType as B, warn as C, ClaudeSettingsSchema as D, validateSkillFile as E, enumType as F, AmbiguousSkillNameError as G, stringType as H, intersectionType as I, SkillNotFoundError as J, CcskiError as K, literalType as L, booleanType as M, custom as N, InstalledPluginsSchema as O, discriminatedUnionType as P, numberType as R, tone as S, parseSkillFile as T, unionType as U, recordType as V, unknownType as W, ValidationError as Y, highlight$1 as _, containsCaseInsensitive as a, setColorEnabled as b, getDefaultSkillDirectories as c, colors as d, dim as f, heading as g, formatBytes as h, skillAliases as i, arrayType as j, PluginEntrySchema as k, loadSkill as l, error as m, formatSkillId as n, rankStrings as o, duplicateBadge as p, ParseError as q, formatSkillLabel as r, discoverSkills as s, SkillRegistry as t, scanSkillDirectory as u, info as v, wrap as w, success as x, renderList as y, objectType as z };
+//# sourceMappingURL=registry-DNMfmLqa.mjs.map