@claude-collective/cli 0.29.4 → 0.30.0

package/dist/{chunk-SSHG7MEE.js → chunk-QUL7R35E.js}

@@ -68,7 +68,7 @@ import {
   STANDARD_FILES,
   YAML_FORMATTING,
   yamlSchemaComment
-} from "./chunk-IFODQTCX.js";
+} from "./chunk-52XVP55K.js";
 import {
   init_esm_shims
 } from "./chunk-AWKZ5BDL.js";
@@ -363,8 +363,8 @@ Examples:
   }
 }
 function validateLocalPath(source, flagName) {
-  const CONTROL_CHAR_PATTERN2 = /[\x00-\x08\x0E-\x1F\x7F]/u;
-  if (CONTROL_CHAR_PATTERN2.test(source)) {
+  const CONTROL_CHAR_PATTERN = /[\x00-\x08\x0E-\x1F\x7F]/u;
+  if (CONTROL_CHAR_PATTERN.test(source)) {
     throw new Error(
       `${flagName} contains invalid characters: "${source}"
 
@@ -682,11 +682,6 @@ function resolveSkillPath(basePath, skillPath) {
   validateSkillPath(resolved, basePath, skillPath);
   return resolved;
 }
-function getSkillDestPath(skill, stackDir) {
-  const skillRelativePath = skill.path.replace(/^skills\//, "");
-  const skillsDir = path4.join(stackDir, "skills");
-  return resolveSkillPath(skillsDir, skillRelativePath);
-}
 async function generateSkillHash(skillSourcePath) {
   const skillMdPath = path4.join(skillSourcePath, STANDARD_FILES.SKILL_MD);
   return computeFileHash(skillMdPath);
@@ -695,55 +690,6 @@ function getSkillSourcePathFromSource(skill, sourceResult) {
   const srcDir = path4.join(sourceResult.sourcePath, "src");
   return resolveSkillPath(srcDir, skill.path);
 }
-async function copySkillFromSource(skill, stackDir, sourceResult) {
-  const sourcePath = getSkillSourcePathFromSource(skill, sourceResult);
-  const destPath = getSkillDestPath(skill, stackDir);
-  const contentHash = await generateSkillHash(sourcePath);
-  await ensureDir(path4.dirname(destPath));
-  await copy(sourcePath, destPath);
-  await injectForkedFromMetadata(destPath, skill.id, contentHash);
-  return {
-    skillId: skill.id,
-    contentHash,
-    sourcePath,
-    destPath
-  };
-}
-async function copySkillsToPluginFromSource(selectedSkillIds, pluginDir, matrix, sourceResult, sourceSelections, onProgress) {
-  const total = selectedSkillIds.length;
-  let completed = 0;
-  const results = await Promise.all(
-    selectedSkillIds.map(async (skillId) => {
-      const skill = matrix.skills[skillId];
-      if (!skill) {
-        warn(`Skill not found in matrix: '${skillId}'`);
-        completed++;
-        onProgress?.(completed, total);
-        return null;
-      }
-      const selectedSource = sourceSelections?.[skillId];
-      const userSelectedRemote = selectedSource && selectedSource !== "local";
-      let result;
-      if (skill.local && skill.localPath && !userSelectedRemote) {
-        const localSkillPath = path4.join(process.cwd(), skill.localPath);
-        const contentHash = await generateSkillHash(localSkillPath);
-        result = {
-          skillId: skill.id,
-          sourcePath: skill.localPath,
-          destPath: skill.localPath,
-          contentHash,
-          local: true
-        };
-      } else {
-        result = await copySkillFromSource(skill, pluginDir, sourceResult);
-      }
-      completed++;
-      onProgress?.(completed, total);
-      return result;
-    })
-  );
-  return results.filter((r) => r !== null);
-}
 function getFlattenedSkillDestPath(skill, localSkillsDir) {
   return resolveSkillPath(localSkillsDir, skill.id);
 }
@@ -1840,106 +1786,20 @@ async function findPluginManifest(startDir) {
 init_esm_shims();
 import path9 from "path";
 import { last, zip } from "remeda";
-var MAX_SKILL_NAME_LENGTH = 100;
-function getCollectivePluginDir(projectDir) {
-  const dir = projectDir ?? process.cwd();
-  return path9.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR, DEFAULT_PLUGIN_NAME);
-}
 function getProjectPluginsDir(projectDir) {
   const dir = projectDir ?? process.cwd();
   return path9.join(dir, CLAUDE_DIR, PLUGINS_SUBDIR);
 }
-function getPluginSkillsDir(pluginDir) {
-  return path9.join(pluginDir, "skills");
-}
 function getPluginAgentsDir(pluginDir) {
   return path9.join(pluginDir, "agents");
 }
 function getPluginManifestPath(pluginDir) {
   return path9.join(pluginDir, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
 }
-async function readPluginManifest(pluginDir) {
-  const manifestPath = getPluginManifestPath(pluginDir);
-  if (!await fileExists(manifestPath)) {
-    verbose(`  No manifest at ${manifestPath}`);
-    return null;
-  }
-  try {
-    const content = await readFileSafe(manifestPath, MAX_PLUGIN_FILE_SIZE);
-    const manifest = pluginManifestSchema.parse(JSON.parse(content));
-    if (!manifest.name || typeof manifest.name !== "string") {
-      verbose(`  Invalid manifest at ${manifestPath}: missing name`);
-      return null;
-    }
-    return manifest;
-  } catch (error) {
-    verbose(`  Failed to parse manifest at ${manifestPath}: ${error}`);
-    return null;
-  }
-}
-async function getPluginSkillIds(pluginSkillsDir, matrix) {
-  const skillFiles = await glob("**/SKILL.md", pluginSkillsDir);
-  const skillIds = [];
-  const aliasToId = /* @__PURE__ */ new Map();
-  for (const [id, skill] of typedEntries(matrix.skills)) {
-    if (!skill) continue;
-    if (skill.displayName) {
-      aliasToId.set(skill.displayName.toLowerCase(), id);
-    }
-  }
-  const dirToId = /* @__PURE__ */ new Map();
-  for (const [id] of typedEntries(matrix.skills)) {
-    const idParts = id.split("/");
-    const lastPart = last(idParts);
-    if (lastPart) {
-      dirToId.set(lastPart.toLowerCase(), id);
-    }
-  }
-  const fileContents = await Promise.all(
-    skillFiles.map((skillFile) => readFile(path9.join(pluginSkillsDir, skillFile)))
-  );
-  for (const [skillFile, content] of zip(skillFiles, fileContents)) {
-    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    if (frontmatterMatch) {
-      const frontmatter = frontmatterMatch[1];
-      const nameMatch = frontmatter.match(/^name:\s*["']?(.+?)["']?\s*$/m);
-      if (nameMatch) {
-        const skillName = nameMatch[1].trim();
-        if (skillName.length === 0) {
-          warn(`Skipping plugin skill '${skillFile}': empty name in frontmatter`);
-          continue;
-        }
-        if (skillName.length > MAX_SKILL_NAME_LENGTH) {
-          warn(
-            `Skipping plugin skill '${skillFile}': name exceeds ${MAX_SKILL_NAME_LENGTH} characters`
-          );
-          continue;
-        }
-        if (matrix.skills[skillName]) {
-          skillIds.push(skillName);
-          continue;
-        }
-        const skillId2 = aliasToId.get(skillName.toLowerCase());
-        if (skillId2) {
-          skillIds.push(skillId2);
-          continue;
-        }
-      }
-    }
-    const dirPath = path9.dirname(skillFile);
-    const dirName = path9.basename(dirPath);
-    const skillId = dirToId.get(dirName.toLowerCase());
-    if (skillId) {
-      skillIds.push(skillId);
-    }
-  }
-  return skillIds;
-}
 
 // src/cli/lib/plugins/plugin-info.ts
 init_esm_shims();
 import { readdir } from "fs/promises";
-import { countBy } from "remeda";
 
 // src/cli/lib/installation/index.ts
 init_esm_shims();
@@ -1951,36 +1811,32 @@ async function detectInstallation(projectDir = process.cwd()) {
   const srcConfigPath = path10.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML);
   const legacyConfigPath = path10.join(projectDir, CLAUDE_DIR, STANDARD_FILES.CONFIG_YAML);
   const localConfigPath = await fileExists(srcConfigPath) ? srcConfigPath : await fileExists(legacyConfigPath) ? legacyConfigPath : null;
-  if (localConfigPath) {
-    const loaded = await loadProjectConfig(projectDir);
-    const mode = loaded?.config?.installMode ?? "local";
-    if (mode === "local") {
-      return {
-        mode: "local",
-        configPath: localConfigPath,
-        agentsDir: path10.join(projectDir, CLAUDE_DIR, "agents"),
-        skillsDir: path10.join(projectDir, CLAUDE_DIR, "skills"),
-        projectDir
-      };
-    }
+  if (!localConfigPath) {
+    return null;
   }
-  const pluginDir = getCollectivePluginDir(projectDir);
-  const pluginConfigPath = path10.join(pluginDir, STANDARD_FILES.CONFIG_YAML);
-  if (await directoryExists(pluginDir)) {
+  const loaded = await loadProjectConfig(projectDir);
+  const mode = loaded?.config?.installMode ?? "local";
+  if (mode === "local") {
     return {
-      mode: "plugin",
-      configPath: pluginConfigPath,
-      agentsDir: path10.join(pluginDir, "agents"),
-      skillsDir: path10.join(pluginDir, "skills"),
+      mode: "local",
+      configPath: localConfigPath,
+      agentsDir: path10.join(projectDir, CLAUDE_DIR, "agents"),
+      skillsDir: path10.join(projectDir, CLAUDE_DIR, "skills"),
       projectDir
     };
   }
-  return null;
+  return {
+    mode: "plugin",
+    configPath: localConfigPath,
+    agentsDir: path10.join(projectDir, CLAUDE_DIR, "agents"),
+    skillsDir: path10.join(projectDir, CLAUDE_DIR, "plugins"),
+    projectDir
+  };
 }
 
 // src/cli/lib/installation/local-installer.ts
 init_esm_shims();
-import path15 from "path";
+import path14 from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
 // src/cli/lib/stacks/index.ts
@@ -2078,11 +1934,6 @@ function getStackSkillIds(stack) {
   );
 }
 
-// src/cli/lib/stacks/stack-installer.ts
-init_esm_shims();
-import os from "os";
-import path14 from "path";
-
 // src/cli/lib/stacks/stack-plugin-compiler.ts
 init_esm_shims();
 import path13 from "path";
@@ -2528,265 +2379,18 @@ Stack plugin compiled: ${result.stackName}`);
   }
 }
 
-// src/cli/utils/exec.ts
-init_esm_shims();
-import { spawn } from "child_process";
-var MAX_PLUGIN_PATH_LENGTH = 1024;
-var MAX_GITHUB_REPO_LENGTH = 256;
-var MAX_MARKETPLACE_NAME_LENGTH = 128;
-var MAX_PLUGIN_NAME_LENGTH = 256;
-var GITHUB_REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
-var SAFE_NAME_PATTERN = /^[a-zA-Z0-9._@/-]+$/;
-var SAFE_PLUGIN_PATH_PATTERN = /^[a-zA-Z0-9._@/:~-]+$/;
-var CONTROL_CHAR_PATTERN = /[\x00-\x08\x0E-\x1F\x7F]/u;
-function validatePluginPath(pluginPath) {
-  if (!pluginPath || pluginPath.trim().length === 0) {
-    throw new Error("Plugin path must not be empty.");
-  }
-  if (pluginPath.length > MAX_PLUGIN_PATH_LENGTH) {
-    throw new Error(
-      `Plugin path is too long (${pluginPath.length} characters, max ${MAX_PLUGIN_PATH_LENGTH}).`
-    );
-  }
-  if (CONTROL_CHAR_PATTERN.test(pluginPath)) {
-    throw new Error("Plugin path contains invalid control characters.");
-  }
-  if (!SAFE_PLUGIN_PATH_PATTERN.test(pluginPath)) {
-    throw new Error(
-      `Plugin path contains invalid characters: "${pluginPath}"
-Plugin paths may only contain alphanumeric characters, dashes, underscores, dots, slashes, @, and colons.`
-    );
-  }
-}
-function validateGithubRepo(githubRepo) {
-  if (!githubRepo || githubRepo.trim().length === 0) {
-    throw new Error("GitHub repository must not be empty.");
-  }
-  if (githubRepo.length > MAX_GITHUB_REPO_LENGTH) {
-    throw new Error(
-      `GitHub repository is too long (${githubRepo.length} characters, max ${MAX_GITHUB_REPO_LENGTH}).`
-    );
-  }
-  if (CONTROL_CHAR_PATTERN.test(githubRepo)) {
-    throw new Error("GitHub repository contains invalid control characters.");
-  }
-  if (!GITHUB_REPO_PATTERN.test(githubRepo)) {
-    throw new Error(
-      `Invalid GitHub repository format: "${githubRepo}"
-Expected format: owner/repo (e.g., 'my-org/my-skills').`
-    );
-  }
-}
-function validateMarketplaceName(name) {
-  if (!name || name.trim().length === 0) {
-    throw new Error("Marketplace name must not be empty.");
-  }
-  if (name.length > MAX_MARKETPLACE_NAME_LENGTH) {
-    throw new Error(
-      `Marketplace name is too long (${name.length} characters, max ${MAX_MARKETPLACE_NAME_LENGTH}).`
-    );
-  }
-  if (CONTROL_CHAR_PATTERN.test(name)) {
-    throw new Error("Marketplace name contains invalid control characters.");
-  }
-  if (!SAFE_NAME_PATTERN.test(name)) {
-    throw new Error(
-      `Marketplace name contains invalid characters: "${name}"
-Names may only contain alphanumeric characters, dashes, underscores, dots, @, and slashes.`
-    );
-  }
-}
-function validatePluginName(pluginName) {
-  if (!pluginName || pluginName.trim().length === 0) {
-    throw new Error("Plugin name must not be empty.");
-  }
-  if (pluginName.length > MAX_PLUGIN_NAME_LENGTH) {
-    throw new Error(
-      `Plugin name is too long (${pluginName.length} characters, max ${MAX_PLUGIN_NAME_LENGTH}).`
-    );
-  }
-  if (CONTROL_CHAR_PATTERN.test(pluginName)) {
-    throw new Error("Plugin name contains invalid control characters.");
-  }
-  if (!SAFE_NAME_PATTERN.test(pluginName)) {
-    throw new Error(
-      `Plugin name contains invalid characters: "${pluginName}"
-Names may only contain alphanumeric characters, dashes, underscores, dots, @, and slashes.`
-    );
-  }
-}
-async function execCommand(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, args, {
-      cwd: options?.cwd,
-      env: { ...process.env, ...options?.env },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 1
-      });
-    });
-    proc.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-async function claudePluginInstall(pluginPath, scope, projectDir) {
-  validatePluginPath(pluginPath);
-  const args = ["plugin", "install", pluginPath, "--scope", scope];
-  const result = await execCommand("claude", args, { cwd: projectDir });
-  if (result.exitCode !== 0) {
-    const errorMessage = result.stderr || result.stdout || "Unknown error";
-    throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);
-  }
-}
-async function isClaudeCLIAvailable() {
-  try {
-    const result = await execCommand("claude", ["--version"], {});
-    return result.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-async function claudePluginMarketplaceList() {
-  try {
-    const result = await execCommand("claude", ["plugin", "marketplace", "list", "--json"], {});
-    if (result.exitCode !== 0) {
-      return [];
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(result.stdout);
-    } catch {
-      warn("Failed to parse marketplace list output as JSON");
-      return [];
-    }
-    if (!Array.isArray(parsed)) {
-      warn("Unexpected marketplace list format \u2014 expected an array");
-      return [];
-    }
-    return parsed;
-  } catch {
-    return [];
-  }
-}
-async function claudePluginMarketplaceExists(name) {
-  const marketplaces = await claudePluginMarketplaceList();
-  return marketplaces.some((m) => m.name === name);
-}
-async function claudePluginMarketplaceAdd(githubRepo, name) {
-  validateGithubRepo(githubRepo);
-  validateMarketplaceName(name);
-  const args = ["plugin", "marketplace", "add", githubRepo, "--name", name];
-  let result;
-  try {
-    result = await execCommand("claude", args, {});
-  } catch (err) {
-    throw new Error(`Failed to add marketplace: ${getErrorMessage(err)}`);
-  }
-  if (result.exitCode !== 0) {
-    const errorMessage = result.stderr || result.stdout || "Unknown error";
-    if (errorMessage.includes("already installed")) {
-      return;
-    }
-    throw new Error(`Failed to add marketplace: ${errorMessage.trim()}`);
-  }
-}
-async function claudePluginUninstall(pluginName, scope, projectDir) {
-  validatePluginName(pluginName);
-  const args = ["plugin", "uninstall", pluginName, "--scope", scope];
-  const result = await execCommand("claude", args, { cwd: projectDir });
-  if (result.exitCode !== 0) {
-    const errorMessage = result.stderr || result.stdout || "Unknown error";
-    if (errorMessage.includes("not installed") || errorMessage.includes("not found")) {
-      return;
-    }
-    throw new Error(`Plugin uninstall failed: ${errorMessage.trim()}`);
-  }
-}
-
-// src/cli/lib/stacks/stack-installer.ts
-async function compileStackToTemp(options) {
-  const tempDir = path14.join(os.tmpdir(), `cc-stack-${Date.now()}`);
-  await ensureDir(tempDir);
-  const result = await compileStackPlugin({
-    stackId: options.stackId,
-    outputDir: tempDir,
-    projectRoot: options.projectRoot,
-    agentSourcePath: options.agentSourcePath
-  });
-  return {
-    result,
-    cleanup: async () => {
-      await remove(tempDir);
-    }
-  };
-}
-async function installStackAsPlugin(options) {
-  const { stackId, projectDir, sourcePath, agentSourcePath, marketplace } = options;
-  const claudeAvailable = await isClaudeCLIAvailable();
-  if (!claudeAvailable) {
-    throw new Error(
-      "Claude CLI not found. Please install Claude Code first: https://claude.ai/code"
-    );
-  }
-  if (marketplace) {
-    verbose(`Installing from marketplace: ${stackId}@${marketplace}`);
-    const pluginRef = `${stackId}@${marketplace}`;
-    await claudePluginInstall(pluginRef, "project", projectDir);
-    return {
-      pluginName: stackId,
-      stackName: stackId,
-      agents: [],
-      skills: [],
-      pluginPath: pluginRef,
-      fromMarketplace: true
-    };
-  }
-  verbose(`Compiling stack locally: ${stackId}`);
-  const { result, cleanup } = await compileStackToTemp({
-    stackId,
-    projectRoot: sourcePath,
-    agentSourcePath
-  });
-  try {
-    await claudePluginInstall(result.pluginPath, "project", projectDir);
-    return {
-      pluginName: `stack-${stackId}`,
-      stackName: result.stackName,
-      agents: result.agents,
-      skills: result.skillPlugins,
-      pluginPath: result.pluginPath,
-      fromMarketplace: false
-    };
-  } finally {
-    await cleanup();
-  }
-}
-
 // src/cli/lib/installation/local-installer.ts
 function resolveInstallPaths(projectDir) {
   return {
-    skillsDir: path15.join(projectDir, LOCAL_SKILLS_PATH),
-    agentsDir: path15.join(projectDir, CLAUDE_DIR, "agents"),
-    configPath: path15.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML)
+    skillsDir: path14.join(projectDir, LOCAL_SKILLS_PATH),
+    agentsDir: path14.join(projectDir, CLAUDE_DIR, "agents"),
+    configPath: path14.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_YAML)
   };
 }
 async function prepareDirectories(paths) {
   await ensureDir(paths.skillsDir);
   await ensureDir(paths.agentsDir);
-  await ensureDir(path15.dirname(paths.configPath));
+  await ensureDir(path14.dirname(paths.configPath));
 }
 async function archiveAndCopySkills(wizardResult, sourceResult, projectDir, skillsDir) {
   for (const skillId of wizardResult.selectedSkills) {
@@ -2915,11 +2519,49 @@ async function compileAndWriteAgents(compileConfig, agents, localSkills, sourceR
       engine,
       installMode
     );
-    await writeFile(path15.join(agentsDir, `${name}.md`), output);
+    await writeFile(path14.join(agentsDir, `${name}.md`), output);
     compiledAgentNames.push(name);
   }
   return compiledAgentNames;
 }
+async function installPluginConfig(options) {
+  const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
+  const paths = resolveInstallPaths(projectDir);
+  await ensureDir(paths.agentsDir);
+  await ensureDir(path14.dirname(paths.configPath));
+  const agents = await loadMergedAgents(sourceResult.sourcePath);
+  const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
+  const finalConfig = mergeResult.config;
+  await writeConfigFile(finalConfig, paths.configPath);
+  const compileAgentsConfig = buildCompileAgents(finalConfig, agents);
+  const compileConfig = {
+    name: DEFAULT_PLUGIN_NAME,
+    description: finalConfig.description || `Plugin setup with ${wizardResult.selectedSkills.length} skills`,
+    agents: compileAgentsConfig
+  };
+  const stackSkillIds = finalConfig.stack ? getStackSkillIds(finalConfig.stack) : [];
+  const skillsForCompilation = await loadSkillsByIds(
+    stackSkillIds.map((id) => ({ id })),
+    sourceResult.sourcePath
+  );
+  const compiledAgentNames = await compileAndWriteAgents(
+    compileConfig,
+    agents,
+    skillsForCompilation,
+    sourceResult,
+    projectDir,
+    paths.agentsDir,
+    wizardResult.installMode
+  );
+  return {
+    config: finalConfig,
+    configPath: paths.configPath,
+    compiledAgents: compiledAgentNames,
+    wasMerged: mergeResult.merged,
+    mergedConfigPath: mergeResult.existingConfigPath,
+    agentsDir: paths.agentsDir
+  };
+}
 async function installLocal(options) {
   const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
   const paths = resolveInstallPaths(projectDir);
@@ -2962,6 +2604,174 @@ async function installLocal(options) {
   };
 }
 
+// src/cli/lib/plugins/plugin-discovery.ts
+init_esm_shims();
+
+// src/cli/lib/plugins/plugin-settings.ts
+init_esm_shims();
+import path15 from "path";
+import os from "os";
+import { z as z2 } from "zod";
+var pluginSettingsSchema = z2.object({
+  enabledPlugins: z2.record(z2.string(), z2.unknown()).optional()
+}).passthrough();
+var pluginInstallationSchema = z2.object({
+  scope: z2.enum(["user", "project", "local"]),
+  projectPath: z2.string().optional(),
+  installPath: z2.string(),
+  version: z2.string(),
+  installedAt: z2.string(),
+  lastUpdated: z2.string().optional(),
+  gitCommitSha: z2.string().optional()
+});
+var installedPluginsSchema = z2.object({
+  version: z2.number(),
+  plugins: z2.record(z2.string(), z2.array(pluginInstallationSchema))
+}).passthrough();
+var SETTINGS_FILE = "settings.json";
+var INSTALLED_PLUGINS_FILE = "installed_plugins.json";
+async function getEnabledPluginKeys(projectDir) {
+  const settingsPath = path15.join(projectDir, CLAUDE_DIR, SETTINGS_FILE);
+  if (!await fileExists(settingsPath)) {
+    verbose(`No settings.json found at '${settingsPath}'`);
+    return [];
+  }
+  try {
+    const content = await readFileSafe(settingsPath, MAX_CONFIG_FILE_SIZE);
+    const raw = JSON.parse(content);
+    const result = pluginSettingsSchema.safeParse(raw);
+    if (!result.success) {
+      verbose(`Invalid settings.json structure: ${getErrorMessage(result.error)}`);
+      return [];
+    }
+    const settings = result.data;
+    if (!settings.enabledPlugins) {
+      verbose(`No enabledPlugins found in '${settingsPath}'`);
+      return [];
+    }
+    const enabledKeys = typedEntries(settings.enabledPlugins).filter(([, enabled]) => enabled === true).map(([key]) => key);
+    verbose(`Found ${enabledKeys.length} enabled plugins in settings.json`);
+    return enabledKeys;
+  } catch (error) {
+    verbose(`Failed to read settings.json: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+async function resolvePluginInstallPaths(pluginKeys, projectDir) {
+  if (pluginKeys.length === 0) {
+    return [];
+  }
+  const registryPath = path15.join(os.homedir(), CLAUDE_DIR, PLUGINS_SUBDIR, INSTALLED_PLUGINS_FILE);
+  if (!await fileExists(registryPath)) {
+    verbose(`Plugin registry not found at '${registryPath}'`);
+    return [];
+  }
+  try {
+    const content = await readFileSafe(registryPath, MAX_CONFIG_FILE_SIZE);
+    const raw = JSON.parse(content);
+    const result = installedPluginsSchema.safeParse(raw);
+    if (!result.success) {
+      verbose(`Invalid plugin registry structure: ${getErrorMessage(result.error)}`);
+      return [];
+    }
+    const registry = result.data;
+    const resolvedPaths = [];
+    for (const pluginKey of pluginKeys) {
+      const installations = registry.plugins[pluginKey];
+      if (!installations || installations.length === 0) {
+        verbose(`Plugin '${pluginKey}' not found in registry`);
+        continue;
+      }
+      const projectInstall = installations.find(
+        (install) => install.scope === "project" && install.projectPath === projectDir
+      );
+      if (projectInstall) {
+        resolvedPaths.push({
+          pluginKey,
+          installPath: projectInstall.installPath
+        });
+        verbose(`Resolved '${pluginKey}' to '${projectInstall.installPath}'`);
+        continue;
+      }
+      const userInstall = installations.find((install) => install.scope === "user");
+      if (userInstall) {
+        resolvedPaths.push({
+          pluginKey,
+          installPath: userInstall.installPath
+        });
+        verbose(`Resolved '${pluginKey}' to '${userInstall.installPath}' (user scope)`);
+        continue;
+      }
+      verbose(`No matching installation found for '${pluginKey}'`);
+    }
+    return resolvedPaths;
+  } catch (error) {
+    verbose(`Failed to read plugin registry: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+async function getVerifiedPluginInstallPaths(projectDir) {
+  const enabledKeys = await getEnabledPluginKeys(projectDir);
+  const resolvedPaths = await resolvePluginInstallPaths(enabledKeys, projectDir);
+  const verified = [];
+  for (const { pluginKey, installPath } of resolvedPaths) {
+    const pluginJsonPath = path15.join(installPath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+    if (await fileExists(pluginJsonPath)) {
+      verified.push({ pluginKey, installPath });
+    } else {
+      verbose(`Plugin '${pluginKey}' manifest does not exist at: '${pluginJsonPath}'`);
+    }
+  }
+  verbose(`Verified ${verified.length} plugin install paths`);
+  return verified;
+}
+
+// src/cli/lib/plugins/plugin-discovery.ts
+async function discoverAllPluginSkills(projectDir) {
+  const allSkills = {};
+  try {
+    const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+    if (pluginPaths.length === 0) {
+      verbose(`No enabled plugins found in settings.json`);
+      return allSkills;
+    }
+    for (const { pluginKey, installPath } of pluginPaths) {
+      verbose(`Discovering skills from plugin: '${pluginKey}'`);
+      try {
+        const pluginSkills = await loadPluginSkills(installPath);
+        for (const [id, skill] of typedEntries(pluginSkills)) {
+          if (skill) {
+            allSkills[id] = skill;
+          }
+        }
+      } catch (error) {
+        verbose(`Failed to load skills from '${pluginKey}': ${getErrorMessage(error)}`);
+      }
+    }
+  } catch (error) {
+    verbose(`Plugin discovery failed: ${getErrorMessage(error)}`);
+  }
+  return allSkills;
+}
+async function hasIndividualPlugins(projectDir) {
+  try {
+    const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+    return pluginPaths.length > 0;
+  } catch (error) {
+    verbose(`Failed to check for individual plugins: ${getErrorMessage(error)}`);
+    return false;
+  }
+}
+async function listPluginNames(projectDir) {
+  try {
+    const pluginPaths = await getVerifiedPluginInstallPaths(projectDir);
+    return pluginPaths.map(({ pluginKey }) => pluginKey);
+  } catch (error) {
+    verbose(`Failed to list plugin names: ${getErrorMessage(error)}`);
+    return [];
+  }
+}
+
 // src/cli/lib/plugins/plugin-info.ts
 async function getInstallationInfo() {
   const installation = await detectInstallation();
@@ -2972,7 +2782,13 @@ async function getInstallationInfo() {
   let agentCount = 0;
   let name = DEFAULT_PLUGIN_NAME;
   let version = DEFAULT_DISPLAY_VERSION;
-  if (await directoryExists(installation.skillsDir)) {
+  if (installation.mode === "plugin") {
+    try {
+      const pluginSkills = await discoverAllPluginSkills(installation.projectDir);
+      skillCount = Object.keys(pluginSkills).length;
+    } catch {
+    }
+  } else if (await directoryExists(installation.skillsDir)) {
     try {
       const skills = await readdir(installation.skillsDir, {
         withFileTypes: true
@@ -2990,19 +2806,10 @@ async function getInstallationInfo() {
     } catch {
     }
   }
-  if (installation.mode === "local") {
-    const loaded = await loadProjectConfig(installation.projectDir);
-    if (loaded?.config) {
-      name = loaded.config.name || DEFAULT_PLUGIN_NAME;
-      version = "local";
-    }
-  } else {
-    const pluginDir = getCollectivePluginDir(installation.projectDir);
-    const manifest = await readPluginManifest(pluginDir);
-    if (manifest) {
-      name = manifest.name || DEFAULT_PLUGIN_NAME;
-      version = manifest.version || DEFAULT_DISPLAY_VERSION;
-    }
+  const loaded = await loadProjectConfig(installation.projectDir);
+  if (loaded?.config) {
+    name = loaded.config.name || DEFAULT_PLUGIN_NAME;
+    version = installation.mode === "local" ? "local" : "plugin";
   }
   return {
     mode: installation.mode,
@@ -3067,24 +2874,24 @@ async function getPluginVersion(pluginDir) {
 
 // src/cli/lib/plugins/plugin-validator.ts
 init_esm_shims();
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import path17 from "path";
 import fg from "fast-glob";
-import { countBy as countBy2 } from "remeda";
+import { countBy } from "remeda";
 var PLUGIN_DIR = PLUGIN_MANIFEST_DIR;
 var PLUGIN_MANIFEST = STANDARD_FILES.PLUGIN_JSON;
 var KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-var pluginManifestValidationSchema = z2.object({
-  name: z2.string(),
-  version: z2.string().optional(),
-  description: z2.string().optional(),
+var pluginManifestValidationSchema = z3.object({
+  name: z3.string(),
+  version: z3.string().optional(),
+  description: z3.string().optional(),
   author: pluginAuthorSchema.optional(),
-  keywords: z2.array(z2.string()).optional(),
-  commands: z2.union([z2.string(), z2.array(z2.string())]).optional(),
-  agents: z2.union([z2.string(), z2.array(z2.string())]).optional(),
-  skills: z2.union([z2.string(), z2.array(z2.string())]).optional(),
-  hooks: z2.union([z2.string(), hooksRecordSchema]).optional()
+  keywords: z3.array(z3.string()).optional(),
+  commands: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  agents: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  skills: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  hooks: z3.union([z3.string(), hooksRecordSchema]).optional()
 }).strict();
 function formatZodErrors2(error) {
   return error.issues.map((issue) => {
@@ -3370,9 +3177,9 @@ async function validateAllPlugins(pluginsDir) {
   }
   const summary = {
     total: results.length,
-    valid: countBy2(results, (r) => String(r.result.valid))["true"] ?? 0,
-    invalid: countBy2(results, (r) => String(r.result.valid))["false"] ?? 0,
-    withWarnings: countBy2(results, (r) => String(r.result.warnings.length > 0))["true"] ?? 0
+    valid: countBy(results, (r) => String(r.result.valid))["true"] ?? 0,
+    invalid: countBy(results, (r) => String(r.result.valid))["false"] ?? 0,
+    withWarnings: countBy(results, (r) => String(r.result.warnings.length > 0))["true"] ?? 0
   };
   return {
     valid: summary.invalid === 0,
@@ -3437,40 +3244,37 @@ function tagLocalSkills(matrix) {
   verbose(`Tagged ${count} local skills with local source`);
 }
 async function tagPluginSkills(matrix, projectDir) {
-  const pluginDir = getCollectivePluginDir(projectDir);
-  if (!await directoryExists(pluginDir)) {
-    verbose("No plugin directory found, skipping plugin skill tagging");
-    return;
-  }
-  const pluginSkillsDir = getPluginSkillsDir(pluginDir);
-  if (!await directoryExists(pluginSkillsDir)) {
-    verbose("No plugin skills directory found, skipping plugin skill tagging");
+  const allPluginSkillIds = await collectPluginSkillIds(matrix, projectDir);
+  if (allPluginSkillIds.length === 0) {
     return;
   }
-  try {
-    const pluginSkillIds = await getPluginSkillIds(pluginSkillsDir, matrix);
-    for (const skillId of pluginSkillIds) {
-      const skill = matrix.skills[skillId];
-      if (!skill) continue;
-      skill.availableSources = skill.availableSources ?? [];
-      const existingSource = skill.availableSources.find((s) => s.type === "public");
-      if (existingSource && !existingSource.installMode) {
-        existingSource.installed = true;
-        existingSource.installMode = "plugin";
-      } else if (!skill.availableSources.some((s) => s.installMode === "plugin")) {
-        skill.availableSources.push({
-          name: PUBLIC_SOURCE_NAME,
-          type: "public",
-          version: skill.version,
-          installed: true,
-          installMode: "plugin"
-        });
-      }
+  for (const skillId of allPluginSkillIds) {
+    const skill = matrix.skills[skillId];
+    if (!skill) continue;
+    skill.availableSources = skill.availableSources ?? [];
+    const existingSource = skill.availableSources.find((s) => s.type === "public");
+    if (existingSource && !existingSource.installMode) {
+      existingSource.installed = true;
+      existingSource.installMode = "plugin";
+    } else if (!skill.availableSources.some((s) => s.installMode === "plugin")) {
+      skill.availableSources.push({
+        name: PUBLIC_SOURCE_NAME,
+        type: "public",
+        version: skill.version,
+        installed: true,
+        installMode: "plugin"
+      });
     }
-    verbose(`Tagged ${pluginSkillIds.length} plugin-installed skills`);
-  } catch (error) {
-    verbose(`Failed to detect plugin skills: ${error}`);
   }
+  verbose(`Tagged ${allPluginSkillIds.length} plugin-installed skills`);
+}
+async function collectPluginSkillIds(_matrix, projectDir) {
+  const pluginSkills = await discoverAllPluginSkills(projectDir);
+  const skillIds = Object.keys(pluginSkills);
+  if (skillIds.length === 0) {
+    verbose("No plugin skills discovered from settings.json");
+  }
+  return skillIds;
 }
 async function tagExtraSources(matrix, projectDir) {
   let allSources;
@@ -3598,12 +3402,22 @@ async function loadFromRemote(source, sourceConfig, forceRefresh) {
   const fetchResult = await fetchFromSource(source, { forceRefresh });
   verbose(`Fetched to: ${fetchResult.path}`);
   const mergedMatrix = await loadAndMergeFromBasePath(fetchResult.path);
+  let marketplace = sourceConfig.marketplace;
+  if (!marketplace) {
+    try {
+      const marketplaceResult = await fetchMarketplace(source, { forceRefresh });
+      marketplace = marketplaceResult.marketplace.name;
+      verbose(`Using marketplace name from marketplace.json: ${marketplace}`);
+    } catch {
+      warn(`Source does not have a marketplace.json - falling back to local mode`);
+    }
+  }
   return {
     matrix: mergedMatrix,
     sourceConfig,
     sourcePath: fetchResult.path,
     isLocal: false,
-    marketplace: sourceConfig.marketplace
+    marketplace
   };
 }
 async function loadAndMergeFromBasePath(basePath) {
@@ -4385,7 +4199,7 @@ async function saveSourceToProjectConfig(projectDir, source) {
 }
 
 // src/cli/lib/loading/source-fetcher.ts
-var SAFE_NAME_PATTERN2 = /^[a-zA-Z0-9@._/ -]+$/;
+var SAFE_NAME_PATTERN = /^[a-zA-Z0-9@._/ -]+$/;
 var MAX_NAME_LENGTH = 200;
 function sanitizeSourceForCache(source) {
   const hash = createHash2("sha256").update(source).digest("hex").slice(0, CACHE_HASH_LENGTH);
@@ -4561,7 +4375,7 @@ Too many plugins: ${marketplace.plugins.length} (limit: ${MAX_MARKETPLACE_PLUGIN
         `Marketplace plugin name too long (${plugin.name.length} chars): '${plugin.name.slice(0, 50)}...'`
       );
     }
-    if (!SAFE_NAME_PATTERN2.test(plugin.name)) {
+    if (!SAFE_NAME_PATTERN.test(plugin.name)) {
       warn(`Marketplace plugin name contains unsafe characters: '${plugin.name.slice(0, 50)}'`);
     }
   }
@@ -4605,7 +4419,7 @@ async function removeSource(projectDir, name) {
   await saveProjectConfig(projectDir, config);
   verbose(`Removed source "${name}"`);
 }
-async function getSourceSummary(projectDir, matrix) {
+async function getSourceSummary(projectDir) {
   const config = await loadProjectSourceConfig(projectDir) ?? {};
   const sources = [
     {
@@ -4629,15 +4443,11 @@ async function getSourceSummary(projectDir, matrix) {
     verbose("Failed to discover local skills for source summary");
   }
   let pluginSkillCount = 0;
-  if (matrix) {
-    try {
-      const pluginDir = getCollectivePluginDir(projectDir);
-      const pluginSkillsDir = getPluginSkillsDir(pluginDir);
-      const skillIds = await getPluginSkillIds(pluginSkillsDir, matrix);
-      pluginSkillCount = skillIds.length;
-    } catch {
-      verbose("Failed to count plugin skills for source summary");
-    }
+  try {
+    const discoveredSkills = await discoverAllPluginSkills(projectDir);
+    pluginSkillCount = Object.keys(discoveredSkills).length;
+  } catch {
+    verbose("Failed to discover plugin skills for source summary");
   }
   return { sources, localSkillCount, pluginSkillCount };
 }
@@ -4648,12 +4458,9 @@ export {
   findPluginManifest,
   typedEntries,
   typedKeys,
-  getCollectivePluginDir,
   getProjectPluginsDir,
-  getPluginSkillsDir,
   getPluginAgentsDir,
   getPluginManifestPath,
-  getPluginSkillIds,
   DEFAULT_SOURCE,
   SOURCE_ENV_VAR,
   getProjectConfigPath,
@@ -4674,12 +4481,10 @@ export {
   readForkedFromMetadata,
   compareLocalSkillsWithSource,
   injectForkedFromMetadata,
-  copySkillsToPluginFromSource,
   copySkillsToLocalFlattened,
   parseFrontmatter,
   loadAllAgents,
   loadProjectAgents,
-  loadPluginSkills,
   resolveAlias,
   validateSelection,
   getAvailableSkills,
@@ -4695,12 +4500,6 @@ export {
   compileAgentForPlugin,
   compileStackPlugin,
   printStackCompilationSummary,
-  claudePluginInstall,
-  isClaudeCLIAvailable,
-  claudePluginMarketplaceExists,
-  claudePluginMarketplaceAdd,
-  claudePluginUninstall,
-  installStackAsPlugin,
   loadSkillsMatrixFromSource,
   getMarketplaceLabel,
   compileSkillPlugin,
@@ -4712,10 +4511,14 @@ export {
   loadProjectConfig,
   validateProjectConfig,
   saveSourceToProjectConfig,
+  discoverAllPluginSkills,
+  hasIndividualPlugins,
+  listPluginNames,
   addSource,
   removeSource,
   getSourceSummary,
   detectInstallation,
+  installPluginConfig,
   installLocal,
   getInstallationInfo,
   formatInstallationDisplay,
@@ -4725,4 +4528,4 @@ export {
   validateAllPlugins,
   printPluginValidationResult
 };
-//# sourceMappingURL=chunk-SSHG7MEE.js.map
+//# sourceMappingURL=chunk-QUL7R35E.js.map