allagents 1.11.4-next.1 → 1.11.6-next.1

package/dist/index.js

@@ -15693,13 +15693,14 @@ var init_esm = __esm(() => {
 });
 
 // src/core/git-errors.ts
-function classifyError(error, url) {
+function classifyError(error, url, timeoutMs = 60000) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   const isTimeout = errorMessage.includes("block timeout") || errorMessage.includes("timed out");
   const isAuthError = errorMessage.includes("Authentication failed") || errorMessage.includes("could not read Username") || errorMessage.includes("Permission denied") || errorMessage.includes("Repository not found");
   const isServerError = /returned error: 5\d\d/.test(errorMessage) || errorMessage.includes("Internal Server Error");
   if (isTimeout) {
-    return new GitCloneError(`Clone timed out after 60s for ${url}.
+    const timeoutSeconds = Math.round(timeoutMs / 1000);
+    return new GitCloneError(`Clone timed out after ${timeoutSeconds}s for ${url}.
   Check your network connection and repository access.
   For SSH: ssh-add -l (to check loaded keys)
   For HTTPS: Check your git credentials`, url, true, false);
@@ -15732,38 +15733,50 @@ var init_git_errors = __esm(() => {
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, normalize as normalize2, resolve, sep } from "node:path";
+function createGit(baseDir) {
+  return esm_default(baseDir, {
+    timeout: { block: CLONE_TIMEOUT_MS },
+    config: [
+      "filter.lfs.required=false",
+      "filter.lfs.smudge=",
+      "filter.lfs.clean=",
+      "filter.lfs.process="
+    ]
+  }).env({
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_LFS_SKIP_SMUDGE: "1"
+  });
+}
 function gitHubUrl(owner, repo) {
   return `https://github.com/${owner}/${repo}.git`;
 }
 async function cloneToTemp(url, ref) {
   const tempDir = await mkdtemp(join(tmpdir(), "allagents-"));
-  const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+  const git = createGit();
   const cloneOptions = ref ? ["--depth", "1", "--branch", ref] : ["--depth", "1"];
   try {
     await git.clone(url, tempDir, cloneOptions);
     return tempDir;
   } catch (error) {
     await rm(tempDir, { recursive: true, force: true }).catch(() => {});
-    throw classifyError(error, url);
+    throw classifyError(error, url, CLONE_TIMEOUT_MS);
   }
 }
 async function cloneTo(url, dest, ref) {
-  const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+  const git = createGit();
   const cloneOptions = ref ? ["--depth", "1", "--branch", ref] : ["--depth", "1"];
   try {
     await git.clone(url, dest, cloneOptions);
   } catch (error) {
-    throw classifyError(error, url);
+    throw classifyError(error, url, CLONE_TIMEOUT_MS);
   }
 }
 async function pull(repoPath) {
-  const git = esm_default(repoPath, {
-    timeout: { block: CLONE_TIMEOUT_MS }
-  });
+  const git = createGit(repoPath);
   await git.pull();
 }
 async function repoExists(url) {
-  const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+  const git = createGit();
   try {
     await git.listRemote([url]);
     return true;
@@ -15772,7 +15785,7 @@ async function repoExists(url) {
   }
 }
 async function refExists(url, ref) {
-  const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+  const git = createGit();
   try {
     const result = await git.listRemote([
       "--refs",
@@ -15792,10 +15805,17 @@ async function cleanupTempDir(dir) {
   }
   await rm(dir, { recursive: true, force: true });
 }
-var CLONE_TIMEOUT_MS = 60000;
+var DEFAULT_CLONE_TIMEOUT_MS = 300000, CLONE_TIMEOUT_MS;
 var init_git = __esm(() => {
   init_esm();
   init_git_errors();
+  CLONE_TIMEOUT_MS = (() => {
+    const raw = process.env.ALLAGENTS_CLONE_TIMEOUT_MS;
+    if (!raw)
+      return DEFAULT_CLONE_TIMEOUT_MS;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_CLONE_TIMEOUT_MS;
+  })();
 });
 
 // src/utils/plugin-path.ts
@@ -25580,794 +25600,939 @@ var init_skill = __esm(() => {
   import_gray_matter = __toESM(require_gray_matter(), 1);
 });
 
-// src/core/transform.ts
-import { readFile as readFile3, writeFile, mkdir as mkdir3, cp, readdir as readdir2 } from "node:fs/promises";
+// src/models/marketplace-manifest.ts
+var UrlSourceSchema, GitHubSourceSchema, PluginSourceRefSchema, ContactSchema, LspServerSchema, MarketplacePluginEntrySchema, MarketplaceManifestSchema, MarketplaceManifestLenientSchema;
+var init_marketplace_manifest = __esm(() => {
+  init_zod();
+  UrlSourceSchema = exports_external.object({
+    source: exports_external.literal("url"),
+    url: exports_external.string().url()
+  });
+  GitHubSourceSchema = exports_external.object({
+    source: exports_external.literal("github"),
+    repo: exports_external.string().min(1)
+  }).transform((val) => ({
+    source: "url",
+    url: `https://github.com/${val.repo}`
+  }));
+  PluginSourceRefSchema = exports_external.union([exports_external.string(), UrlSourceSchema, GitHubSourceSchema]);
+  ContactSchema = exports_external.object({
+    name: exports_external.string(),
+    email: exports_external.string().optional()
+  });
+  LspServerSchema = exports_external.object({
+    command: exports_external.string(),
+    args: exports_external.array(exports_external.string()).optional(),
+    extensionToLanguage: exports_external.record(exports_external.string()).optional(),
+    startupTimeout: exports_external.number().optional()
+  });
+  MarketplacePluginEntrySchema = exports_external.object({
+    name: exports_external.string().min(1),
+    description: exports_external.string().min(1),
+    source: PluginSourceRefSchema,
+    version: exports_external.string().optional(),
+    author: ContactSchema.optional(),
+    category: exports_external.string().optional(),
+    homepage: exports_external.string().optional(),
+    strict: exports_external.boolean().optional(),
+    tags: exports_external.array(exports_external.string()).optional(),
+    skills: exports_external.array(exports_external.string()).optional(),
+    lspServers: exports_external.record(LspServerSchema).optional()
+  });
+  MarketplaceManifestSchema = exports_external.object({
+    $schema: exports_external.string().optional(),
+    name: exports_external.string().min(1),
+    version: exports_external.string().optional(),
+    description: exports_external.string().min(1),
+    owner: ContactSchema.optional(),
+    plugins: exports_external.array(MarketplacePluginEntrySchema)
+  });
+  MarketplaceManifestLenientSchema = exports_external.object({
+    name: exports_external.string().optional(),
+    plugins: exports_external.array(exports_external.unknown())
+  }).passthrough();
+});
+
+// src/utils/marketplace-manifest-parser.ts
+import { readFile as readFile3 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join7, basename as basename2, dirname as dirname4, relative as relative2 } from "node:path";
-async function ensureWorkspaceRules(filePath, repositories, skillsIndexRefs = []) {
-  const rulesContent = generateWorkspaceRules(repositories, skillsIndexRefs);
-  const startMarker = "<!-- WORKSPACE-RULES:START -->";
-  const endMarker = "<!-- WORKSPACE-RULES:END -->";
-  if (!existsSync4(filePath)) {
-    await writeFile(filePath, `${rulesContent.trim()}
-`, "utf-8");
-    return;
+import { join as join7, resolve as resolve5 } from "node:path";
+async function parseMarketplaceManifest(marketplacePath) {
+  const manifestPath = join7(marketplacePath, MANIFEST_PATH);
+  if (!existsSync4(manifestPath)) {
+    return {
+      success: false,
+      error: `Marketplace manifest not found: ${manifestPath}`
+    };
   }
-  const content = await readFile3(filePath, "utf-8");
-  const startIndex = content.indexOf(startMarker);
-  const endIndex = content.indexOf(endMarker);
-  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
-    const before = content.substring(0, startIndex);
-    const after = content.substring(endIndex + endMarker.length);
-    await writeFile(filePath, before + rulesContent.trim() + after, "utf-8");
-  } else {
-    await writeFile(filePath, content + rulesContent, "utf-8");
+  let raw;
+  try {
+    raw = await readFile3(manifestPath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read marketplace manifest: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
+  let json2;
+  try {
+    json2 = JSON.parse(raw);
+  } catch {
+    return {
+      success: false,
+      error: "Failed to parse marketplace.json as JSON: invalid syntax"
+    };
+  }
+  const strictResult = MarketplaceManifestSchema.safeParse(json2);
+  if (strictResult.success) {
+    return { success: true, data: strictResult.data, warnings: [] };
+  }
+  return parseLeniently(json2);
 }
-function isExcluded(pluginPath, filePath, exclude) {
-  if (!exclude || exclude.length === 0)
-    return false;
-  const relativePath = relative2(pluginPath, filePath).replaceAll("\\", "/");
-  return import_micromatch.default.isMatch(relativePath, exclude);
-}
-async function copyDirectoryWithExclusions(sourceDir, destDir, pluginPath, exclude) {
-  await mkdir3(destDir, { recursive: true });
-  const entries = await readdir2(sourceDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = join7(sourceDir, entry.name);
-    const destPath = join7(destDir, entry.name);
-    if (isExcluded(pluginPath, sourcePath, exclude)) {
+function parseLeniently(json2) {
+  const lenientResult = MarketplaceManifestLenientSchema.safeParse(json2);
+  if (!lenientResult.success) {
+    return {
+      success: false,
+      error: 'Marketplace manifest must contain a "plugins" array'
+    };
+  }
+  const raw = lenientResult.data;
+  const warnings = [];
+  const obj = json2;
+  const validPlugins = [];
+  for (let i2 = 0;i2 < raw.plugins.length; i2++) {
+    const entry = raw.plugins[i2];
+    const entryResult = MarketplacePluginEntrySchema.safeParse(entry);
+    if (entryResult.success) {
+      validPlugins.push(entryResult.data);
       continue;
     }
-    if (entry.isDirectory()) {
-      await copyDirectoryWithExclusions(sourcePath, destPath, pluginPath, exclude);
-    } else {
-      await cp(sourcePath, destPath);
+    const extracted = extractPluginEntry(entry, i2, warnings);
+    if (extracted) {
+      validPlugins.push(extracted);
     }
   }
+  const data = {
+    name: typeof raw.name === "string" ? raw.name : "unknown",
+    description: typeof obj.description === "string" ? obj.description : "",
+    plugins: validPlugins
+  };
+  return { success: true, data, warnings };
 }
-function getMapping(client, options2) {
-  return options2?.clientMappings?.[client] ?? CLIENT_MAPPINGS[client];
-}
-async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false } = options2;
-  const mapping = getMapping(client, options2);
-  const results = [];
-  if (!mapping.commandsPath) {
-    return results;
-  }
-  const sourceDir = join7(pluginPath, "commands");
-  if (!existsSync4(sourceDir)) {
-    return results;
-  }
-  const destDir = join7(workspacePath, mapping.commandsPath);
-  if (!dryRun) {
-    await mkdir3(destDir, { recursive: true });
+function extractPluginEntry(entry, index, warnings) {
+  if (!entry || typeof entry !== "object") {
+    warnings.push(`plugins[${index}]: not an object, skipped`);
+    return null;
   }
-  const files = await readdir2(sourceDir);
-  const mdFiles = files.filter((f) => f.endsWith(".md"));
-  const copyPromises = mdFiles.filter((file) => !isExcluded(pluginPath, join7(sourceDir, file), options2.exclude)).map(async (file) => {
-    const sourcePath = join7(sourceDir, file);
-    const destPath = join7(destDir, file);
-    if (dryRun) {
-      return { source: sourcePath, destination: destPath, action: "copied" };
-    }
-    try {
-      const content = await readFile3(sourcePath, "utf-8");
-      await writeFile(destPath, content, "utf-8");
-      return { source: sourcePath, destination: destPath, action: "copied" };
-    } catch (error) {
-      return {
-        source: sourcePath,
-        destination: destPath,
-        action: "failed",
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  });
-  return Promise.all(copyPromises);
-}
-async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false, skillNameMap, syncMode = "copy", canonicalSkillsPath } = options2;
-  const mapping = getMapping(client, options2);
-  const results = [];
-  if (!mapping.skillsPath) {
-    return results;
+  const obj = entry;
+  const name = typeof obj.name === "string" && obj.name ? obj.name : undefined;
+  if (!name) {
+    warnings.push(`plugins[${index}]: missing "name" field, skipped`);
+    return null;
   }
-  const skillsDir = join7(pluginPath, "skills");
-  let skillSources;
-  if (existsSync4(skillsDir)) {
-    const entries = await readdir2(skillsDir, { withFileTypes: true });
-    skillSources = entries.filter((e) => e.isDirectory()).filter((e) => !isExcluded(pluginPath, join7(skillsDir, e.name), options2.exclude)).map((e) => ({ name: e.name, sourcePath: join7(skillsDir, e.name), isRootLevel: false }));
+  let description = "";
+  if (typeof obj.description === "string" && obj.description) {
+    description = obj.description;
+  } else if (obj.metadata && typeof obj.metadata === "object" && typeof obj.metadata.description === "string") {
+    description = obj.metadata.description;
+    warnings.push(`plugins[${index}] ("${name}"): "description" found in metadata instead of top level`);
   } else {
-    const entries = await readdir2(pluginPath, { withFileTypes: true });
-    const flatSkills = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const skillMdPath = join7(pluginPath, entry.name, "SKILL.md");
-      if (existsSync4(skillMdPath)) {
-        flatSkills.push({ name: entry.name, sourcePath: join7(pluginPath, entry.name), isRootLevel: false });
-      }
-    }
-    if (flatSkills.length > 0) {
-      skillSources = flatSkills;
-    } else {
-      const rootSkillMd = join7(pluginPath, "SKILL.md");
-      if (existsSync4(rootSkillMd)) {
-        const content = await readFile3(rootSkillMd, "utf-8");
-        const metadata = parseSkillMetadata(content);
-        const skillName = metadata?.name ?? basename2(pluginPath);
-        skillSources = [{ name: skillName, sourcePath: pluginPath, isRootLevel: true }];
-      } else {
-        return results;
-      }
-    }
+    warnings.push(`plugins[${index}] ("${name}"): missing "description" field`);
   }
-  if (skillNameMap) {
-    skillSources = skillSources.filter((s) => skillNameMap.has(s.name));
+  let source = "";
+  const sourceResult = PluginSourceRefSchema.safeParse(obj.source);
+  if (sourceResult.success) {
+    source = sourceResult.data;
+  } else {
+    warnings.push(`plugins[${index}] ("${name}"): missing or invalid "source" field`);
   }
-  if (skillSources.length === 0) {
-    return results;
+  return {
+    name,
+    description,
+    source,
+    ...typeof obj.version === "string" && { version: obj.version },
+    ...typeof obj.category === "string" && { category: obj.category },
+    ...typeof obj.homepage === "string" && { homepage: obj.homepage },
+    ...Array.isArray(obj.skills) && obj.skills.every((s) => typeof s === "string") && { skills: obj.skills }
+  };
+}
+function resolvePluginSourcePath(source, marketplacePath) {
+  if (typeof source === "object") {
+    return source.url;
   }
-  const destDir = join7(workspacePath, mapping.skillsPath);
-  if (!dryRun) {
-    await mkdir3(destDir, { recursive: true });
+  return resolve5(marketplacePath, source);
+}
+var MANIFEST_PATH = ".claude-plugin/marketplace.json";
+var init_marketplace_manifest_parser = __esm(() => {
+  init_marketplace_manifest();
+});
+
+// src/core/workspace-modify.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile4, writeFile } from "node:fs/promises";
+import { join as join8 } from "node:path";
+async function setClients(clients, workspacePath = process.cwd()) {
+  try {
+    await ensureWorkspace(workspacePath);
+    const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    config.clients = clients;
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  const useSymlinks = syncMode === "symlink" && !isUniversalClient(client) && canonicalSkillsPath;
-  const copyPromises = skillSources.map(async (skill) => {
-    const resolvedName = skillNameMap?.get(skill.name) ?? skill.name;
-    const skillDestPath = join7(destDir, resolvedName);
-    if (dryRun) {
+}
+async function ensureWorkspace(workspacePath, clients) {
+  const configDir = join8(workspacePath, CONFIG_DIR);
+  const configPath = join8(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync5(configPath))
+    return;
+  const defaultConfig = {
+    repositories: [],
+    plugins: [],
+    clients: clients ?? [...DEFAULT_PROJECT_CLIENTS]
+  };
+  await mkdir3(configDir, { recursive: true });
+  await writeFile(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
+}
+async function addPlugin(plugin, workspacePath = process.cwd(), force) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  await ensureWorkspace(workspacePath);
+  if (isPluginSpec(plugin)) {
+    const resolved = await resolvePluginSpecWithAutoRegister(plugin, { workspacePath });
+    if (!resolved.success) {
       return {
-        source: skill.sourcePath,
-        destination: skillDestPath,
-        action: "copied"
+        success: false,
+        error: resolved.error || "Unknown error"
       };
     }
-    if (useSymlinks) {
-      const canonicalSkillPath = join7(workspacePath, canonicalSkillsPath, resolvedName);
-      const symlinkCreated = await createSymlink(canonicalSkillPath, skillDestPath);
-      if (symlinkCreated) {
-        return {
-          source: canonicalSkillPath,
-          destination: skillDestPath,
-          action: "copied"
-        };
-      }
+    return await addPluginToConfig(resolved.registeredAs ? plugin.replace(/@[^@]+$/, `@${resolved.registeredAs}`) : plugin, configPath, resolved.registeredAs, force);
+  }
+  if (isGitHubUrl(plugin)) {
+    const validation = validatePluginSource(plugin);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: validation.error || "Invalid GitHub URL"
+      };
     }
-    try {
-      if (skill.isRootLevel) {
-        await mkdir3(skillDestPath, { recursive: true });
-        await cp(join7(skill.sourcePath, "SKILL.md"), join7(skillDestPath, "SKILL.md"));
-      } else if (options2.exclude && options2.exclude.length > 0) {
-        await copyDirectoryWithExclusions(skill.sourcePath, skillDestPath, pluginPath, options2.exclude);
-      } else {
-        await cp(skill.sourcePath, skillDestPath, { recursive: true });
-      }
+    const verifyResult = await verifyGitHubUrlExists(plugin);
+    if (!verifyResult.exists) {
       return {
-        source: skill.sourcePath,
-        destination: skillDestPath,
-        action: "copied"
+        success: false,
+        error: verifyResult.error || `GitHub URL not found: ${plugin}`
       };
-    } catch (error) {
+    }
+  } else {
+    const fullPath = join8(workspacePath, plugin);
+    if (!existsSync5(fullPath) && !existsSync5(plugin)) {
       return {
-        source: skill.sourcePath,
-        destination: skillDestPath,
-        action: "failed",
-        error: error instanceof Error ? error.message : "Unknown error"
+        success: false,
+        error: `Plugin not found at ${plugin}`
       };
     }
-  });
-  return Promise.all(copyPromises);
+  }
+  return await addPluginToConfig(plugin, configPath, undefined, force);
 }
-async function collectPluginSkills(pluginPath, pluginSource, disabledSkills, pluginName, enabledSkills, pluginSkillsConfig) {
-  const skillsDir = join7(pluginPath, "skills");
-  const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && pluginName && [...enabledSkills].some((s) => s.startsWith(`${pluginName}:`));
-  let candidateDirs;
-  if (existsSync4(skillsDir)) {
-    const entries = await readdir2(skillsDir, { withFileTypes: true });
-    candidateDirs = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, path: join7(skillsDir, e.name) }));
-  } else {
-    const entries = await readdir2(pluginPath, { withFileTypes: true });
-    const flatDirs = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const skillMdPath = join7(pluginPath, entry.name, "SKILL.md");
-      if (existsSync4(skillMdPath)) {
-        flatDirs.push({ name: entry.name, path: join7(pluginPath, entry.name) });
+async function addPluginToConfig(plugin, configPath, autoRegistered, force) {
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const existingExactIndex = config.plugins.findIndex((entry) => getPluginSource(entry) === plugin);
+    if (existingExactIndex !== -1) {
+      if (!force) {
+        return {
+          success: false,
+          error: `Plugin already exists in .allagents/workspace.yaml: ${plugin}`
+        };
       }
     }
-    if (flatDirs.length > 0) {
-      candidateDirs = flatDirs;
-    } else {
-      const rootSkillMd = join7(pluginPath, "SKILL.md");
-      if (existsSync4(rootSkillMd)) {
-        const content = await readFile3(rootSkillMd, "utf-8");
-        const metadata = parseSkillMetadata(content);
-        const skillName = metadata?.name ?? basename2(pluginPath);
-        candidateDirs = [{ name: skillName, path: pluginPath }];
-      } else {
-        candidateDirs = [];
+    if (!force) {
+      const newIdentity = await resolveGitHubIdentity(plugin);
+      if (newIdentity) {
+        for (const existing of config.plugins) {
+          const existingSource = getPluginSource(existing);
+          const existingIdentity = await resolveGitHubIdentity(existingSource);
+          if (existingIdentity === newIdentity) {
+            return {
+              success: false,
+              error: `Plugin duplicates existing entry '${existingSource}': both resolve to ${newIdentity}`
+            };
+          }
+        }
       }
     }
-  }
-  let filteredDirs;
-  if (pluginSkillsConfig !== undefined) {
-    if (Array.isArray(pluginSkillsConfig)) {
-      filteredDirs = candidateDirs.filter((e) => pluginSkillsConfig.includes(e.name));
-    } else {
-      filteredDirs = candidateDirs.filter((e) => !pluginSkillsConfig.exclude.includes(e.name));
+    const wasReplaced = force && existingExactIndex !== -1;
+    if (wasReplaced) {
+      config.plugins.splice(existingExactIndex, 1);
     }
-  } else if (pluginName) {
-    if (hasEnabledEntries) {
-      filteredDirs = candidateDirs.filter((e) => enabledSkills?.has(`${pluginName}:${e.name}`));
-    } else if (disabledSkills) {
-      filteredDirs = candidateDirs.filter((e) => !disabledSkills.has(`${pluginName}:${e.name}`));
-    } else {
-      filteredDirs = candidateDirs;
+    config.plugins.push(plugin);
+    const newContent = dump(config, { lineWidth: -1 });
+    await writeFile(configPath, newContent, "utf-8");
+    const result = {
+      success: true,
+      normalizedPlugin: plugin
+    };
+    if (autoRegistered) {
+      result.autoRegistered = autoRegistered;
     }
-  } else {
-    filteredDirs = candidateDirs;
+    if (wasReplaced) {
+      result.replaced = true;
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  return filteredDirs.map((entry) => ({
-    folderName: entry.name,
-    skillPath: entry.path,
-    pluginPath,
-    pluginSource
-  }));
 }
-async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false } = options2;
-  const mapping = getMapping(client, options2);
-  const results = [];
-  if (!mapping.hooksPath) {
-    return results;
-  }
-  const sourceDir = join7(pluginPath, "hooks");
-  if (!existsSync4(sourceDir)) {
-    return results;
-  }
-  const destDir = join7(workspacePath, mapping.hooksPath);
-  if (dryRun) {
-    results.push({ source: sourceDir, destination: destDir, action: "copied" });
-    return results;
-  }
-  await mkdir3(destDir, { recursive: true });
+async function hasPlugin(plugin, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath))
+    return false;
   try {
-    if (options2.exclude && options2.exclude.length > 0) {
-      await copyDirectoryWithExclusions(sourceDir, destDir, pluginPath, options2.exclude);
-    } else {
-      await cp(sourceDir, destDir, { recursive: true });
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    if (config.plugins.some((entry) => getPluginSource(entry) === plugin))
+      return true;
+    if (!isPluginSpec(plugin)) {
+      return config.plugins.some((entry) => {
+        const source = getPluginSource(entry);
+        return source.startsWith(`${plugin}@`) || source === plugin;
+      });
     }
-    results.push({ source: sourceDir, destination: destDir, action: "copied" });
-  } catch (error) {
-    results.push({
-      source: sourceDir,
-      destination: destDir,
-      action: "failed",
-      error: error instanceof Error ? error.message : "Unknown error"
-    });
+    return false;
+  } catch {
+    return false;
   }
-  return results;
 }
-async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false } = options2;
-  const mapping = getMapping(client, options2);
-  const results = [];
-  if (!mapping.agentsPath) {
-    return results;
-  }
-  const sourceDir = join7(pluginPath, "agents");
-  if (!existsSync4(sourceDir)) {
-    return results;
-  }
-  const destDir = join7(workspacePath, mapping.agentsPath);
-  if (!dryRun) {
-    await mkdir3(destDir, { recursive: true });
+async function removePlugin(plugin, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
+  Run 'allagents workspace init <path>' to create a new workspace`
+    };
   }
-  const files = await readdir2(sourceDir);
-  const mdFiles = files.filter((f) => f.endsWith(".md"));
-  const copyPromises = mdFiles.filter((file) => !isExcluded(pluginPath, join7(sourceDir, file), options2.exclude)).map(async (file) => {
-    const sourcePath = join7(sourceDir, file);
-    const destPath = join7(destDir, file);
-    if (dryRun) {
-      return { source: sourcePath, destination: destPath, action: "copied" };
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    let index = config.plugins.findIndex((entry) => getPluginSource(entry) === plugin);
+    if (index === -1 && isPluginSpec(plugin) === false) {
+      index = config.plugins.findIndex((entry) => {
+        const source = getPluginSource(entry);
+        return source.startsWith(`${plugin}@`) || source === plugin;
+      });
     }
-    try {
-      const content = await readFile3(sourcePath, "utf-8");
-      await writeFile(destPath, content, "utf-8");
-      return { source: sourcePath, destination: destPath, action: "copied" };
-    } catch (error) {
+    if (index === -1) {
+      const identity = await resolveGitHubIdentity(plugin);
+      if (identity) {
+        for (let i2 = 0;i2 < config.plugins.length; i2++) {
+          const p = config.plugins[i2];
+          if (!p)
+            continue;
+          const existing = await resolveGitHubIdentity(getPluginSource(p));
+          if (existing === identity) {
+            index = i2;
+            break;
+          }
+        }
+      }
+    }
+    if (index === -1) {
       return {
-        source: sourcePath,
-        destination: destPath,
-        action: "failed",
-        error: error instanceof Error ? error.message : "Unknown error"
+        success: false,
+        error: `Plugin not found in .allagents/workspace.yaml: ${plugin}`
       };
     }
-  });
-  return Promise.all(copyPromises);
+    const removedEntry = getPluginSource(config.plugins[index]);
+    config.plugins.splice(index, 1);
+    pruneDisabledSkillsForPlugin(config, removedEntry);
+    pruneEnabledSkillsForPlugin(config, removedEntry);
+    const newContent = dump(config, { lineWidth: -1 });
+    await writeFile(configPath, newContent, "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
 }
-async function copyAndAdjustDirectory(sourceDir, destDir, sourceBase, pluginPath, skillsPath, skillNameMap, exclude) {
-  await mkdir3(destDir, { recursive: true });
-  const entries = await readdir2(sourceDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = join7(sourceDir, entry.name);
-    const destPath = join7(destDir, entry.name);
-    if (isExcluded(pluginPath, sourcePath, exclude)) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      await copyAndAdjustDirectory(sourcePath, destPath, sourceBase, pluginPath, skillsPath, skillNameMap, exclude);
-    } else {
-      const relativePath = relative2(sourceBase, sourcePath).replaceAll("\\", "/");
-      const isMarkdown = entry.name.endsWith(".md") || entry.name.endsWith(".markdown");
-      if (isMarkdown) {
-        let content = await readFile3(sourcePath, "utf-8");
-        content = adjustLinksInContent(content, relativePath, {
-          ...skillNameMap && { skillNameMap },
-          workspaceSkillsPath: skillsPath
-        });
-        await writeFile(destPath, content, "utf-8");
-      } else {
-        await cp(sourcePath, destPath);
-      }
+function pruneDisabledSkillsForPlugin(config, pluginEntry) {
+  if (!config.disabledSkills?.length)
+    return;
+  const names = extractPluginNames(pluginEntry);
+  if (names.length === 0)
+    return;
+  const prefixes = names.map((n) => `${n}:`);
+  config.disabledSkills = config.disabledSkills.filter((s) => !prefixes.some((p) => s.startsWith(p)));
+  if (config.disabledSkills.length === 0) {
+    config.disabledSkills = undefined;
+  }
+}
+function extractPluginNames(pluginSource) {
+  if (isPluginSpec(pluginSource)) {
+    const parsed = parsePluginSpec(pluginSource);
+    if (!parsed)
+      return [];
+    const names = [parsed.plugin];
+    if (parsed.marketplaceName && parsed.marketplaceName !== parsed.plugin) {
+      names.push(parsed.marketplaceName);
     }
+    return names;
   }
+  if (isGitHubUrl(pluginSource)) {
+    const parsed = parseGitHubUrl(pluginSource);
+    if (parsed) {
+      const names = [];
+      const ownerRepo = `${parsed.owner}-${parsed.repo}`;
+      if (ownerRepo !== parsed.repo)
+        names.push(ownerRepo);
+      if (parsed.subpath) {
+        const subpathName = parsed.subpath.split("/").filter(Boolean).pop();
+        if (subpathName && !names.includes(subpathName))
+          names.push(subpathName);
+      }
+      if (!names.includes(parsed.repo))
+        names.push(parsed.repo);
+      if (!names.includes(ownerRepo))
+        names.push(ownerRepo);
+      return names;
+    }
+  }
+  const parts = pluginSource.split(/[/\\]/).filter(Boolean);
+  const last2 = parts[parts.length - 1];
+  if (!last2)
+    return [];
+  return [last2.replace(/\.git$/, "")];
 }
-async function copyGitHubContent(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false, skillNameMap } = options2;
-  const mapping = getMapping(client, options2);
-  const results = [];
-  if (!mapping.githubPath) {
-    return results;
+function findPluginEntryByName(config, pluginName) {
+  return config.plugins.findIndex((entry) => extractPluginNames(getPluginSource(entry)).includes(pluginName));
+}
+function ensureObjectPluginEntry(config, index) {
+  const entry = config.plugins[index];
+  if (entry === undefined)
+    throw new Error(`Plugin entry at index ${index} not found`);
+  if (typeof entry === "string") {
+    const objectEntry = { source: entry };
+    config.plugins[index] = objectEntry;
+    return objectEntry;
   }
-  const sourceDir = join7(pluginPath, ".github");
-  if (!existsSync4(sourceDir)) {
-    return results;
+  return entry;
+}
+function uniqueSkillNames(skillNames) {
+  const unique = [];
+  const seen = new Set;
+  for (const skillName of skillNames) {
+    if (seen.has(skillName))
+      continue;
+    seen.add(skillName);
+    unique.push(skillName);
+  }
+  return unique;
+}
+function formatGitHubSource(parsed, styleSource) {
+  const basePath = `${parsed.owner}/${parsed.repo}`;
+  if (styleSource.startsWith("http://") || styleSource.startsWith("https://") || styleSource.startsWith("github.com/")) {
+    const baseUrl = `https://github.com/${basePath}`;
+    if (!parsed.branch)
+      return baseUrl;
+    return parsed.subpath ? `${baseUrl}/tree/${parsed.branch}/${parsed.subpath}` : `${baseUrl}/tree/${parsed.branch}`;
+  }
+  if (!parsed.branch) {
+    return parsed.subpath ? `${basePath}/${parsed.subpath}` : basePath;
+  }
+  return parsed.subpath ? `${basePath}@${parsed.branch}/${parsed.subpath}` : `${basePath}@${parsed.branch}`;
+}
+function canonicalizeGitHubPluginSource(currentSource, nextSource) {
+  const current = parseGitHubUrl(currentSource);
+  const next = parseGitHubUrl(nextSource);
+  if (!current || !next)
+    return nextSource;
+  if (current.owner.toLowerCase() !== next.owner.toLowerCase() || current.repo.toLowerCase() !== next.repo.toLowerCase()) {
+    return nextSource;
+  }
+  if (current.branch && next.branch && current.branch !== next.branch) {
+    return currentSource;
+  }
+  const currentParts = current.subpath?.split("/").filter(Boolean) ?? [];
+  const nextParts = next.subpath?.split("/").filter(Boolean) ?? [];
+  const sharedParts = [];
+  const sharedLength = Math.min(currentParts.length, nextParts.length);
+  for (let i2 = 0;i2 < sharedLength; i2++) {
+    if (currentParts[i2] !== nextParts[i2])
+      break;
+    sharedParts.push(currentParts[i2]);
+  }
+  return formatGitHubSource({
+    owner: current.owner,
+    repo: current.repo,
+    ...current.branch || next.branch ? { branch: current.branch ?? next.branch } : {},
+    ...sharedParts.length > 0 ? { subpath: sharedParts.join("/") } : {}
+  }, currentSource);
+}
+async function findPluginEntryByGitHubIdentity(config, source) {
+  const identity = await resolveGitHubIdentity(source);
+  if (!identity)
+    return -1;
+  for (let i2 = 0;i2 < config.plugins.length; i2++) {
+    const entry = config.plugins[i2];
+    if (!entry)
+      continue;
+    const existingIdentity = await resolveGitHubIdentity(getPluginSource(entry));
+    if (existingIdentity === identity)
+      return i2;
   }
-  const destDir = join7(workspacePath, mapping.githubPath);
-  if (dryRun) {
-    results.push({ source: sourceDir, destination: destDir, action: "copied" });
-    return results;
+  return -1;
+}
+async function upsertGitHubPluginSourceAllowlistInConfig(config, source, skillNames) {
+  const normalizedSkills = uniqueSkillNames(skillNames);
+  const exactIndex = config.plugins.findIndex((entry2) => getPluginSource(entry2) === source);
+  if (exactIndex !== -1) {
+    const entry2 = ensureObjectPluginEntry(config, exactIndex);
+    entry2.source = source;
+    entry2.skills = normalizedSkills;
+    return { success: true, normalizedPlugin: source };
+  }
+  const semanticIndex = await findPluginEntryByGitHubIdentity(config, source);
+  if (semanticIndex === -1) {
+    config.plugins.push({ source, skills: normalizedSkills });
+    return { success: true, normalizedPlugin: source };
+  }
+  const entry = ensureObjectPluginEntry(config, semanticIndex);
+  const normalizedSource = canonicalizeGitHubPluginSource(entry.source, source);
+  entry.source = normalizedSource;
+  entry.skills = normalizedSkills;
+  return { success: true, normalizedPlugin: normalizedSource };
+}
+function parseSkillKey(skillKey) {
+  const colonIdx = skillKey.indexOf(":");
+  if (colonIdx === -1)
+    return null;
+  return {
+    pluginName: skillKey.slice(0, colonIdx),
+    skillName: skillKey.slice(colonIdx + 1)
+  };
+}
+async function addDisabledSkill(skillKey, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
   }
+  const parsed = parseSkillKey(skillKey);
+  if (!parsed) {
+    return {
+      success: false,
+      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
+    };
+  }
+  const { pluginName, skillName } = parsed;
   try {
-    if (mapping.skillsPath || options2.exclude && options2.exclude.length > 0) {
-      await copyAndAdjustDirectory(sourceDir, destDir, sourceDir, pluginPath, mapping.skillsPath ?? "", skillNameMap, options2.exclude);
-    } else {
-      await cp(sourceDir, destDir, { recursive: true });
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' not found in workspace config`
+      };
     }
-    results.push({ source: sourceDir, destination: destDir, action: "copied" });
+    const entry = ensureObjectPluginEntry(config, index);
+    if (Array.isArray(entry.skills)) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' is in allowlist mode; use removeEnabledSkill to disable a skill`
+      };
+    }
+    const existing = entry.skills?.exclude ?? [];
+    if (existing.includes(skillName)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already disabled`
+      };
+    }
+    entry.skills = { exclude: [...existing, skillName] };
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
   } catch (error) {
-    results.push({
-      source: sourceDir,
-      destination: destDir,
-      action: "failed",
-      error: error instanceof Error ? error.message : "Unknown error"
-    });
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  return results;
 }
-async function copyPluginToWorkspace(pluginPath, workspacePath, client, options2 = {}) {
-  const { skillNameMap, syncMode, canonicalSkillsPath, ...baseOptions } = options2;
-  const [commandResults, skillResults, hookResults, agentResults] = await Promise.all([
-    copyCommands(pluginPath, workspacePath, client, baseOptions),
-    copySkills(pluginPath, workspacePath, client, {
-      ...baseOptions,
-      ...skillNameMap && { skillNameMap },
-      ...syncMode && { syncMode },
-      ...canonicalSkillsPath && { canonicalSkillsPath }
-    }),
-    copyHooks(pluginPath, workspacePath, client, baseOptions),
-    copyAgents(pluginPath, workspacePath, client, baseOptions)
-  ]);
-  const githubResults = await copyGitHubContent(pluginPath, workspacePath, client, {
-    ...baseOptions,
-    ...skillNameMap && { skillNameMap }
-  });
-  return [...commandResults, ...skillResults, ...hookResults, ...agentResults, ...githubResults];
-}
-function isExplicitGitHubSource(source) {
-  if (source.startsWith("https://github.com/") || source.startsWith("http://github.com/") || source.startsWith("github.com/") || source.startsWith("gh:")) {
-    return true;
+async function removeDisabledSkill(skillKey, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
   }
-  if (!source.startsWith(".") && !source.startsWith("/") && source.includes("/")) {
-    const parts = source.split("/");
-    if (parts.length >= 3) {
-      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
-      if (parts[0] && parts[1] && validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
-        return true;
-      }
-    }
+  const parsed = parseSkillKey(skillKey);
+  if (!parsed) {
+    return {
+      success: false,
+      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
+    };
   }
-  return false;
-}
-function resolveFileSourcePath(source, defaultSourcePath, githubCache) {
-  if (!isExplicitGitHubSource(source)) {
-    if (source.startsWith("/")) {
-      return { path: source };
+  const { pluginName, skillName } = parsed;
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' not found in workspace config`
+      };
     }
-    if (source.startsWith("../")) {
-      return { path: join7(process.cwd(), source) };
+    const entry = config.plugins[index];
+    if (!entry) {
+      return { success: false, error: `Plugin '${pluginName}' not found in workspace config` };
     }
-    if (defaultSourcePath) {
-      return { path: join7(defaultSourcePath, source) };
+    if (typeof entry === "string" || !entry.skills || Array.isArray(entry.skills)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already enabled`
+      };
     }
-    return { path: join7(process.cwd(), source) };
-  }
-  const parsed = parseFileSource(source);
-  if (parsed.type === "github" && parsed.owner && parsed.repo && parsed.filePath) {
-    const cacheKey = `${parsed.owner}/${parsed.repo}`;
-    const cachePath = githubCache?.get(cacheKey);
-    if (!cachePath) {
+    if (!entry.skills.exclude.includes(skillName)) {
       return {
-        path: "",
-        error: `GitHub cache not found for ${cacheKey}. Ensure the repo is fetched.`
+        success: false,
+        error: `Skill '${skillKey}' is already enabled`
       };
     }
-    return { path: join7(cachePath, parsed.filePath) };
-  }
-  if (parsed.type === "github") {
+    const newExclude = entry.skills.exclude.filter((s) => s !== skillName);
+    entry.skills = newExclude.length > 0 ? { exclude: newExclude } : undefined;
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
     return {
-      path: "",
-      error: `Invalid GitHub file source: ${source}. Must include path to file (e.g., owner/repo/path/to/file.md)`
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
     };
   }
-  return null;
 }
-async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {}) {
-  const { dryRun = false, githubCache, repositories = [], skillsIndexRefs = [] } = options2;
-  const results = [];
-  const stringPatterns = [];
-  const objectEntries = [];
-  const copiedAgentFiles = [];
-  for (const file of files) {
-    if (typeof file === "string") {
-      stringPatterns.push(file);
-    } else {
-      let dest = file.dest;
-      if (!dest && file.source) {
-        const parts = file.source.split("/");
-        dest = parts[parts.length - 1] || file.source;
-      }
-      if (!dest) {
-        results.push({
-          source: "unknown",
-          destination: join7(workspacePath, "unknown"),
-          action: "failed",
-          error: "File entry must have at least source or dest specified"
-        });
-        continue;
-      }
-      objectEntries.push(file.source ? { source: file.source, dest } : { dest });
-    }
+async function addEnabledSkill(skillKey, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
   }
-  if (stringPatterns.length > 0) {
-    if (!sourcePath) {
-      for (const pattern of stringPatterns) {
-        if (!isGlobPattern(pattern) && !pattern.startsWith("!")) {
-          results.push({
-            source: pattern,
-            destination: join7(workspacePath, pattern),
-            action: "failed",
-            error: `Cannot resolve file '${pattern}' - no workspace.source configured and no explicit source provided`
-          });
-        }
-      }
-    } else {
-      const resolvedFiles = await resolveGlobPatterns(sourcePath, stringPatterns);
-      for (const resolved of resolvedFiles) {
-        const destPath = join7(workspacePath, resolved.relativePath);
-        if (!existsSync4(resolved.sourcePath)) {
-          const wasLiteral = stringPatterns.some((p) => !isGlobPattern(p) && !p.startsWith("!") && p === resolved.relativePath);
-          if (wasLiteral) {
-            results.push({
-              source: resolved.sourcePath,
-              destination: destPath,
-              action: "failed",
-              error: `Source file not found: ${resolved.sourcePath}`
-            });
-          }
-          continue;
-        }
-        if (dryRun) {
-          results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
-          if (AGENT_FILES2.includes(resolved.relativePath)) {
-            copiedAgentFiles.push(resolved.relativePath);
-          }
-          continue;
-        }
-        try {
-          await mkdir3(dirname4(destPath), { recursive: true });
-          const content = await readFile3(resolved.sourcePath, "utf-8");
-          await writeFile(destPath, content, "utf-8");
-          results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
-          if (AGENT_FILES2.includes(resolved.relativePath)) {
-            copiedAgentFiles.push(resolved.relativePath);
-          }
-        } catch (error) {
-          results.push({
-            source: resolved.sourcePath,
-            destination: destPath,
-            action: "failed",
-            error: error instanceof Error ? error.message : "Unknown error"
-          });
-        }
-      }
-    }
+  const parsed = parseSkillKey(skillKey);
+  if (!parsed) {
+    return {
+      success: false,
+      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
+    };
   }
-  for (const entry of objectEntries) {
-    const destPath = join7(workspacePath, entry.dest);
-    let srcPath;
-    if (entry.source) {
-      const resolved = resolveFileSourcePath(entry.source, sourcePath, githubCache);
-      if (!resolved) {
-        results.push({
-          source: entry.source,
-          destination: destPath,
-          action: "failed",
-          error: `Failed to resolve source: ${entry.source}`
-        });
-        continue;
-      }
-      if (resolved.error) {
-        results.push({
-          source: entry.source,
-          destination: destPath,
-          action: "failed",
-          error: resolved.error
-        });
-        continue;
-      }
-      srcPath = resolved.path;
-    } else {
-      if (!sourcePath) {
-        results.push({
-          source: entry.dest,
-          destination: destPath,
-          action: "failed",
-          error: `Cannot resolve file '${entry.dest}' - no workspace.source configured and no explicit source provided`
-        });
-        continue;
-      }
-      srcPath = join7(sourcePath, entry.dest);
-    }
-    if (!existsSync4(srcPath)) {
-      results.push({
-        source: srcPath,
-        destination: destPath,
-        action: "failed",
-        error: `Source file not found: ${srcPath}`
-      });
-      continue;
-    }
-    if (dryRun) {
-      results.push({ source: srcPath, destination: destPath, action: "copied" });
-      if (AGENT_FILES2.includes(entry.dest)) {
-        copiedAgentFiles.push(entry.dest);
-      }
-      continue;
+  const { pluginName, skillName } = parsed;
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' not found in workspace config`
+      };
     }
-    try {
-      await mkdir3(dirname4(destPath), { recursive: true });
-      const content = await readFile3(srcPath, "utf-8");
-      await writeFile(destPath, content, "utf-8");
-      results.push({ source: srcPath, destination: destPath, action: "copied" });
-      if (AGENT_FILES2.includes(entry.dest)) {
-        copiedAgentFiles.push(entry.dest);
-      }
-    } catch (error) {
-      results.push({
-        source: srcPath,
-        destination: destPath,
-        action: "failed",
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
+    const entry = ensureObjectPluginEntry(config, index);
+    if (entry.skills && !Array.isArray(entry.skills)) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' is in blocklist mode; use removeDisabledSkill to enable a skill`
+      };
     }
-  }
-  if (!dryRun && repositories.length > 0) {
-    for (const agentFile of copiedAgentFiles) {
-      const targetPath = join7(workspacePath, agentFile);
-      try {
-        await ensureWorkspaceRules(targetPath, repositories, skillsIndexRefs);
-      } catch (error) {
-        results.push({
-          source: "WORKSPACE-RULES",
-          destination: targetPath,
-          action: "failed",
-          error: error instanceof Error ? error.message : "Failed to inject WORKSPACE-RULES"
-        });
-      }
+    const existing = entry.skills ?? [];
+    if (existing.includes(skillName)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already enabled`
+      };
     }
+    entry.skills = [...existing, skillName];
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  return results;
 }
-var import_micromatch, AGENT_FILES2;
-var init_transform = __esm(() => {
-  init_glob_patterns();
-  init_client_mapping();
-  init_constants();
-  init_plugin_path();
-  init_symlink();
-  init_link_adjuster();
-  init_skill();
-  import_micromatch = __toESM(require_micromatch(), 1);
-  AGENT_FILES2 = ["AGENTS.md", "CLAUDE.md"];
-});
-
-// src/models/marketplace-manifest.ts
-var UrlSourceSchema, GitHubSourceSchema, PluginSourceRefSchema, ContactSchema, LspServerSchema, MarketplacePluginEntrySchema, MarketplaceManifestSchema, MarketplaceManifestLenientSchema;
-var init_marketplace_manifest = __esm(() => {
-  init_zod();
-  UrlSourceSchema = exports_external.object({
-    source: exports_external.literal("url"),
-    url: exports_external.string().url()
-  });
-  GitHubSourceSchema = exports_external.object({
-    source: exports_external.literal("github"),
-    repo: exports_external.string().min(1)
-  }).transform((val) => ({
-    source: "url",
-    url: `https://github.com/${val.repo}`
-  }));
-  PluginSourceRefSchema = exports_external.union([exports_external.string(), UrlSourceSchema, GitHubSourceSchema]);
-  ContactSchema = exports_external.object({
-    name: exports_external.string(),
-    email: exports_external.string().optional()
-  });
-  LspServerSchema = exports_external.object({
-    command: exports_external.string(),
-    args: exports_external.array(exports_external.string()).optional(),
-    extensionToLanguage: exports_external.record(exports_external.string()).optional(),
-    startupTimeout: exports_external.number().optional()
-  });
-  MarketplacePluginEntrySchema = exports_external.object({
-    name: exports_external.string().min(1),
-    description: exports_external.string().min(1),
-    source: PluginSourceRefSchema,
-    version: exports_external.string().optional(),
-    author: ContactSchema.optional(),
-    category: exports_external.string().optional(),
-    homepage: exports_external.string().optional(),
-    strict: exports_external.boolean().optional(),
-    tags: exports_external.array(exports_external.string()).optional(),
-    skills: exports_external.array(exports_external.string()).optional(),
-    lspServers: exports_external.record(LspServerSchema).optional()
-  });
-  MarketplaceManifestSchema = exports_external.object({
-    $schema: exports_external.string().optional(),
-    name: exports_external.string().min(1),
-    version: exports_external.string().optional(),
-    description: exports_external.string().min(1),
-    owner: ContactSchema.optional(),
-    plugins: exports_external.array(MarketplacePluginEntrySchema)
-  });
-  MarketplaceManifestLenientSchema = exports_external.object({
-    name: exports_external.string().optional(),
-    plugins: exports_external.array(exports_external.unknown())
-  }).passthrough();
-});
-
-// src/utils/marketplace-manifest-parser.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
-import { join as join8, resolve as resolve5 } from "node:path";
-async function parseMarketplaceManifest(marketplacePath) {
-  const manifestPath = join8(marketplacePath, MANIFEST_PATH);
-  if (!existsSync5(manifestPath)) {
+async function removeEnabledSkill(skillKey, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
     return {
       success: false,
-      error: `Marketplace manifest not found: ${manifestPath}`
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
     };
   }
-  let raw;
-  try {
-    raw = await readFile4(manifestPath, "utf-8");
-  } catch (err) {
+  const parsed = parseSkillKey(skillKey);
+  if (!parsed) {
     return {
       success: false,
-      error: `Failed to read marketplace manifest: ${err instanceof Error ? err.message : String(err)}`
+      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
     };
   }
-  let json2;
+  const { pluginName, skillName } = parsed;
   try {
-    json2 = JSON.parse(raw);
-  } catch {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' not found in workspace config`
+      };
+    }
+    const entry = config.plugins[index];
+    if (!entry) {
+      return { success: false, error: `Plugin '${pluginName}' not found in workspace config` };
+    }
+    if (typeof entry === "string" || !entry.skills || !Array.isArray(entry.skills)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already disabled`
+      };
+    }
+    if (!entry.skills.includes(skillName)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already disabled`
+      };
+    }
+    const newSkills = entry.skills.filter((s) => s !== skillName);
+    entry.skills = newSkills;
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
     return {
       success: false,
-      error: "Failed to parse marketplace.json as JSON: invalid syntax"
+      error: error instanceof Error ? error.message : String(error)
     };
   }
-  const strictResult = MarketplaceManifestSchema.safeParse(json2);
-  if (strictResult.success) {
-    return { success: true, data: strictResult.data, warnings: [] };
-  }
-  return parseLeniently(json2);
 }
-function parseLeniently(json2) {
-  const lenientResult = MarketplaceManifestLenientSchema.safeParse(json2);
-  if (!lenientResult.success) {
+async function setPluginSkillsMode(pluginName, mode, skillNames, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
     return {
       success: false,
-      error: 'Marketplace manifest must contain a "plugins" array'
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
     };
   }
-  const raw = lenientResult.data;
-  const warnings = [];
-  const obj = json2;
-  const validPlugins = [];
-  for (let i2 = 0;i2 < raw.plugins.length; i2++) {
-    const entry = raw.plugins[i2];
-    const entryResult = MarketplacePluginEntrySchema.safeParse(entry);
-    if (entryResult.success) {
-      validPlugins.push(entryResult.data);
-      continue;
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      return {
+        success: false,
+        error: `Plugin '${pluginName}' not found in workspace config`
+      };
     }
-    const extracted = extractPluginEntry(entry, i2, warnings);
-    if (extracted) {
-      validPlugins.push(extracted);
+    const entry = ensureObjectPluginEntry(config, index);
+    if (mode === "allowlist") {
+      entry.skills = [...skillNames];
+    } else {
+      entry.skills = skillNames.length > 0 ? { exclude: [...skillNames] } : undefined;
     }
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  const data = {
-    name: typeof raw.name === "string" ? raw.name : "unknown",
-    description: typeof obj.description === "string" ? obj.description : "",
-    plugins: validPlugins
-  };
-  return { success: true, data, warnings };
 }
-function extractPluginEntry(entry, index, warnings) {
-  if (!entry || typeof entry !== "object") {
-    warnings.push(`plugins[${index}]: not an object, skipped`);
-    return null;
+async function upsertGitHubPluginSourceAllowlist(source, skillNames, workspacePath = process.cwd()) {
+  await ensureWorkspace(workspacePath);
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
   }
-  const obj = entry;
-  const name = typeof obj.name === "string" && obj.name ? obj.name : undefined;
-  if (!name) {
-    warnings.push(`plugins[${index}]: missing "name" field, skipped`);
-    return null;
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const result = await upsertGitHubPluginSourceAllowlistInConfig(config, source, skillNames);
+    if (!result.success)
+      return result;
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  let description = "";
-  if (typeof obj.description === "string" && obj.description) {
-    description = obj.description;
-  } else if (obj.metadata && typeof obj.metadata === "object" && typeof obj.metadata.description === "string") {
-    description = obj.metadata.description;
-    warnings.push(`plugins[${index}] ("${name}"): "description" found in metadata instead of top level`);
-  } else {
-    warnings.push(`plugins[${index}] ("${name}"): missing "description" field`);
+}
+function pruneEnabledSkillsForPlugin(config, pluginEntry) {
+  if (!config.enabledSkills?.length)
+    return;
+  const names = extractPluginNames(pluginEntry);
+  if (names.length === 0)
+    return;
+  const prefixes = names.map((n) => `${n}:`);
+  config.enabledSkills = config.enabledSkills.filter((s) => !prefixes.some((p) => s.startsWith(p)));
+  if (config.enabledSkills.length === 0) {
+    config.enabledSkills = undefined;
   }
-  let source = "";
-  const sourceResult = PluginSourceRefSchema.safeParse(obj.source);
-  if (sourceResult.success) {
-    source = sourceResult.data;
-  } else {
-    warnings.push(`plugins[${index}] ("${name}"): missing or invalid "source" field`);
+}
+async function resolveGitHubIdentity(pluginSource) {
+  if (isGitHubUrl(pluginSource)) {
+    const parsed = parseGitHubUrl(pluginSource);
+    return parsed ? `${parsed.owner}/${parsed.repo}`.toLowerCase() : null;
   }
-  return {
-    name,
-    description,
-    source,
-    ...typeof obj.version === "string" && { version: obj.version },
-    ...typeof obj.category === "string" && { category: obj.category },
-    ...typeof obj.homepage === "string" && { homepage: obj.homepage },
-    ...Array.isArray(obj.skills) && obj.skills.every((s) => typeof s === "string") && { skills: obj.skills }
-  };
+  if (isPluginSpec(pluginSource)) {
+    const parsed = parsePluginSpec(pluginSource);
+    if (!parsed)
+      return null;
+    const marketplace = await getMarketplace(parsed.marketplaceName);
+    if (!marketplace)
+      return null;
+    const manifestResult = await parseMarketplaceManifest(marketplace.path);
+    if (!manifestResult.success)
+      return null;
+    const entry = manifestResult.data.plugins.find((p) => p.name === parsed.plugin);
+    if (!entry || typeof entry.source === "string")
+      return null;
+    const parsedUrl = parseGitHubUrl(entry.source.url);
+    return parsedUrl ? `${parsedUrl.owner}/${parsedUrl.repo}`.toLowerCase() : null;
+  }
+  return null;
 }
-function resolvePluginSourcePath(source, marketplacePath) {
-  if (typeof source === "object") {
-    return source.url;
+async function migrateWorkspaceSkillsV1toV2(workspacePath) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync5(configPath))
+    return;
+  let config;
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    config = load(content);
+  } catch {
+    return;
+  }
+  if (!config || config.version !== undefined && config.version >= 2)
+    return;
+  const enabledSkills = config.enabledSkills ?? [];
+  const disabledSkills = config.disabledSkills ?? [];
+  const enabledByPlugin = new Map;
+  for (const skillKey of enabledSkills) {
+    const parsed = parseSkillKey(skillKey);
+    if (!parsed)
+      continue;
+    const list = enabledByPlugin.get(parsed.pluginName) ?? [];
+    list.push(parsed.skillName);
+    enabledByPlugin.set(parsed.pluginName, list);
+  }
+  const disabledByPlugin = new Map;
+  for (const skillKey of disabledSkills) {
+    const parsed = parseSkillKey(skillKey);
+    if (!parsed)
+      continue;
+    const list = disabledByPlugin.get(parsed.pluginName) ?? [];
+    list.push(parsed.skillName);
+    disabledByPlugin.set(parsed.pluginName, list);
+  }
+  for (const [pluginName, skillNames] of enabledByPlugin) {
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      console.warn(`[migrate v1→v2] No plugin found for '${pluginName}', skipping`);
+      continue;
+    }
+    const entry = ensureObjectPluginEntry(config, index);
+    entry.skills = skillNames;
+  }
+  for (const [pluginName, skillNames] of disabledByPlugin) {
+    const index = findPluginEntryByName(config, pluginName);
+    if (index === -1) {
+      console.warn(`[migrate v1→v2] No plugin found for '${pluginName}', skipping`);
+      continue;
+    }
+    const entry = ensureObjectPluginEntry(config, index);
+    if (!Array.isArray(entry.skills)) {
+      entry.skills = { exclude: skillNames };
+    }
+  }
+  config.enabledSkills = undefined;
+  config.disabledSkills = undefined;
+  config.version = 2;
+  try {
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+  } catch (error) {
+    console.warn(`[migrate v1→v2] Failed to write migrated config: ${error instanceof Error ? error.message : String(error)}`);
   }
-  return resolve5(marketplacePath, source);
 }
-var MANIFEST_PATH = ".claude-plugin/marketplace.json";
-var init_marketplace_manifest_parser = __esm(() => {
-  init_marketplace_manifest();
+async function updateRepositories(changes, workspacePath = process.cwd()) {
+  if (changes.remove.length === 0 && changes.add.length === 0) {
+    return { success: true };
+  }
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    const removeSet = new Set(changes.remove);
+    config.repositories = config.repositories.filter((repo) => !removeSet.has(repo.path));
+    config.repositories.push(...changes.add);
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function setRepositories(repositories, workspacePath = process.cwd()) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  try {
+    const content = await readFile4(configPath, "utf-8");
+    const config = load(content);
+    config.repositories = repositories;
+    await writeFile(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var DEFAULT_PROJECT_CLIENTS;
+var init_workspace_modify = __esm(() => {
+  init_js_yaml();
+  init_constants();
+  init_workspace_config();
+  init_marketplace_manifest_parser();
+  init_plugin_path();
+  init_marketplace();
+  DEFAULT_PROJECT_CLIENTS = ["universal"];
 });
 
 // src/core/user-workspace.ts
 var exports_user_workspace = {};
 __export(exports_user_workspace, {
+  upsertUserGitHubPluginSourceAllowlist: () => upsertUserGitHubPluginSourceAllowlist,
   setUserPluginSkillsMode: () => setUserPluginSkillsMode,
   setUserClients: () => setUserClients,
   removeUserPluginsForMarketplace: () => removeUserPluginsForMarketplace,
@@ -26391,7 +26556,7 @@ __export(exports_user_workspace, {
 });
 import { existsSync as existsSync6 } from "node:fs";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename3, join as join9, resolve as resolve6 } from "node:path";
+import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
 function getUserWorkspaceConfigPath() {
   return join9(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
 }
@@ -26611,7 +26776,7 @@ async function setUserClients(clients) {
     };
   }
 }
-function parseSkillKey(skillKey) {
+function parseSkillKey2(skillKey) {
   const colonIdx = skillKey.indexOf(":");
   if (colonIdx === -1)
     return null;
@@ -26644,7 +26809,7 @@ async function getUserDisabledSkills() {
 async function addUserDisabledSkill(skillKey) {
   await ensureUserWorkspace();
   const configPath = getUserWorkspaceConfigPath();
-  const parsed = parseSkillKey(skillKey);
+  const parsed = parseSkillKey2(skillKey);
   if (!parsed) {
     return {
       success: false,
@@ -26689,7 +26854,7 @@ async function addUserDisabledSkill(skillKey) {
 async function removeUserDisabledSkill(skillKey) {
   await ensureUserWorkspace();
   const configPath = getUserWorkspaceConfigPath();
-  const parsed = parseSkillKey(skillKey);
+  const parsed = parseSkillKey2(skillKey);
   if (!parsed) {
     return {
       success: false,
@@ -26758,7 +26923,7 @@ async function getUserEnabledSkills() {
 async function addUserEnabledSkill(skillKey) {
   await ensureUserWorkspace();
   const configPath = getUserWorkspaceConfigPath();
-  const parsed = parseSkillKey(skillKey);
+  const parsed = parseSkillKey2(skillKey);
   if (!parsed) {
     return {
       success: false,
@@ -26803,7 +26968,7 @@ async function addUserEnabledSkill(skillKey) {
 async function removeUserEnabledSkill(skillKey) {
   await ensureUserWorkspace();
   const configPath = getUserWorkspaceConfigPath();
-  const parsed = parseSkillKey(skillKey);
+  const parsed = parseSkillKey2(skillKey);
   if (!parsed) {
     return {
       success: false,
@@ -26876,6 +27041,24 @@ async function setUserPluginSkillsMode(pluginName, mode, skillNames) {
     };
   }
 }
+async function upsertUserGitHubPluginSourceAllowlist(source, skillNames) {
+  await ensureUserWorkspace();
+  const configPath = getUserWorkspaceConfigPath();
+  try {
+    const content = await readFile5(configPath, "utf-8");
+    const config = load(content);
+    const result = await upsertGitHubPluginSourceAllowlistInConfig(config, source, skillNames);
+    if (!result.success)
+      return result;
+    await writeFile2(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function pluginSourceToInfo(plugin, scope) {
   const parsed = parsePluginSpec(plugin);
   if (parsed) {
@@ -26890,14 +27073,14 @@ function pluginSourceToInfo(plugin, scope) {
     const ghParsed = parseGitHubUrl(plugin);
     return {
       spec: plugin,
-      name: ghParsed?.repo ?? basename3(plugin),
+      name: ghParsed?.repo ?? basename2(plugin),
       marketplace: "",
       scope
     };
   }
   return {
     spec: plugin,
-    name: basename3(plugin),
+    name: basename2(plugin),
     marketplace: "",
     scope
   };
@@ -27021,8 +27204,8 @@ var init_user_workspace = __esm(() => {
 
 // src/core/marketplace.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { mkdir as mkdir5, readFile as readFile6, readdir as readdir3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname5, join as join10, resolve as resolve7 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile6, readdir as readdir2, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname4, join as join10, resolve as resolve7 } from "node:path";
 function parseLocation(location) {
   const [owner = "", repo = "", ...rest] = location.split("/");
   const branch = rest.length > 0 ? rest.join("/") : undefined;
@@ -27052,7 +27235,7 @@ async function loadRegistryFromPath(registryPath) {
   }
 }
 async function saveRegistryToPath(registry, registryPath) {
-  const dir = dirname5(registryPath);
+  const dir = dirname4(registryPath);
   if (!existsSync7(dir)) {
     await mkdir5(dir, { recursive: true });
   }
@@ -27108,7 +27291,7 @@ function parseMarketplaceSource(source) {
     };
   }
   const absPath = resolve7(source);
-  const name = source.split(/[/\\]/).filter(Boolean).pop() || basename4(absPath) || "local";
+  const name = source.split(/[/\\]/).filter(Boolean).pop() || basename3(absPath) || "local";
   return {
     type: "local",
     location: absPath,
@@ -27458,7 +27641,7 @@ async function listMarketplacePlugins(name, workspacePath) {
     return { plugins: [], warnings: manifestResult.warnings };
   }
   try {
-    const entries = await readdir3(pluginsDir, { withFileTypes: true });
+    const entries = await readdir2(pluginsDir, { withFileTypes: true });
     const plugins = entries.filter((e) => e.isDirectory()).map((e) => ({
       name: e.name,
       path: join10(pluginsDir, e.name)
@@ -27810,653 +27993,762 @@ var init_marketplace = __esm(() => {
   updatedMarketplaceCache = new Set;
 });
 
-// src/core/workspace-modify.ts
+// src/core/skills.ts
 import { existsSync as existsSync8 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join11 } from "node:path";
-async function setClients(clients, workspacePath = process.cwd()) {
-  try {
-    await ensureWorkspace(workspacePath);
-    const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    config.clients = clients;
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
-  } catch (error) {
+import { readFile as readFile7, readdir as readdir3 } from "node:fs/promises";
+import { join as join11, basename as basename4, resolve as resolve8 } from "node:path";
+async function resolvePluginPath(pluginSource, workspacePath) {
+  if (isPluginSpec(pluginSource)) {
+    const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource, {
+      offline: true,
+      workspacePath
+    });
+    if (!resolved2.success || !resolved2.path)
+      return null;
     return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
+      path: resolved2.path,
+      pluginName: resolved2.pluginName
     };
   }
-}
-async function ensureWorkspace(workspacePath, clients) {
-  const configDir = join11(workspacePath, CONFIG_DIR);
-  const configPath = join11(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync8(configPath))
-    return;
-  const defaultConfig = {
-    repositories: [],
-    plugins: [],
-    clients: clients ?? [...DEFAULT_PROJECT_CLIENTS]
-  };
-  await mkdir6(configDir, { recursive: true });
-  await writeFile4(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
-}
-async function addPlugin(plugin, workspacePath = process.cwd(), force) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  await ensureWorkspace(workspacePath);
-  if (isPluginSpec(plugin)) {
-    const resolved = await resolvePluginSpecWithAutoRegister(plugin, { workspacePath });
-    if (!resolved.success) {
-      return {
-        success: false,
-        error: resolved.error || "Unknown error"
-      };
-    }
-    return await addPluginToConfig(resolved.registeredAs ? plugin.replace(/@[^@]+$/, `@${resolved.registeredAs}`) : plugin, configPath, resolved.registeredAs, force);
-  }
-  if (isGitHubUrl(plugin)) {
-    const validation = validatePluginSource(plugin);
-    if (!validation.valid) {
-      return {
-        success: false,
-        error: validation.error || "Invalid GitHub URL"
-      };
-    }
-    const verifyResult = await verifyGitHubUrlExists(plugin);
-    if (!verifyResult.exists) {
-      return {
-        success: false,
-        error: verifyResult.error || `GitHub URL not found: ${plugin}`
-      };
-    }
-  } else {
-    const fullPath = join11(workspacePath, plugin);
-    if (!existsSync8(fullPath) && !existsSync8(plugin)) {
-      return {
-        success: false,
-        error: `Plugin not found at ${plugin}`
-      };
-    }
-  }
-  return await addPluginToConfig(plugin, configPath, undefined, force);
-}
-async function addPluginToConfig(plugin, configPath, autoRegistered, force) {
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const existingExactIndex = config.plugins.findIndex((entry) => getPluginSource(entry) === plugin);
-    if (existingExactIndex !== -1) {
-      if (!force) {
-        return {
-          success: false,
-          error: `Plugin already exists in .allagents/workspace.yaml: ${plugin}`
-        };
-      }
-    }
-    if (!force) {
-      const newIdentity = await resolveGitHubIdentity(plugin);
-      if (newIdentity) {
-        for (const existing of config.plugins) {
-          const existingSource = getPluginSource(existing);
-          const existingIdentity = await resolveGitHubIdentity(existingSource);
-          if (existingIdentity === newIdentity) {
-            return {
-              success: false,
-              error: `Plugin duplicates existing entry '${existingSource}': both resolve to ${newIdentity}`
-            };
-          }
-        }
-      }
-    }
-    const wasReplaced = force && existingExactIndex !== -1;
-    if (wasReplaced) {
-      config.plugins.splice(existingExactIndex, 1);
-    }
-    config.plugins.push(plugin);
-    const newContent = dump(config, { lineWidth: -1 });
-    await writeFile4(configPath, newContent, "utf-8");
-    const result = {
-      success: true,
-      normalizedPlugin: plugin
-    };
-    if (autoRegistered) {
-      result.autoRegistered = autoRegistered;
-    }
-    if (wasReplaced) {
-      result.replaced = true;
-    }
-    return result;
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+  if (isGitHubUrl(pluginSource)) {
+    const parsed = parseGitHubUrl(pluginSource);
+    const result = await fetchPlugin(pluginSource, {
+      offline: true,
+      ...parsed?.branch && { branch: parsed.branch }
+    });
+    if (!result.success)
+      return null;
+    const path = parsed?.subpath ? join11(result.cachePath, parsed.subpath) : result.cachePath;
+    return existsSync8(path) ? { path } : null;
   }
+  const resolved = resolve8(workspacePath, pluginSource);
+  return existsSync8(resolved) ? { path: resolved } : null;
 }
-async function hasPlugin(plugin, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath))
-    return false;
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    if (config.plugins.some((entry) => getPluginSource(entry) === plugin))
-      return true;
-    if (!isPluginSpec(plugin)) {
-      return config.plugins.some((entry) => {
-        const source = getPluginSource(entry);
-        return source.startsWith(`${plugin}@`) || source === plugin;
-      });
+async function discoverNestedSkillEntries(pluginPath) {
+  const entries = await readdir3(pluginPath, { withFileTypes: true });
+  const discovered = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const skillPath = join11(pluginPath, entry.name);
+    if (existsSync8(join11(skillPath, "SKILL.md"))) {
+      discovered.push({ name: entry.name, skillPath });
+      continue;
     }
-    return false;
-  } catch {
-    return false;
+    discovered.push(...await discoverNestedSkillEntries(skillPath));
   }
+  return discovered;
 }
-async function removePlugin(plugin, workspacePath = process.cwd()) {
+async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
   const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
   if (!existsSync8(configPath)) {
-    return {
-      success: false,
-      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
-  Run 'allagents workspace init <path>' to create a new workspace`
-    };
+    return [];
   }
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    let index = config.plugins.findIndex((entry) => getPluginSource(entry) === plugin);
-    if (index === -1 && isPluginSpec(plugin) === false) {
-      index = config.plugins.findIndex((entry) => {
-        const source = getPluginSource(entry);
-        return source.startsWith(`${plugin}@`) || source === plugin;
-      });
+  const content = await readFile7(configPath, "utf-8");
+  const config = load(content);
+  const isV1Fallback = config.version === undefined || config.version < 2;
+  const disabledSkills = isV1Fallback ? new Set(config.disabledSkills ?? []) : new Set;
+  const enabledSkills = isV1Fallback && config.enabledSkills ? new Set(config.enabledSkills) : null;
+  const skills = [];
+  for (const pluginEntry of config.plugins) {
+    const pluginSource = getPluginSource(pluginEntry);
+    const resolved = await resolvePluginPath(pluginSource, workspacePath);
+    if (!resolved)
+      continue;
+    const pluginPath = resolved.path;
+    const pluginName = resolved.pluginName ?? getPluginName(pluginPath);
+    const skillsDir = join11(pluginPath, "skills");
+    const pluginSkillsConfig = typeof pluginEntry === "string" ? undefined : pluginEntry.skills;
+    const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && [...enabledSkills].some((s) => s.startsWith(`${pluginName}`));
+    let skillEntries;
+    if (existsSync8(skillsDir)) {
+      const entries = await readdir3(skillsDir, { withFileTypes: true });
+      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join11(skillsDir, e.name) }));
+    } else {
+      const nestedSkills = await discoverNestedSkillEntries(pluginPath);
+      if (nestedSkills.length > 0) {
+        skillEntries = nestedSkills;
+      } else {
+        const rootSkillMd = join11(pluginPath, "SKILL.md");
+        if (existsSync8(rootSkillMd)) {
+          const skillContent = await readFile7(rootSkillMd, "utf-8");
+          const metadata = parseSkillMetadata(skillContent);
+          const skillName = metadata?.name ?? basename4(pluginPath);
+          skillEntries = [{ name: skillName, skillPath: pluginPath }];
+        } else {
+          skillEntries = [];
+        }
+      }
     }
-    if (index === -1) {
-      const identity = await resolveGitHubIdentity(plugin);
-      if (identity) {
-        for (let i2 = 0;i2 < config.plugins.length; i2++) {
-          const p = config.plugins[i2];
-          if (!p)
-            continue;
-          const existing = await resolveGitHubIdentity(getPluginSource(p));
-          if (existing === identity) {
-            index = i2;
-            break;
-          }
+    const pluginSkillsMode = pluginSkillsConfig === undefined ? "none" : Array.isArray(pluginSkillsConfig) ? "allowlist" : "blocklist";
+    for (const { name, skillPath } of skillEntries) {
+      const skillKey = `${pluginName}:${name}`;
+      let isDisabled;
+      if (pluginSkillsConfig !== undefined) {
+        if (Array.isArray(pluginSkillsConfig)) {
+          isDisabled = !pluginSkillsConfig.includes(name);
+        } else {
+          isDisabled = pluginSkillsConfig.exclude.includes(name);
         }
+      } else if (isV1Fallback) {
+        isDisabled = hasEnabledEntries ? !enabledSkills?.has(skillKey) : disabledSkills.has(skillKey);
+      } else {
+        isDisabled = false;
       }
+      skills.push({
+        name,
+        pluginName,
+        pluginSource,
+        path: skillPath,
+        disabled: isDisabled,
+        pluginSkillsMode
+      });
     }
-    if (index === -1) {
-      return {
-        success: false,
-        error: `Plugin not found in .allagents/workspace.yaml: ${plugin}`
-      };
+  }
+  return skills;
+}
+async function findSkillByName(skillName, workspacePath = process.cwd()) {
+  const allSkills = await getAllSkillsFromPlugins(workspacePath);
+  return allSkills.filter((s) => s.name === skillName);
+}
+async function discoverSkillNames(pluginPath) {
+  if (!existsSync8(pluginPath))
+    return [];
+  const skillsDir = join11(pluginPath, "skills");
+  if (existsSync8(skillsDir)) {
+    const entries = await readdir3(skillsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  }
+  const nestedSkills = await discoverNestedSkillEntries(pluginPath);
+  if (nestedSkills.length > 0)
+    return nestedSkills.map((entry) => entry.name);
+  const rootSkillMd = join11(pluginPath, "SKILL.md");
+  if (existsSync8(rootSkillMd)) {
+    try {
+      const content = await readFile7(rootSkillMd, "utf-8");
+      const { parseSkillMetadata: parseSkillMetadata2 } = await Promise.resolve().then(() => (init_skill(), exports_skill));
+      const metadata = parseSkillMetadata2(content);
+      return [metadata?.name ?? basename4(pluginPath)];
+    } catch {
+      return [basename4(pluginPath)];
     }
-    const removedEntry = getPluginSource(config.plugins[index]);
-    config.plugins.splice(index, 1);
-    pruneDisabledSkillsForPlugin(config, removedEntry);
-    pruneEnabledSkillsForPlugin(config, removedEntry);
-    const newContent = dump(config, { lineWidth: -1 });
-    await writeFile4(configPath, newContent, "utf-8");
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
   }
+  return [];
 }
-function pruneDisabledSkillsForPlugin(config, pluginEntry) {
-  if (!config.disabledSkills?.length)
-    return;
-  const names = extractPluginNames(pluginEntry);
-  if (names.length === 0)
+var init_skills = __esm(() => {
+  init_js_yaml();
+  init_constants();
+  init_workspace_config();
+  init_plugin();
+  init_plugin_path();
+  init_marketplace();
+  init_skill();
+});
+
+// src/core/transform.ts
+import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir6, cp, readdir as readdir4 } from "node:fs/promises";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join12, basename as basename5, dirname as dirname5, relative as relative2 } from "node:path";
+async function ensureWorkspaceRules(filePath, repositories, skillsIndexRefs = []) {
+  const rulesContent = generateWorkspaceRules(repositories, skillsIndexRefs);
+  const startMarker = "<!-- WORKSPACE-RULES:START -->";
+  const endMarker = "<!-- WORKSPACE-RULES:END -->";
+  if (!existsSync9(filePath)) {
+    await writeFile4(filePath, `${rulesContent.trim()}
+`, "utf-8");
     return;
-  const prefixes = names.map((n) => `${n}:`);
-  config.disabledSkills = config.disabledSkills.filter((s) => !prefixes.some((p) => s.startsWith(p)));
-  if (config.disabledSkills.length === 0) {
-    config.disabledSkills = undefined;
+  }
+  const content = await readFile8(filePath, "utf-8");
+  const startIndex = content.indexOf(startMarker);
+  const endIndex = content.indexOf(endMarker);
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const before = content.substring(0, startIndex);
+    const after = content.substring(endIndex + endMarker.length);
+    await writeFile4(filePath, before + rulesContent.trim() + after, "utf-8");
+  } else {
+    await writeFile4(filePath, content + rulesContent, "utf-8");
   }
 }
-function extractPluginNames(pluginSource) {
-  if (isPluginSpec(pluginSource)) {
-    const parsed = parsePluginSpec(pluginSource);
-    if (!parsed)
-      return [];
-    const names = [parsed.plugin];
-    if (parsed.marketplaceName && parsed.marketplaceName !== parsed.plugin) {
-      names.push(parsed.marketplaceName);
+function isExcluded(pluginPath, filePath, exclude) {
+  if (!exclude || exclude.length === 0)
+    return false;
+  const relativePath = relative2(pluginPath, filePath).replaceAll("\\", "/");
+  return import_micromatch.default.isMatch(relativePath, exclude);
+}
+async function copyDirectoryWithExclusions(sourceDir, destDir, pluginPath, exclude) {
+  await mkdir6(destDir, { recursive: true });
+  const entries = await readdir4(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = join12(sourceDir, entry.name);
+    const destPath = join12(destDir, entry.name);
+    if (isExcluded(pluginPath, sourcePath, exclude)) {
+      continue;
     }
-    return names;
-  }
-  if (isGitHubUrl(pluginSource)) {
-    const parsed = parseGitHubUrl(pluginSource);
-    if (parsed) {
-      const names = [parsed.repo];
-      const ownerRepo = `${parsed.owner}-${parsed.repo}`;
-      if (ownerRepo !== parsed.repo)
-        names.push(ownerRepo);
-      return names;
+    if (entry.isDirectory()) {
+      await copyDirectoryWithExclusions(sourcePath, destPath, pluginPath, exclude);
+    } else {
+      await cp(sourcePath, destPath);
     }
   }
-  const parts = pluginSource.split(/[/\\]/).filter(Boolean);
-  const last2 = parts[parts.length - 1];
-  if (!last2)
-    return [];
-  return [last2.replace(/\.git$/, "")];
 }
-function findPluginEntryByName(config, pluginName) {
-  return config.plugins.findIndex((entry) => extractPluginNames(getPluginSource(entry)).includes(pluginName));
+function getMapping(client, options2) {
+  return options2?.clientMappings?.[client] ?? CLIENT_MAPPINGS[client];
 }
-function ensureObjectPluginEntry(config, index) {
-  const entry = config.plugins[index];
-  if (entry === undefined)
-    throw new Error(`Plugin entry at index ${index} not found`);
-  if (typeof entry === "string") {
-    const objectEntry = { source: entry };
-    config.plugins[index] = objectEntry;
-    return objectEntry;
+async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
+  const { dryRun = false } = options2;
+  const mapping = getMapping(client, options2);
+  const results = [];
+  if (!mapping.commandsPath) {
+    return results;
   }
-  return entry;
-}
-function parseSkillKey2(skillKey) {
-  const colonIdx = skillKey.indexOf(":");
-  if (colonIdx === -1)
-    return null;
-  return {
-    pluginName: skillKey.slice(0, colonIdx),
-    skillName: skillKey.slice(colonIdx + 1)
-  };
-}
-async function addDisabledSkill(skillKey, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath)) {
-    return {
-      success: false,
-      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
-    };
+  const sourceDir = join12(pluginPath, "commands");
+  if (!existsSync9(sourceDir)) {
+    return results;
   }
-  const parsed = parseSkillKey2(skillKey);
-  if (!parsed) {
-    return {
-      success: false,
-      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
-    };
+  const destDir = join12(workspacePath, mapping.commandsPath);
+  if (!dryRun) {
+    await mkdir6(destDir, { recursive: true });
   }
-  const { pluginName, skillName } = parsed;
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
-      return {
-        success: false,
-        error: `Plugin '${pluginName}' not found in workspace config`
-      };
+  const files = await readdir4(sourceDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  const copyPromises = mdFiles.filter((file) => !isExcluded(pluginPath, join12(sourceDir, file), options2.exclude)).map(async (file) => {
+    const sourcePath = join12(sourceDir, file);
+    const destPath = join12(destDir, file);
+    if (dryRun) {
+      return { source: sourcePath, destination: destPath, action: "copied" };
     }
-    const entry = ensureObjectPluginEntry(config, index);
-    if (Array.isArray(entry.skills)) {
+    try {
+      const content = await readFile8(sourcePath, "utf-8");
+      await writeFile4(destPath, content, "utf-8");
+      return { source: sourcePath, destination: destPath, action: "copied" };
+    } catch (error) {
       return {
-        success: false,
-        error: `Plugin '${pluginName}' is in allowlist mode; use removeEnabledSkill to disable a skill`
+        source: sourcePath,
+        destination: destPath,
+        action: "failed",
+        error: error instanceof Error ? error.message : "Unknown error"
       };
     }
-    const existing = entry.skills?.exclude ?? [];
-    if (existing.includes(skillName)) {
-      return {
-        success: false,
-        error: `Skill '${skillKey}' is already disabled`
-      };
+  });
+  return Promise.all(copyPromises);
+}
+async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
+  const { dryRun = false, skillNameMap, syncMode = "copy", canonicalSkillsPath } = options2;
+  const mapping = getMapping(client, options2);
+  const results = [];
+  if (!mapping.skillsPath) {
+    return results;
+  }
+  const skillsDir = join12(pluginPath, "skills");
+  let skillSources;
+  if (existsSync9(skillsDir)) {
+    const entries = await readdir4(skillsDir, { withFileTypes: true });
+    skillSources = entries.filter((e) => e.isDirectory()).filter((e) => !isExcluded(pluginPath, join12(skillsDir, e.name), options2.exclude)).map((e) => ({ name: e.name, sourcePath: join12(skillsDir, e.name), isRootLevel: false }));
+  } else {
+    const nestedSkills = (await discoverNestedSkillEntries(pluginPath)).filter((entry) => !isExcluded(pluginPath, entry.skillPath, options2.exclude)).map((entry) => ({ name: entry.name, sourcePath: entry.skillPath, isRootLevel: false }));
+    if (nestedSkills.length > 0) {
+      skillSources = nestedSkills;
+    } else {
+      const rootSkillMd = join12(pluginPath, "SKILL.md");
+      if (existsSync9(rootSkillMd)) {
+        const content = await readFile8(rootSkillMd, "utf-8");
+        const metadata = parseSkillMetadata(content);
+        const skillName = metadata?.name ?? basename5(pluginPath);
+        skillSources = [{ name: skillName, sourcePath: pluginPath, isRootLevel: true }];
+      } else {
+        return results;
+      }
     }
-    entry.skills = { exclude: [...existing, skillName] };
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
   }
-}
-async function removeDisabledSkill(skillKey, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath)) {
-    return {
-      success: false,
-      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
-    };
+  if (skillNameMap) {
+    skillSources = skillSources.filter((s) => skillNameMap.has(s.name));
   }
-  const parsed = parseSkillKey2(skillKey);
-  if (!parsed) {
-    return {
-      success: false,
-      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
-    };
+  if (skillSources.length === 0) {
+    return results;
   }
-  const { pluginName, skillName } = parsed;
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
+  const destDir = join12(workspacePath, mapping.skillsPath);
+  if (!dryRun) {
+    await mkdir6(destDir, { recursive: true });
+  }
+  const useSymlinks = syncMode === "symlink" && !isUniversalClient(client) && canonicalSkillsPath;
+  const copyPromises = skillSources.map(async (skill) => {
+    const resolvedName = skillNameMap?.get(skill.name) ?? skill.name;
+    const skillDestPath = join12(destDir, resolvedName);
+    if (dryRun) {
       return {
-        success: false,
-        error: `Plugin '${pluginName}' not found in workspace config`
+        source: skill.sourcePath,
+        destination: skillDestPath,
+        action: "copied"
       };
     }
-    const entry = config.plugins[index];
-    if (!entry) {
-      return { success: false, error: `Plugin '${pluginName}' not found in workspace config` };
+    if (useSymlinks) {
+      const canonicalSkillPath = join12(workspacePath, canonicalSkillsPath, resolvedName);
+      const symlinkCreated = await createSymlink(canonicalSkillPath, skillDestPath);
+      if (symlinkCreated) {
+        return {
+          source: canonicalSkillPath,
+          destination: skillDestPath,
+          action: "copied"
+        };
+      }
     }
-    if (typeof entry === "string" || !entry.skills || Array.isArray(entry.skills)) {
+    try {
+      if (skill.isRootLevel) {
+        await mkdir6(skillDestPath, { recursive: true });
+        await cp(join12(skill.sourcePath, "SKILL.md"), join12(skillDestPath, "SKILL.md"));
+      } else if (options2.exclude && options2.exclude.length > 0) {
+        await copyDirectoryWithExclusions(skill.sourcePath, skillDestPath, pluginPath, options2.exclude);
+      } else {
+        await cp(skill.sourcePath, skillDestPath, { recursive: true });
+      }
       return {
-        success: false,
-        error: `Skill '${skillKey}' is already enabled`
+        source: skill.sourcePath,
+        destination: skillDestPath,
+        action: "copied"
       };
-    }
-    if (!entry.skills.exclude.includes(skillName)) {
+    } catch (error) {
       return {
-        success: false,
-        error: `Skill '${skillKey}' is already enabled`
+        source: skill.sourcePath,
+        destination: skillDestPath,
+        action: "failed",
+        error: error instanceof Error ? error.message : "Unknown error"
       };
     }
-    const newExclude = entry.skills.exclude.filter((s) => s !== skillName);
-    entry.skills = newExclude.length > 0 ? { exclude: newExclude } : undefined;
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+  });
+  return Promise.all(copyPromises);
+}
+async function collectPluginSkills(pluginPath, pluginSource, disabledSkills, pluginName, enabledSkills, pluginSkillsConfig) {
+  const skillsDir = join12(pluginPath, "skills");
+  const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && pluginName && [...enabledSkills].some((s) => s.startsWith(`${pluginName}:`));
+  let candidateDirs;
+  if (existsSync9(skillsDir)) {
+    const entries = await readdir4(skillsDir, { withFileTypes: true });
+    candidateDirs = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, path: join12(skillsDir, e.name) }));
+  } else {
+    const nestedDirs = await discoverNestedSkillEntries(pluginPath).then((entries) => entries.map((entry) => ({ name: entry.name, path: entry.skillPath })));
+    if (nestedDirs.length > 0) {
+      candidateDirs = nestedDirs;
+    } else {
+      const rootSkillMd = join12(pluginPath, "SKILL.md");
+      if (existsSync9(rootSkillMd)) {
+        const content = await readFile8(rootSkillMd, "utf-8");
+        const metadata = parseSkillMetadata(content);
+        const skillName = metadata?.name ?? basename5(pluginPath);
+        candidateDirs = [{ name: skillName, path: pluginPath }];
+      } else {
+        candidateDirs = [];
+      }
+    }
+  }
+  let filteredDirs;
+  if (pluginSkillsConfig !== undefined) {
+    if (Array.isArray(pluginSkillsConfig)) {
+      filteredDirs = candidateDirs.filter((e) => pluginSkillsConfig.includes(e.name));
+    } else {
+      filteredDirs = candidateDirs.filter((e) => !pluginSkillsConfig.exclude.includes(e.name));
+    }
+  } else if (pluginName) {
+    if (hasEnabledEntries) {
+      filteredDirs = candidateDirs.filter((e) => enabledSkills?.has(`${pluginName}:${e.name}`));
+    } else if (disabledSkills) {
+      filteredDirs = candidateDirs.filter((e) => !disabledSkills.has(`${pluginName}:${e.name}`));
+    } else {
+      filteredDirs = candidateDirs;
+    }
+  } else {
+    filteredDirs = candidateDirs;
   }
+  return filteredDirs.map((entry) => ({
+    folderName: entry.name,
+    skillPath: entry.path,
+    pluginPath,
+    pluginSource
+  }));
 }
-async function addEnabledSkill(skillKey, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath)) {
-    return {
-      success: false,
-      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
-    };
+async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
+  const { dryRun = false } = options2;
+  const mapping = getMapping(client, options2);
+  const results = [];
+  if (!mapping.hooksPath) {
+    return results;
   }
-  const parsed = parseSkillKey2(skillKey);
-  if (!parsed) {
-    return {
-      success: false,
-      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
-    };
+  const sourceDir = join12(pluginPath, "hooks");
+  if (!existsSync9(sourceDir)) {
+    return results;
   }
-  const { pluginName, skillName } = parsed;
+  const destDir = join12(workspacePath, mapping.hooksPath);
+  if (dryRun) {
+    results.push({ source: sourceDir, destination: destDir, action: "copied" });
+    return results;
+  }
+  await mkdir6(destDir, { recursive: true });
   try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
-      return {
-        success: false,
-        error: `Plugin '${pluginName}' not found in workspace config`
-      };
-    }
-    const entry = ensureObjectPluginEntry(config, index);
-    if (entry.skills && !Array.isArray(entry.skills)) {
-      return {
-        success: false,
-        error: `Plugin '${pluginName}' is in blocklist mode; use removeDisabledSkill to enable a skill`
-      };
-    }
-    const existing = entry.skills ?? [];
-    if (existing.includes(skillName)) {
-      return {
-        success: false,
-        error: `Skill '${skillKey}' is already enabled`
-      };
+    if (options2.exclude && options2.exclude.length > 0) {
+      await copyDirectoryWithExclusions(sourceDir, destDir, pluginPath, options2.exclude);
+    } else {
+      await cp(sourceDir, destDir, { recursive: true });
     }
-    entry.skills = [...existing, skillName];
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
+    results.push({ source: sourceDir, destination: destDir, action: "copied" });
   } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+    results.push({
+      source: sourceDir,
+      destination: destDir,
+      action: "failed",
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
   }
+  return results;
 }
-async function removeEnabledSkill(skillKey, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath)) {
-    return {
-      success: false,
-      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
-    };
+async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
+  const { dryRun = false } = options2;
+  const mapping = getMapping(client, options2);
+  const results = [];
+  if (!mapping.agentsPath) {
+    return results;
   }
-  const parsed = parseSkillKey2(skillKey);
-  if (!parsed) {
-    return {
-      success: false,
-      error: `Invalid skill key format: '${skillKey}' (expected pluginName:skillName)`
-    };
+  const sourceDir = join12(pluginPath, "agents");
+  if (!existsSync9(sourceDir)) {
+    return results;
   }
-  const { pluginName, skillName } = parsed;
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
+  const destDir = join12(workspacePath, mapping.agentsPath);
+  if (!dryRun) {
+    await mkdir6(destDir, { recursive: true });
+  }
+  const files = await readdir4(sourceDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  const copyPromises = mdFiles.filter((file) => !isExcluded(pluginPath, join12(sourceDir, file), options2.exclude)).map(async (file) => {
+    const sourcePath = join12(sourceDir, file);
+    const destPath = join12(destDir, file);
+    if (dryRun) {
+      return { source: sourcePath, destination: destPath, action: "copied" };
+    }
+    try {
+      const content = await readFile8(sourcePath, "utf-8");
+      await writeFile4(destPath, content, "utf-8");
+      return { source: sourcePath, destination: destPath, action: "copied" };
+    } catch (error) {
       return {
-        success: false,
-        error: `Plugin '${pluginName}' not found in workspace config`
+        source: sourcePath,
+        destination: destPath,
+        action: "failed",
+        error: error instanceof Error ? error.message : "Unknown error"
       };
     }
-    const entry = config.plugins[index];
-    if (!entry) {
-      return { success: false, error: `Plugin '${pluginName}' not found in workspace config` };
+  });
+  return Promise.all(copyPromises);
+}
+async function copyAndAdjustDirectory(sourceDir, destDir, sourceBase, pluginPath, skillsPath, skillNameMap, exclude) {
+  await mkdir6(destDir, { recursive: true });
+  const entries = await readdir4(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = join12(sourceDir, entry.name);
+    const destPath = join12(destDir, entry.name);
+    if (isExcluded(pluginPath, sourcePath, exclude)) {
+      continue;
     }
-    if (typeof entry === "string" || !entry.skills || !Array.isArray(entry.skills)) {
-      return {
-        success: false,
-        error: `Skill '${skillKey}' is already disabled`
-      };
+    if (entry.isDirectory()) {
+      await copyAndAdjustDirectory(sourcePath, destPath, sourceBase, pluginPath, skillsPath, skillNameMap, exclude);
+    } else {
+      const relativePath = relative2(sourceBase, sourcePath).replaceAll("\\", "/");
+      const isMarkdown = entry.name.endsWith(".md") || entry.name.endsWith(".markdown");
+      if (isMarkdown) {
+        let content = await readFile8(sourcePath, "utf-8");
+        content = adjustLinksInContent(content, relativePath, {
+          ...skillNameMap && { skillNameMap },
+          workspaceSkillsPath: skillsPath
+        });
+        await writeFile4(destPath, content, "utf-8");
+      } else {
+        await cp(sourcePath, destPath);
+      }
     }
-    if (!entry.skills.includes(skillName)) {
-      return {
-        success: false,
-        error: `Skill '${skillKey}' is already disabled`
-      };
+  }
+}
+async function copyGitHubContent(pluginPath, workspacePath, client, options2 = {}) {
+  const { dryRun = false, skillNameMap } = options2;
+  const mapping = getMapping(client, options2);
+  const results = [];
+  if (!mapping.githubPath) {
+    return results;
+  }
+  const sourceDir = join12(pluginPath, ".github");
+  if (!existsSync9(sourceDir)) {
+    return results;
+  }
+  const destDir = join12(workspacePath, mapping.githubPath);
+  if (dryRun) {
+    results.push({ source: sourceDir, destination: destDir, action: "copied" });
+    return results;
+  }
+  try {
+    if (mapping.skillsPath || options2.exclude && options2.exclude.length > 0) {
+      await copyAndAdjustDirectory(sourceDir, destDir, sourceDir, pluginPath, mapping.skillsPath ?? "", skillNameMap, options2.exclude);
+    } else {
+      await cp(sourceDir, destDir, { recursive: true });
     }
-    const newSkills = entry.skills.filter((s) => s !== skillName);
-    entry.skills = newSkills;
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
+    results.push({ source: sourceDir, destination: destDir, action: "copied" });
   } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+    results.push({
+      source: sourceDir,
+      destination: destDir,
+      action: "failed",
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
   }
+  return results;
 }
-async function setPluginSkillsMode(pluginName, mode, skillNames, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath)) {
-    return {
-      success: false,
-      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
-    };
+async function copyPluginToWorkspace(pluginPath, workspacePath, client, options2 = {}) {
+  const { skillNameMap, syncMode, canonicalSkillsPath, ...baseOptions } = options2;
+  const [commandResults, skillResults, hookResults, agentResults] = await Promise.all([
+    copyCommands(pluginPath, workspacePath, client, baseOptions),
+    copySkills(pluginPath, workspacePath, client, {
+      ...baseOptions,
+      ...skillNameMap && { skillNameMap },
+      ...syncMode && { syncMode },
+      ...canonicalSkillsPath && { canonicalSkillsPath }
+    }),
+    copyHooks(pluginPath, workspacePath, client, baseOptions),
+    copyAgents(pluginPath, workspacePath, client, baseOptions)
+  ]);
+  const githubResults = await copyGitHubContent(pluginPath, workspacePath, client, {
+    ...baseOptions,
+    ...skillNameMap && { skillNameMap }
+  });
+  return [...commandResults, ...skillResults, ...hookResults, ...agentResults, ...githubResults];
+}
+function isExplicitGitHubSource(source) {
+  if (source.startsWith("https://github.com/") || source.startsWith("http://github.com/") || source.startsWith("github.com/") || source.startsWith("gh:")) {
+    return true;
+  }
+  if (!source.startsWith(".") && !source.startsWith("/") && source.includes("/")) {
+    const parts = source.split("/");
+    if (parts.length >= 3) {
+      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
+      if (parts[0] && parts[1] && validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function resolveFileSourcePath(source, defaultSourcePath, githubCache) {
+  if (!isExplicitGitHubSource(source)) {
+    if (source.startsWith("/")) {
+      return { path: source };
+    }
+    if (source.startsWith("../")) {
+      return { path: join12(process.cwd(), source) };
+    }
+    if (defaultSourcePath) {
+      return { path: join12(defaultSourcePath, source) };
+    }
+    return { path: join12(process.cwd(), source) };
   }
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
+  const parsed = parseFileSource(source);
+  if (parsed.type === "github" && parsed.owner && parsed.repo && parsed.filePath) {
+    const cacheKey = `${parsed.owner}/${parsed.repo}`;
+    const cachePath = githubCache?.get(cacheKey);
+    if (!cachePath) {
       return {
-        success: false,
-        error: `Plugin '${pluginName}' not found in workspace config`
+        path: "",
+        error: `GitHub cache not found for ${cacheKey}. Ensure the repo is fetched.`
       };
     }
-    const entry = ensureObjectPluginEntry(config, index);
-    if (mode === "allowlist") {
-      entry.skills = [...skillNames];
-    } else {
-      entry.skills = skillNames.length > 0 ? { exclude: [...skillNames] } : undefined;
-    }
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
-  } catch (error) {
+    return { path: join12(cachePath, parsed.filePath) };
+  }
+  if (parsed.type === "github") {
     return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
+      path: "",
+      error: `Invalid GitHub file source: ${source}. Must include path to file (e.g., owner/repo/path/to/file.md)`
     };
   }
-}
-function pruneEnabledSkillsForPlugin(config, pluginEntry) {
-  if (!config.enabledSkills?.length)
-    return;
-  const names = extractPluginNames(pluginEntry);
-  if (names.length === 0)
-    return;
-  const prefixes = names.map((n) => `${n}:`);
-  config.enabledSkills = config.enabledSkills.filter((s) => !prefixes.some((p) => s.startsWith(p)));
-  if (config.enabledSkills.length === 0) {
-    config.enabledSkills = undefined;
-  }
-}
-async function resolveGitHubIdentity(pluginSource) {
-  if (isGitHubUrl(pluginSource)) {
-    const parsed = parseGitHubUrl(pluginSource);
-    return parsed ? `${parsed.owner}/${parsed.repo}`.toLowerCase() : null;
-  }
-  if (isPluginSpec(pluginSource)) {
-    const parsed = parsePluginSpec(pluginSource);
-    if (!parsed)
-      return null;
-    const marketplace = await getMarketplace(parsed.marketplaceName);
-    if (!marketplace)
-      return null;
-    const manifestResult = await parseMarketplaceManifest(marketplace.path);
-    if (!manifestResult.success)
-      return null;
-    const entry = manifestResult.data.plugins.find((p) => p.name === parsed.plugin);
-    if (!entry || typeof entry.source === "string")
-      return null;
-    const parsedUrl = parseGitHubUrl(entry.source.url);
-    return parsedUrl ? `${parsedUrl.owner}/${parsedUrl.repo}`.toLowerCase() : null;
-  }
   return null;
 }
-async function migrateWorkspaceSkillsV1toV2(workspacePath) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath))
-    return;
-  let config;
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    config = load(content);
-  } catch {
-    return;
-  }
-  if (!config || config.version !== undefined && config.version >= 2)
-    return;
-  const enabledSkills = config.enabledSkills ?? [];
-  const disabledSkills = config.disabledSkills ?? [];
-  const enabledByPlugin = new Map;
-  for (const skillKey of enabledSkills) {
-    const parsed = parseSkillKey2(skillKey);
-    if (!parsed)
-      continue;
-    const list = enabledByPlugin.get(parsed.pluginName) ?? [];
-    list.push(parsed.skillName);
-    enabledByPlugin.set(parsed.pluginName, list);
+async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {}) {
+  const { dryRun = false, githubCache, repositories = [], skillsIndexRefs = [] } = options2;
+  const results = [];
+  const stringPatterns = [];
+  const objectEntries = [];
+  const copiedAgentFiles = [];
+  for (const file of files) {
+    if (typeof file === "string") {
+      stringPatterns.push(file);
+    } else {
+      let dest = file.dest;
+      if (!dest && file.source) {
+        const parts = file.source.split("/");
+        dest = parts[parts.length - 1] || file.source;
+      }
+      if (!dest) {
+        results.push({
+          source: "unknown",
+          destination: join12(workspacePath, "unknown"),
+          action: "failed",
+          error: "File entry must have at least source or dest specified"
+        });
+        continue;
+      }
+      objectEntries.push(file.source ? { source: file.source, dest } : { dest });
+    }
   }
-  const disabledByPlugin = new Map;
-  for (const skillKey of disabledSkills) {
-    const parsed = parseSkillKey2(skillKey);
-    if (!parsed)
-      continue;
-    const list = disabledByPlugin.get(parsed.pluginName) ?? [];
-    list.push(parsed.skillName);
-    disabledByPlugin.set(parsed.pluginName, list);
+  if (stringPatterns.length > 0) {
+    if (!sourcePath) {
+      for (const pattern of stringPatterns) {
+        if (!isGlobPattern(pattern) && !pattern.startsWith("!")) {
+          results.push({
+            source: pattern,
+            destination: join12(workspacePath, pattern),
+            action: "failed",
+            error: `Cannot resolve file '${pattern}' - no workspace.source configured and no explicit source provided`
+          });
+        }
+      }
+    } else {
+      const resolvedFiles = await resolveGlobPatterns(sourcePath, stringPatterns);
+      for (const resolved of resolvedFiles) {
+        const destPath = join12(workspacePath, resolved.relativePath);
+        if (!existsSync9(resolved.sourcePath)) {
+          const wasLiteral = stringPatterns.some((p) => !isGlobPattern(p) && !p.startsWith("!") && p === resolved.relativePath);
+          if (wasLiteral) {
+            results.push({
+              source: resolved.sourcePath,
+              destination: destPath,
+              action: "failed",
+              error: `Source file not found: ${resolved.sourcePath}`
+            });
+          }
+          continue;
+        }
+        if (dryRun) {
+          results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
+          if (AGENT_FILES2.includes(resolved.relativePath)) {
+            copiedAgentFiles.push(resolved.relativePath);
+          }
+          continue;
+        }
+        try {
+          await mkdir6(dirname5(destPath), { recursive: true });
+          const content = await readFile8(resolved.sourcePath, "utf-8");
+          await writeFile4(destPath, content, "utf-8");
+          results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
+          if (AGENT_FILES2.includes(resolved.relativePath)) {
+            copiedAgentFiles.push(resolved.relativePath);
+          }
+        } catch (error) {
+          results.push({
+            source: resolved.sourcePath,
+            destination: destPath,
+            action: "failed",
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      }
+    }
   }
-  for (const [pluginName, skillNames] of enabledByPlugin) {
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
-      console.warn(`[migrate v1→v2] No plugin found for '${pluginName}', skipping`);
+  for (const entry of objectEntries) {
+    const destPath = join12(workspacePath, entry.dest);
+    let srcPath;
+    if (entry.source) {
+      const resolved = resolveFileSourcePath(entry.source, sourcePath, githubCache);
+      if (!resolved) {
+        results.push({
+          source: entry.source,
+          destination: destPath,
+          action: "failed",
+          error: `Failed to resolve source: ${entry.source}`
+        });
+        continue;
+      }
+      if (resolved.error) {
+        results.push({
+          source: entry.source,
+          destination: destPath,
+          action: "failed",
+          error: resolved.error
+        });
+        continue;
+      }
+      srcPath = resolved.path;
+    } else {
+      if (!sourcePath) {
+        results.push({
+          source: entry.dest,
+          destination: destPath,
+          action: "failed",
+          error: `Cannot resolve file '${entry.dest}' - no workspace.source configured and no explicit source provided`
+        });
+        continue;
+      }
+      srcPath = join12(sourcePath, entry.dest);
+    }
+    if (!existsSync9(srcPath)) {
+      results.push({
+        source: srcPath,
+        destination: destPath,
+        action: "failed",
+        error: `Source file not found: ${srcPath}`
+      });
       continue;
     }
-    const entry = ensureObjectPluginEntry(config, index);
-    entry.skills = skillNames;
-  }
-  for (const [pluginName, skillNames] of disabledByPlugin) {
-    const index = findPluginEntryByName(config, pluginName);
-    if (index === -1) {
-      console.warn(`[migrate v1→v2] No plugin found for '${pluginName}', skipping`);
+    if (dryRun) {
+      results.push({ source: srcPath, destination: destPath, action: "copied" });
+      if (AGENT_FILES2.includes(entry.dest)) {
+        copiedAgentFiles.push(entry.dest);
+      }
       continue;
     }
-    const entry = ensureObjectPluginEntry(config, index);
-    if (!Array.isArray(entry.skills)) {
-      entry.skills = { exclude: skillNames };
+    try {
+      await mkdir6(dirname5(destPath), { recursive: true });
+      const content = await readFile8(srcPath, "utf-8");
+      await writeFile4(destPath, content, "utf-8");
+      results.push({ source: srcPath, destination: destPath, action: "copied" });
+      if (AGENT_FILES2.includes(entry.dest)) {
+        copiedAgentFiles.push(entry.dest);
+      }
+    } catch (error) {
+      results.push({
+        source: srcPath,
+        destination: destPath,
+        action: "failed",
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
     }
   }
-  config.enabledSkills = undefined;
-  config.disabledSkills = undefined;
-  config.version = 2;
-  try {
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-  } catch (error) {
-    console.warn(`[migrate v1→v2] Failed to write migrated config: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-async function updateRepositories(changes, workspacePath = process.cwd()) {
-  if (changes.remove.length === 0 && changes.add.length === 0) {
-    return { success: true };
-  }
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    const removeSet = new Set(changes.remove);
-    config.repositories = config.repositories.filter((repo) => !removeSet.has(repo.path));
-    config.repositories.push(...changes.add);
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function setRepositories(repositories, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  try {
-    const content = await readFile7(configPath, "utf-8");
-    const config = load(content);
-    config.repositories = repositories;
-    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+  if (!dryRun && repositories.length > 0) {
+    for (const agentFile of copiedAgentFiles) {
+      const targetPath = join12(workspacePath, agentFile);
+      try {
+        await ensureWorkspaceRules(targetPath, repositories, skillsIndexRefs);
+      } catch (error) {
+        results.push({
+          source: "WORKSPACE-RULES",
+          destination: targetPath,
+          action: "failed",
+          error: error instanceof Error ? error.message : "Failed to inject WORKSPACE-RULES"
+        });
+      }
+    }
   }
+  return results;
 }
-var DEFAULT_PROJECT_CLIENTS;
-var init_workspace_modify = __esm(() => {
-  init_js_yaml();
+var import_micromatch, AGENT_FILES2;
+var init_transform = __esm(() => {
+  init_glob_patterns();
+  init_client_mapping();
   init_constants();
-  init_workspace_config();
-  init_marketplace_manifest_parser();
   init_plugin_path();
-  init_marketplace();
-  DEFAULT_PROJECT_CLIENTS = ["universal"];
+  init_symlink();
+  init_link_adjuster();
+  init_skill();
+  init_skills();
+  import_micromatch = __toESM(require_micromatch(), 1);
+  AGENT_FILES2 = ["AGENTS.md", "CLAUDE.md"];
 });
 
 // src/core/repo-skills.ts
-import { existsSync as existsSync9, lstatSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { readdir as readdir4, readFile as readFile8 } from "node:fs/promises";
-import { basename as basename5, join as join12, relative as relative3, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync10, lstatSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { readdir as readdir5, readFile as readFile9 } from "node:fs/promises";
+import { basename as basename6, join as join13, relative as relative3, resolve as resolve9 } from "node:path";
 async function discoverRepoSkills(repoPath, options2) {
   if (options2.disabled)
     return [];
@@ -28476,19 +28768,19 @@ async function discoverRepoSkills(repoPath, options2) {
   const results = [];
   const seen = new Set;
   for (const skillDir of skillDirs) {
-    const absDir = join12(repoPath, skillDir);
-    if (!existsSync9(absDir))
+    const absDir = join13(repoPath, skillDir);
+    if (!existsSync10(absDir))
       continue;
     let entries;
     try {
-      entries = await readdir4(absDir, { withFileTypes: true });
+      entries = await readdir5(absDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const entryPath = join12(absDir, entry.name);
+      const entryPath = join13(absDir, entry.name);
       try {
         const stat2 = lstatSync(entryPath);
         if (stat2.isSymbolicLink())
@@ -28496,14 +28788,14 @@ async function discoverRepoSkills(repoPath, options2) {
       } catch {
         continue;
       }
-      const skillMdPath = join12(entryPath, "SKILL.md");
-      if (!existsSync9(skillMdPath))
+      const skillMdPath = join13(entryPath, "SKILL.md");
+      if (!existsSync10(skillMdPath))
         continue;
       const relPath = relative3(repoPath, skillMdPath);
       if (seen.has(relPath))
         continue;
       try {
-        const content = await readFile8(skillMdPath, "utf-8");
+        const content = await readFile9(skillMdPath, "utf-8");
         const metadata = parseSkillMetadata(content);
         if (!metadata)
           continue;
@@ -28524,7 +28816,7 @@ async function discoverWorkspaceSkills(workspacePath, repositories, clientNames)
   for (const repo of repositories) {
     if (repo.skills === false || repo.skills === undefined)
       continue;
-    const repoAbsPath = resolve8(workspacePath, repo.path);
+    const repoAbsPath = resolve9(workspacePath, repo.path);
     const discoverOpts = Array.isArray(repo.skills) ? { skillPaths: repo.skills } : { clients: clientNames };
     const repoSkills = await discoverRepoSkills(repoAbsPath, discoverOpts);
     for (const skill of repoSkills) {
@@ -28556,7 +28848,7 @@ async function discoverWorkspaceSkills(workspacePath, repositories, clientNames)
 function writeSkillsIndex(workspacePath, skillsByRepo) {
   if (skillsByRepo.size === 0)
     return { writtenFiles: [], refs: [] };
-  const indexDir = join12(workspacePath, ".allagents", "skills-index");
+  const indexDir = join13(workspacePath, ".allagents", "skills-index");
   mkdirSync(indexDir, { recursive: true });
   const writtenFiles = [];
   const refs = [];
@@ -28574,15 +28866,15 @@ ${skillEntries}
 </available_skills>
 `;
     const filePath = `skills-index/${repoName}.md`;
-    writeFileSync(join12(indexDir, `${repoName}.md`), content, "utf-8");
+    writeFileSync(join13(indexDir, `${repoName}.md`), content, "utf-8");
     writtenFiles.push(filePath);
     refs.push({ repoName, indexPath: `.allagents/${filePath}` });
   }
   return { writtenFiles, refs };
 }
 function cleanupSkillsIndex(workspacePath, currentFiles) {
-  const indexDir = join12(workspacePath, ".allagents", "skills-index");
-  if (!existsSync9(indexDir))
+  const indexDir = join13(workspacePath, ".allagents", "skills-index");
+  if (!existsSync10(indexDir))
     return;
   const currentSet = new Set(currentFiles.map((f) => f.replace("skills-index/", "")));
   let entries;
@@ -28593,7 +28885,7 @@ function cleanupSkillsIndex(workspacePath, currentFiles) {
   }
   for (const entry of entries) {
     if (!currentSet.has(entry)) {
-      rmSync(join12(indexDir, entry), { force: true });
+      rmSync(join13(indexDir, entry), { force: true });
     }
   }
   try {
@@ -28606,11 +28898,11 @@ function cleanupSkillsIndex(workspacePath, currentFiles) {
 function groupSkillsByRepo(skills, repositories) {
   const repoNameMap = new Map;
   for (const repo of repositories) {
-    repoNameMap.set(repo.path, repo.name ?? basename5(repo.path));
+    repoNameMap.set(repo.path, repo.name ?? basename6(repo.path));
   }
   const grouped = new Map;
   for (const skill of skills) {
-    const repoName = repoNameMap.get(skill.repoPath) ?? basename5(skill.repoPath);
+    const repoName = repoNameMap.get(skill.repoPath) ?? basename6(skill.repoPath);
     const existing = grouped.get(skill.repoPath);
     if (existing) {
       existing.skills.push(skill);
@@ -28626,9 +28918,9 @@ var init_repo_skills = __esm(() => {
 });
 
 // src/core/workspace-repo.ts
-import { readFile as readFile9, writeFile as writeFile5 } from "node:fs/promises";
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join13 } from "node:path";
+import { readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join14 } from "node:path";
 async function detectRemote(repoPath) {
   try {
     const env2 = { ...process.env };
@@ -28670,10 +28962,10 @@ function normalizePath(p) {
 }
 async function addRepository(path, options2 = {}, workspacePath = process.cwd()) {
   const normalizedPath = normalizePath(path);
-  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const configPath = join14(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
   await ensureWorkspace(workspacePath);
   try {
-    const content = await readFile9(configPath, "utf-8");
+    const content = await readFile10(configPath, "utf-8");
     const config = load(content);
     if (config.repositories.some((r) => normalizePath(r.path) === normalizedPath)) {
       return { success: false, error: `Repository already exists: ${normalizedPath}` };
@@ -28693,8 +28985,8 @@ async function addRepository(path, options2 = {}, workspacePath = process.cwd())
   }
 }
 async function removeRepository(path, workspacePath = process.cwd()) {
-  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync10(configPath)) {
+  const configPath = join14(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync11(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -28702,7 +28994,7 @@ async function removeRepository(path, workspacePath = process.cwd()) {
     };
   }
   try {
-    const content = await readFile9(configPath, "utf-8");
+    const content = await readFile10(configPath, "utf-8");
     const config = load(content);
     const normalizedPath = normalizePath(path);
     const index = config.repositories.findIndex((r) => normalizePath(r.path) === normalizedPath);
@@ -28717,11 +29009,11 @@ async function removeRepository(path, workspacePath = process.cwd()) {
   }
 }
 async function listRepositories(workspacePath = process.cwd()) {
-  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync10(configPath))
+  const configPath = join14(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync11(configPath))
     return [];
   try {
-    const content = await readFile9(configPath, "utf-8");
+    const content = await readFile10(configPath, "utf-8");
     const config = load(content);
     return config.repositories ?? [];
   } catch {
@@ -28732,10 +29024,10 @@ function resolveClientNames(clients) {
   return (clients ?? []).map((c) => typeof c === "string" ? c : c.name);
 }
 async function updateAgentFiles(workspacePath = process.cwd()) {
-  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync10(configPath))
+  const configPath = join14(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync11(configPath))
     return;
-  const content = await readFile9(configPath, "utf-8");
+  const content = await readFile10(configPath, "utf-8");
   const config = load(content);
   if (config.repositories.length === 0)
     return;
@@ -28753,7 +29045,7 @@ async function updateAgentFiles(workspacePath = process.cwd()) {
   }
   agentFiles.add("AGENTS.md");
   for (const agentFile of agentFiles) {
-    await ensureWorkspaceRules(join13(workspacePath, agentFile), config.repositories, skillsIndexRefs);
+    await ensureWorkspaceRules(join14(workspacePath, agentFile), config.repositories, skillsIndexRefs);
   }
 }
 var init_workspace_repo = __esm(() => {
@@ -28937,14 +29229,14 @@ var init_sync_state = __esm(() => {
 });
 
 // src/core/config-gitignore.ts
-import { writeFile as writeFile6, readFile as readFile10 } from "node:fs/promises";
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join14 } from "node:path";
+import { writeFile as writeFile6, readFile as readFile11 } from "node:fs/promises";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join15 } from "node:path";
 async function ensureConfigGitignore(workspacePath) {
-  const gitignorePath = join14(workspacePath, CONFIG_DIR, ".gitignore");
+  const gitignorePath = join15(workspacePath, CONFIG_DIR, ".gitignore");
   let existing = "";
-  if (existsSync11(gitignorePath)) {
-    existing = await readFile10(gitignorePath, "utf-8");
+  if (existsSync12(gitignorePath)) {
+    existing = await readFile11(gitignorePath, "utf-8");
   }
   const missing = GITIGNORE_ENTRIES.filter((entry) => !existing.split(`
 `).includes(entry));
@@ -28965,19 +29257,19 @@ var init_config_gitignore = __esm(() => {
 });
 
 // src/core/sync-state.ts
-import { readFile as readFile11, writeFile as writeFile7, mkdir as mkdir7 } from "node:fs/promises";
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join15, dirname as dirname6 } from "node:path";
+import { readFile as readFile12, writeFile as writeFile7, mkdir as mkdir7 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join16, dirname as dirname6 } from "node:path";
 function getSyncStatePath(workspacePath) {
-  return join15(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
+  return join16(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
 }
 async function loadSyncState(workspacePath) {
   const statePath = getSyncStatePath(workspacePath);
-  if (!existsSync12(statePath)) {
+  if (!existsSync13(statePath)) {
     return null;
   }
   try {
-    const content = await readFile11(statePath, "utf-8");
+    const content = await readFile12(statePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = SyncStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -29052,12 +29344,12 @@ var init_sync_state2 = __esm(() => {
 
 // src/core/vscode-workspace.ts
 import { createHash as createHash2 } from "node:crypto";
-import { resolve as resolve9, basename as basename6, isAbsolute as isAbsolute3, relative as relative4 } from "node:path";
+import { resolve as resolve10, basename as basename7, isAbsolute as isAbsolute3, relative as relative4 } from "node:path";
 function normalizeWorkspacePath(path) {
   return path.replace(/\\/g, "/");
 }
 function resolveFolderAbsolutePath(workspacePath, folderPath) {
-  return (isAbsolute3(folderPath) ? folderPath : resolve9(workspacePath, folderPath)).replace(/\\/g, "/");
+  return (isAbsolute3(folderPath) ? folderPath : resolve10(workspacePath, folderPath)).replace(/\\/g, "/");
 }
 function resolveFolderDisplayPath(folderPath) {
   return normalizeWorkspacePath(folderPath);
@@ -29065,7 +29357,7 @@ function resolveFolderDisplayPath(folderPath) {
 function buildPathPlaceholderMap(repositories, workspacePath) {
   const map2 = new Map;
   for (const repo of repositories) {
-    const absolutePath = resolve9(workspacePath, repo.path);
+    const absolutePath = resolve10(workspacePath, repo.path);
     map2.set(repo.path, absolutePath);
   }
   return map2;
@@ -29100,7 +29392,7 @@ function generateVscodeWorkspace(input) {
   const folders = [];
   const seenPaths = new Set;
   folders.push({ path: "." });
-  seenPaths.add(resolve9(workspacePath, "."));
+  seenPaths.add(resolve10(workspacePath, "."));
   for (const repo of repositories) {
     const absolutePath = resolveFolderAbsolutePath(workspacePath, repo.path);
     const entry = { path: resolveFolderDisplayPath(repo.path) };
@@ -29142,22 +29434,22 @@ function getWorkspaceOutputPath(workspacePath, vscodeConfig) {
   const name = vscodeConfig?.output;
   if (name) {
     const filename = name.endsWith(".code-workspace") ? name : `${name}.code-workspace`;
-    return resolve9(workspacePath, filename);
+    return resolve10(workspacePath, filename);
   }
-  const dirName = basename6(resolve9(workspacePath));
-  return resolve9(workspacePath, `${dirName}.code-workspace`);
+  const dirName = basename7(resolve10(workspacePath));
+  return resolve10(workspacePath, `${dirName}.code-workspace`);
 }
 function computeWorkspaceHash(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function reconcileVscodeWorkspaceFolders(workspacePath, codeWorkspaceFolders, lastSyncedRepos, currentRepos) {
-  const normalizedWorkspacePath = resolve9(workspacePath).replace(/\\/g, "/");
+  const normalizedWorkspacePath = resolve10(workspacePath).replace(/\\/g, "/");
   const codeWorkspaceAbsPaths = new Set;
   const codeWorkspaceNames = new Map;
   for (const folder of codeWorkspaceFolders) {
     if (folder.path === ".")
       continue;
-    const absPath = (isAbsolute3(folder.path) ? folder.path : resolve9(workspacePath, folder.path)).replace(/\\/g, "/");
+    const absPath = (isAbsolute3(folder.path) ? folder.path : resolve10(workspacePath, folder.path)).replace(/\\/g, "/");
     codeWorkspaceAbsPaths.add(absPath);
     if (folder.name)
       codeWorkspaceNames.set(absPath, folder.name);
@@ -29165,7 +29457,7 @@ function reconcileVscodeWorkspaceFolders(workspacePath, codeWorkspaceFolders, la
   const lastSyncedSet = new Set(lastSyncedRepos.map((p) => p.replace(/\\/g, "/")));
   const currentReposByAbsPath = new Map;
   for (const repo of currentRepos) {
-    const absPath = resolve9(workspacePath, repo.path).replace(/\\/g, "/");
+    const absPath = resolve10(workspacePath, repo.path).replace(/\\/g, "/");
     currentReposByAbsPath.set(absPath, repo);
   }
   const currentAbsPaths = new Set(currentReposByAbsPath.keys());
@@ -29216,8 +29508,8 @@ var init_vscode_workspace = __esm(() => {
 });
 
 // src/core/vscode-mcp.ts
-import { existsSync as existsSync13, readFileSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join16, dirname as dirname7 } from "node:path";
+import { existsSync as existsSync14, readFileSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join17, dirname as dirname7 } from "node:path";
 function deepEqual(a, b) {
   if (a === b)
     return true;
@@ -29249,17 +29541,17 @@ function getVscodeMcpConfigPath() {
     if (!appData) {
       throw new Error("APPDATA environment variable not set");
     }
-    return join16(appData, "Code", "User", "mcp.json");
+    return join17(appData, "Code", "User", "mcp.json");
   }
   const home = getHomeDir();
   if (platform2 === "darwin") {
-    return join16(home, "Library", "Application Support", "Code", "User", "mcp.json");
+    return join17(home, "Library", "Application Support", "Code", "User", "mcp.json");
   }
-  return join16(home, ".config", "Code", "User", "mcp.json");
+  return join17(home, ".config", "Code", "User", "mcp.json");
 }
 function readPluginMcpConfig(pluginPath) {
-  const mcpPath = join16(pluginPath, ".mcp.json");
-  if (!existsSync13(mcpPath)) {
+  const mcpPath = join17(pluginPath, ".mcp.json");
+  if (!existsSync14(mcpPath)) {
     return null;
   }
   try {
@@ -29325,7 +29617,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingConfig = {};
-  if (existsSync13(configPath)) {
+  if (existsSync14(configPath)) {
     try {
       const content = readFileSync(configPath, "utf-8");
       existingConfig = import_json5.default.parse(content);
@@ -29376,7 +29668,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
   if (hasChanges && !dryRun) {
     existingConfig.servers = existingServers;
     const dir = dirname7(configPath);
-    if (!existsSync13(dir)) {
+    if (!existsSync14(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     writeFileSync2(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29394,7 +29686,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
     if (result.removed > 0 && !dryRun) {
       existingConfig.servers = existingServers;
       const dir = dirname7(configPath);
-      if (!existsSync13(dir)) {
+      if (!existsSync14(dir)) {
         mkdirSync2(dir, { recursive: true });
       }
       writeFileSync2(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29451,7 +29743,7 @@ function applyMcpProxy(servers, client, config) {
 // src/core/native/types.ts
 import { spawn as spawn2 } from "node:child_process";
 function executeCommand(binary2, args, options2 = {}) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const proc = spawn2(binary2, args, {
       cwd: options2.cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -29472,7 +29764,7 @@ function executeCommand(binary2, args, options2 = {}) {
         return;
       resolved = true;
       const trimmedStderr = stderr.trim();
-      resolve10({
+      resolve11({
         success: code === 0,
         output: stdout.trim(),
         ...trimmedStderr && { error: trimmedStderr }
@@ -29482,7 +29774,7 @@ function executeCommand(binary2, args, options2 = {}) {
       if (resolved)
         return;
       resolved = true;
-      resolve10({
+      resolve11({
         success: false,
         output: "",
         error: `Failed to execute ${binary2} CLI: ${err.message}`
@@ -29501,7 +29793,7 @@ function mergeNativeSyncResults(results) {
 var init_types2 = () => {};
 
 // src/core/codex-mcp.ts
-import { existsSync as existsSync14, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
 import { dirname as dirname8 } from "node:path";
 function buildCodexMcpAddArgs(name, config) {
   if (typeof config.url === "string") {
@@ -29712,7 +30004,7 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingContent = "";
-  if (existsSync14(configPath)) {
+  if (existsSync15(configPath)) {
     try {
       existingContent = readFileSync2(configPath, "utf-8");
     } catch {
@@ -29768,7 +30060,7 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
 `)}
 `;
     const dir = dirname8(configPath);
-    if (!existsSync14(dir)) {
+    if (!existsSync15(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     writeFileSync3(configPath, output, "utf-8");
@@ -29782,7 +30074,7 @@ var init_codex_mcp = __esm(() => {
 });
 
 // src/core/claude-mcp.ts
-import { existsSync as existsSync15, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 function deepEqual2(a, b) {
   if (a === b)
@@ -29850,7 +30142,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingConfig = {};
-  if (existsSync15(configPath)) {
+  if (existsSync16(configPath)) {
     try {
       const content = readFileSync3(configPath, "utf-8");
       existingConfig = import_json52.default.parse(content);
@@ -29901,7 +30193,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
   if (hasChanges && !dryRun) {
     existingConfig.mcpServers = existingServers;
     const dir = dirname9(configPath);
-    if (!existsSync15(dir)) {
+    if (!existsSync16(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
     writeFileSync4(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29919,7 +30211,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     if (result.removed > 0 && !dryRun) {
       existingConfig.mcpServers = existingServers;
       const dir = dirname9(configPath);
-      if (!existsSync15(dir)) {
+      if (!existsSync16(dir)) {
         mkdirSync4(dir, { recursive: true });
       }
       writeFileSync4(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -30018,41 +30310,41 @@ var init_claude_mcp = __esm(() => {
 });
 
 // src/core/copilot-mcp.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function getCopilotMcpConfigPath() {
-  return join17(getHomeDir(), ".copilot", "mcp-config.json");
+  return join18(getHomeDir(), ".copilot", "mcp-config.json");
 }
 var init_copilot_mcp = __esm(() => {
   init_constants();
 });
 
 // src/core/mcp-sync.ts
-import { existsSync as existsSync16 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { join as join19 } from "node:path";
 function buildSyncSpecs(workspacePath) {
   return [
     {
       client: "vscode",
       scope: "vscode",
-      configPath: join18(workspacePath, ".vscode", "mcp.json"),
+      configPath: join19(workspacePath, ".vscode", "mcp.json"),
       syncFn: syncVscodeMcpConfig
     },
     {
       client: "claude",
       scope: "claude",
-      configPath: join18(workspacePath, ".mcp.json"),
+      configPath: join19(workspacePath, ".mcp.json"),
       syncFn: syncClaudeMcpConfig
     },
     {
       client: "codex",
       scope: "codex",
-      configPath: join18(workspacePath, ".codex", "config.toml"),
+      configPath: join19(workspacePath, ".codex", "config.toml"),
       syncFn: syncCodexProjectMcpConfig
     },
     {
       client: "copilot",
       scope: "copilot",
-      configPath: join18(workspacePath, ".copilot", "mcp-config.json"),
+      configPath: join19(workspacePath, ".copilot", "mcp-config.json"),
       syncFn: syncClaudeMcpConfig
     }
   ];
@@ -30107,8 +30399,8 @@ function syncMcpServers(workspacePath, validPlugins, config, previousState, sync
 async function syncMcpOnly(workspacePath = process.cwd(), options2 = {}) {
   const { offline = false, dryRun = false } = options2;
   await migrateWorkspaceSkillsV1toV2(workspacePath);
-  const configPath = join18(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync16(configPath)) {
+  const configPath = join19(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync17(configPath)) {
     return {
       success: false,
       mcpResults: {},
@@ -30482,9 +30774,9 @@ function padStart2(str3, len) {
 }
 
 // src/core/managed-repos.ts
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve10 } from "node:path";
+import { dirname as dirname10, resolve as resolve11 } from "node:path";
 function expandHome(p) {
   if (p.startsWith("~/") || p === "~") {
     return p.replace("~", getHomeDir());
@@ -30565,8 +30857,8 @@ async function processManagedRepos(repositories, workspacePath, options2 = {}) {
       continue;
     }
     const expandedPath = expandHome(repo.path);
-    const absolutePath = resolve10(workspacePath, expandedPath);
-    if (!existsSync17(absolutePath)) {
+    const absolutePath = resolve11(workspacePath, expandedPath);
+    if (!existsSync18(absolutePath)) {
       if (!shouldClone(repo.managed)) {
         results.push({ path: repo.path, repo: repo.repo, action: "skipped" });
         continue;
@@ -30617,9 +30909,9 @@ var init_managed_repos = __esm(() => {
 });
 
 // src/core/sync.ts
-import { existsSync as existsSync18, readFileSync as readFileSync4, writeFileSync as writeFileSync5, lstatSync as lstatSync2 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync4, writeFileSync as writeFileSync5, lstatSync as lstatSync2 } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
-import { join as join19, resolve as resolve11, dirname as dirname11, relative as relative5 } from "node:path";
+import { join as join20, resolve as resolve12, dirname as dirname11, relative as relative5 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -30782,7 +31074,7 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join19(workspacePath, filePath);
+      const fullPath = join20(workspacePath, filePath);
       const cleanPath = fullPath.replace(/\/$/, "");
       let stats;
       try {
@@ -30811,8 +31103,8 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
 async function cleanupEmptyParents(workspacePath, filePath) {
   let parentPath = dirname11(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join19(workspacePath, parentPath);
-    if (!existsSync18(fullParentPath)) {
+    const fullParentPath = join20(workspacePath, parentPath);
+    if (!existsSync19(fullParentPath)) {
       parentPath = dirname11(parentPath);
       continue;
     }
@@ -30897,8 +31189,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join19(defaultSourcePath, file);
-      if (!existsSync18(fullPath)) {
+      const fullPath = join20(defaultSourcePath, file);
+      if (!existsSync19(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -30916,8 +31208,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join19(cachePath, parsed.filePath);
-        if (!existsSync18(fullPath)) {
+        const fullPath = join20(cachePath, parsed.filePath);
+        if (!existsSync19(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -30925,13 +31217,13 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         if (file.source.startsWith("/")) {
           fullPath = file.source;
         } else if (file.source.startsWith("../")) {
-          fullPath = resolve11(file.source);
+          fullPath = resolve12(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join19(defaultSourcePath, file.source);
+          fullPath = join20(defaultSourcePath, file.source);
         } else {
-          fullPath = resolve11(file.source);
+          fullPath = resolve12(file.source);
         }
-        if (!existsSync18(fullPath)) {
+        if (!existsSync19(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -30940,8 +31232,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file.dest}' - no workspace.source configured and no explicit source provided`);
         continue;
       }
-      const fullPath = join19(defaultSourcePath, file.dest ?? "");
-      if (!existsSync18(fullPath)) {
+      const fullPath = join20(defaultSourcePath, file.dest ?? "");
+      if (!existsSync19(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -31089,7 +31381,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join19(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join20(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
@@ -31098,8 +31390,8 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
       nativeClients: []
     };
   }
-  const resolvedPath = resolve11(workspacePath, pluginSource);
-  if (!existsSync18(resolvedPath)) {
+  const resolvedPath = resolve12(workspacePath, pluginSource);
+  if (!existsSync19(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -31272,10 +31564,10 @@ function buildPluginSkillNameMaps(allSkills) {
   return pluginMaps;
 }
 function generateVscodeWorkspaceFile(workspacePath, config) {
-  const configDir = join19(workspacePath, CONFIG_DIR);
-  const templatePath = join19(configDir, VSCODE_TEMPLATE_FILE);
+  const configDir = join20(workspacePath, CONFIG_DIR);
+  const templatePath = join20(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync18(templatePath)) {
+  if (existsSync19(templatePath)) {
     try {
       template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
     } catch (error) {
@@ -31427,7 +31719,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync18(outputPath)) {
+    if (existsSync19(outputPath)) {
       const existingContent = readFileSync4(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
@@ -31460,7 +31752,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   }
   const writtenContent = generateVscodeWorkspaceFile(workspacePath, updatedConfig);
   const hash = computeWorkspaceHash(writtenContent);
-  const repos = updatedConfig.repositories.map((r) => resolve11(workspacePath, r.path).replace(/\\/g, "/"));
+  const repos = updatedConfig.repositories.map((r) => resolve12(workspacePath, r.path).replace(/\\/g, "/"));
   return { config: updatedConfig, hash, repos };
 }
 async function buildSourcesProvenance(validatedPlugins, pluginEntries) {
@@ -31542,9 +31834,9 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
     skipManaged = false
   } = options2;
   const sw = new Stopwatch;
-  const configDir = join19(workspacePath, CONFIG_DIR);
-  const configPath = join19(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync18(configPath)) {
+  const configDir = join20(workspacePath, CONFIG_DIR);
+  const configPath = join20(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync19(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -31641,8 +31933,8 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     const filesToCopy = [...config.workspace.files];
     if (hasRepositories && sourcePath) {
       for (const agentFile of AGENT_FILES) {
-        const agentPath = join19(sourcePath, agentFile);
-        if (existsSync18(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join20(sourcePath, agentFile);
+        if (existsSync19(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -31682,10 +31974,10 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       skillsIndexRefs
     });
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
-      const claudePath = join19(workspacePath, "CLAUDE.md");
-      const agentsPath = join19(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync18(join19(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync18(agentsPath) && !existsSync18(claudePath)) {
+      const claudePath = join20(workspacePath, "CLAUDE.md");
+      const agentsPath = join20(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync19(join20(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync19(agentsPath) && !existsSync19(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -31769,7 +32061,7 @@ async function seedFetchCacheFromMarketplaces(results) {
 }
 function readGitBranch(repoPath) {
   try {
-    const head = readFileSync4(join19(repoPath, ".git", "HEAD"), "utf-8").trim();
+    const head = readFileSync4(join20(repoPath, ".git", "HEAD"), "utf-8").trim();
     const prefix = "ref: refs/heads/";
     return head.startsWith(prefix) ? head.slice(prefix.length) : null;
   } catch {
@@ -31779,7 +32071,7 @@ function readGitBranch(repoPath) {
 async function syncUserWorkspace(options2 = {}) {
   await migrateUserWorkspaceSkillsV1toV2();
   const sw = new Stopwatch;
-  const homeDir = resolve11(getHomeDir());
+  const homeDir = resolve12(getHomeDir());
   const config = await getUserWorkspaceConfig();
   if (!config) {
     return {
@@ -31977,11 +32269,11 @@ var init_sync = __esm(() => {
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync19, readFileSync as readFileSync5 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync5 } from "node:fs";
+import { join as join21 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
-  const fullPath = join20(tempDir, filePath);
-  if (existsSync19(fullPath)) {
+  const fullPath = join21(tempDir, filePath);
+  if (existsSync20(fullPath)) {
     return readFileSync5(fullPath, "utf-8");
   }
   return null;
@@ -32080,15 +32372,15 @@ var init_github_fetch = __esm(() => {
 });
 
 // src/core/workspace.ts
-import { cp as cp2, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile8, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join21, resolve as resolve12, dirname as dirname12, relative as relative6, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
+import { cp as cp2, mkdir as mkdir9, readFile as readFile13, writeFile as writeFile8, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join22, resolve as resolve13, dirname as dirname12, relative as relative6, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
-  const absoluteTarget = resolve12(targetPath);
-  const configDir = join21(absoluteTarget, CONFIG_DIR);
-  const configPath = join21(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync20(configPath)) {
+  const absoluteTarget = resolve13(targetPath);
+  const configDir = join22(absoluteTarget, CONFIG_DIR);
+  const configPath = join22(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync21(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -32099,7 +32391,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   const currentFilePath = fileURLToPath(import.meta.url);
   const currentFileDir = dirname12(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
-  const defaultTemplatePath = isProduction ? join21(currentFileDir, "templates", "default") : join21(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join22(currentFileDir, "templates", "default") : join22(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   let parsedFromUrl;
   let githubBasePath = "";
@@ -32138,20 +32430,20 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
-        const fromPath = resolve12(options2.from);
-        if (!existsSync20(fromPath)) {
+        const fromPath = resolve13(options2.from);
+        if (!existsSync21(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
         const fromStat = await stat2(fromPath);
         let sourceYamlPath;
         if (fromStat.isDirectory()) {
-          const nestedPath = join21(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join21(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync20(nestedPath)) {
+          const nestedPath = join22(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join22(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync21(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync20(rootPath)) {
+          } else if (existsSync21(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -32167,14 +32459,14 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             sourceDir = parentDir;
           }
         }
-        workspaceYamlContent = await readFile12(sourceYamlPath, "utf-8");
+        workspaceYamlContent = await readFile13(sourceYamlPath, "utf-8");
         if (sourceDir) {
           const parsed2 = load(workspaceYamlContent);
           const workspace = parsed2?.workspace;
           if (workspace?.source) {
             const source = workspace.source;
             if (!isGitHubUrl(source) && !isAbsolute4(source)) {
-              workspace.source = resolve12(sourceDir, source);
+              workspace.source = resolve13(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
           }
@@ -32182,11 +32474,11 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join21(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync20(defaultYamlPath)) {
+      const defaultYamlPath = join22(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync21(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
-      workspaceYamlContent = await readFile12(defaultYamlPath, "utf-8");
+      workspaceYamlContent = await readFile13(defaultYamlPath, "utf-8");
     }
     if (options2.clients && options2.clients.length > 0) {
       const configParsed = load(workspaceYamlContent);
@@ -32199,8 +32491,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     const clientNames = getClientTypes(clients);
     const VSCODE_TEMPLATE_FILE2 = "template.code-workspace";
     if (clientNames.includes("vscode") && options2.from) {
-      const targetTemplatePath = join21(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync20(targetTemplatePath)) {
+      const targetTemplatePath = join22(configDir, VSCODE_TEMPLATE_FILE2);
+      if (!existsSync21(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
@@ -32210,8 +32502,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             }
           }
         } else if (sourceDir) {
-          const sourceTemplatePath = join21(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync20(sourceTemplatePath)) {
+          const sourceTemplatePath = join22(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
+          if (existsSync21(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -32224,8 +32516,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       if (options2.from && isGitHubUrl(options2.from) && githubTempDir) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
-            const targetFilePath = join21(absoluteTarget, agentFile);
-            if (existsSync20(targetFilePath)) {
+            const targetFilePath = join22(absoluteTarget, agentFile);
+            if (existsSync21(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
@@ -32240,30 +32532,30 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       } else {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
-          const targetFilePath = join21(absoluteTarget, agentFile);
-          if (existsSync20(targetFilePath)) {
+          const targetFilePath = join22(absoluteTarget, agentFile);
+          if (existsSync21(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
-          const sourcePath = join21(effectiveSourceDir, agentFile);
-          if (existsSync20(sourcePath)) {
-            const content = await readFile12(sourcePath, "utf-8");
+          const sourcePath = join22(effectiveSourceDir, agentFile);
+          if (existsSync21(sourcePath)) {
+            const content = await readFile13(sourcePath, "utf-8");
             await writeFile8(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
           }
         }
       }
       if (copiedAgentFiles.length === 0) {
-        await ensureWorkspaceRules(join21(absoluteTarget, "AGENTS.md"), repositories);
+        await ensureWorkspaceRules(join22(absoluteTarget, "AGENTS.md"), repositories);
         copiedAgentFiles.push("AGENTS.md");
       } else {
         for (const agentFile of copiedAgentFiles) {
-          await ensureWorkspaceRules(join21(absoluteTarget, agentFile), repositories);
+          await ensureWorkspaceRules(join22(absoluteTarget, agentFile), repositories);
         }
       }
       if (clientNames.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-        const agentsPath = join21(absoluteTarget, "AGENTS.md");
-        const claudePath = join21(absoluteTarget, "CLAUDE.md");
+        const agentsPath = join22(absoluteTarget, "AGENTS.md");
+        const claudePath = join22(absoluteTarget, "CLAUDE.md");
         await copyFile2(agentsPath, claudePath);
       }
     }
@@ -32308,14 +32600,14 @@ Next steps:`);
 async function seedCacheFromClone(tempDir, owner, repo, branch) {
   const cachePaths = [
     getPluginCachePath(owner, repo, branch),
-    join21(getMarketplacesDir(), repo)
+    join22(getMarketplacesDir(), repo)
   ];
   for (const cachePath of cachePaths) {
-    if (existsSync20(cachePath))
+    if (existsSync21(cachePath))
       continue;
     try {
       const parentDir = dirname12(cachePath);
-      if (!existsSync20(parentDir)) {
+      if (!existsSync21(parentDir)) {
         await mkdir9(parentDir, { recursive: true });
       }
       await cp2(tempDir, cachePath, { recursive: true });
@@ -32336,11 +32628,11 @@ var init_workspace = __esm(() => {
 });
 
 // src/core/status.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join23 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
-  const configPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync21(configPath) || isUserConfigPath(workspacePath)) {
+  const configPath = join23(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync22(configPath) || isUserConfigPath(workspacePath)) {
     const userPlugins = await getUserPluginStatuses();
     return {
       success: true,
@@ -32382,7 +32674,7 @@ async function getWorkspaceStatus(workspacePath = process.cwd()) {
 function getPluginStatus(parsed) {
   if (parsed.type === "github") {
     const cachePath = parsed.owner && parsed.repo ? getPluginCachePath(parsed.owner, parsed.repo) : "";
-    const available2 = cachePath ? existsSync21(cachePath) : false;
+    const available2 = cachePath ? existsSync22(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -32392,7 +32684,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync21(parsed.normalized);
+  const available = existsSync22(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -34553,160 +34845,6 @@ var init_prompt_clients = __esm(() => {
   ({ autocompleteMultiselect } = exports_dist);
 });
 
-// src/core/skills.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { readFile as readFile14, readdir as readdir5 } from "node:fs/promises";
-import { join as join25, basename as basename7, resolve as resolve14 } from "node:path";
-async function resolvePluginPath(pluginSource, workspacePath) {
-  if (isPluginSpec(pluginSource)) {
-    const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource, {
-      offline: true,
-      workspacePath
-    });
-    if (!resolved2.success || !resolved2.path)
-      return null;
-    return {
-      path: resolved2.path,
-      pluginName: resolved2.pluginName
-    };
-  }
-  if (isGitHubUrl(pluginSource)) {
-    const parsed = parseGitHubUrl(pluginSource);
-    const result = await fetchPlugin(pluginSource, {
-      offline: true,
-      ...parsed?.branch && { branch: parsed.branch }
-    });
-    if (!result.success)
-      return null;
-    const path = parsed?.subpath ? join25(result.cachePath, parsed.subpath) : result.cachePath;
-    return { path };
-  }
-  const resolved = resolve14(workspacePath, pluginSource);
-  return existsSync24(resolved) ? { path: resolved } : null;
-}
-async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
-  const configPath = join25(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync24(configPath)) {
-    return [];
-  }
-  const content = await readFile14(configPath, "utf-8");
-  const config = load(content);
-  const isV1Fallback = config.version === undefined || config.version < 2;
-  const disabledSkills = isV1Fallback ? new Set(config.disabledSkills ?? []) : new Set;
-  const enabledSkills = isV1Fallback && config.enabledSkills ? new Set(config.enabledSkills) : null;
-  const skills = [];
-  for (const pluginEntry of config.plugins) {
-    const pluginSource = getPluginSource(pluginEntry);
-    const resolved = await resolvePluginPath(pluginSource, workspacePath);
-    if (!resolved)
-      continue;
-    const pluginPath = resolved.path;
-    const pluginName = resolved.pluginName ?? getPluginName(pluginPath);
-    const skillsDir = join25(pluginPath, "skills");
-    const pluginSkillsConfig = typeof pluginEntry === "string" ? undefined : pluginEntry.skills;
-    const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && [...enabledSkills].some((s) => s.startsWith(`${pluginName}`));
-    let skillEntries;
-    if (existsSync24(skillsDir)) {
-      const entries = await readdir5(skillsDir, { withFileTypes: true });
-      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join25(skillsDir, e.name) }));
-    } else {
-      const entries = await readdir5(pluginPath, { withFileTypes: true });
-      const flatSkills = [];
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        const skillMdPath = join25(pluginPath, entry.name, "SKILL.md");
-        if (existsSync24(skillMdPath)) {
-          flatSkills.push({ name: entry.name, skillPath: join25(pluginPath, entry.name) });
-        }
-      }
-      if (flatSkills.length > 0) {
-        skillEntries = flatSkills;
-      } else {
-        const rootSkillMd = join25(pluginPath, "SKILL.md");
-        if (existsSync24(rootSkillMd)) {
-          const skillContent = await readFile14(rootSkillMd, "utf-8");
-          const metadata = parseSkillMetadata(skillContent);
-          const skillName = metadata?.name ?? basename7(pluginPath);
-          skillEntries = [{ name: skillName, skillPath: pluginPath }];
-        } else {
-          skillEntries = [];
-        }
-      }
-    }
-    const pluginSkillsMode = pluginSkillsConfig === undefined ? "none" : Array.isArray(pluginSkillsConfig) ? "allowlist" : "blocklist";
-    for (const { name, skillPath } of skillEntries) {
-      const skillKey = `${pluginName}:${name}`;
-      let isDisabled;
-      if (pluginSkillsConfig !== undefined) {
-        if (Array.isArray(pluginSkillsConfig)) {
-          isDisabled = !pluginSkillsConfig.includes(name);
-        } else {
-          isDisabled = pluginSkillsConfig.exclude.includes(name);
-        }
-      } else if (isV1Fallback) {
-        isDisabled = hasEnabledEntries ? !enabledSkills?.has(skillKey) : disabledSkills.has(skillKey);
-      } else {
-        isDisabled = false;
-      }
-      skills.push({
-        name,
-        pluginName,
-        pluginSource,
-        path: skillPath,
-        disabled: isDisabled,
-        pluginSkillsMode
-      });
-    }
-  }
-  return skills;
-}
-async function findSkillByName(skillName, workspacePath = process.cwd()) {
-  const allSkills = await getAllSkillsFromPlugins(workspacePath);
-  return allSkills.filter((s) => s.name === skillName);
-}
-async function discoverSkillNames(pluginPath) {
-  if (!existsSync24(pluginPath))
-    return [];
-  const skillsDir = join25(pluginPath, "skills");
-  if (existsSync24(skillsDir)) {
-    const entries2 = await readdir5(skillsDir, { withFileTypes: true });
-    return entries2.filter((e) => e.isDirectory()).map((e) => e.name);
-  }
-  const entries = await readdir5(pluginPath, { withFileTypes: true });
-  const flatSkills = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    if (existsSync24(join25(pluginPath, entry.name, "SKILL.md"))) {
-      flatSkills.push(entry.name);
-    }
-  }
-  if (flatSkills.length > 0)
-    return flatSkills;
-  const rootSkillMd = join25(pluginPath, "SKILL.md");
-  if (existsSync24(rootSkillMd)) {
-    try {
-      const content = await readFile14(rootSkillMd, "utf-8");
-      const { parseSkillMetadata: parseSkillMetadata2 } = await Promise.resolve().then(() => (init_skill(), exports_skill));
-      const metadata = parseSkillMetadata2(content);
-      return [metadata?.name ?? basename7(pluginPath)];
-    } catch {
-      return [basename7(pluginPath)];
-    }
-  }
-  return [];
-}
-var init_skills = __esm(() => {
-  init_js_yaml();
-  init_constants();
-  init_workspace_config();
-  init_plugin();
-  init_plugin_path();
-  init_marketplace();
-  init_skill();
-});
-
 // src/core/skill-search.ts
 function validateSkillSearchArgs(query, options2) {
   if (query.trim().length < 2) {
@@ -34841,6 +34979,23 @@ async function runOneQuery(q3, page, limit, token, fetchFn) {
     truncated: Boolean(parsed.incomplete_results)
   };
 }
+async function fetchPrimaryPages(q3, page, limit, token, fetchFn) {
+  const needed = page * limit * 3;
+  const numPages = Math.min(Math.max(1, Math.ceil(needed / SEARCH_PAGE_SIZE)), MAX_RESULTS / SEARCH_PAGE_SIZE);
+  const items = [];
+  let total = 0;
+  let truncated = false;
+  for (let currentPage = 1;currentPage <= numPages; currentPage += 1) {
+    const result = await runOneQuery(q3, currentPage, SEARCH_PAGE_SIZE, token, fetchFn);
+    items.push(...result.items);
+    total = result.total;
+    truncated = truncated || result.truncated;
+    if (result.items.length < SEARCH_PAGE_SIZE) {
+      break;
+    }
+  }
+  return { items, total, truncated };
+}
 async function searchSkills(query, options2 = {}, deps = {}) {
   validateSkillSearchArgs(query, options2);
   const fetchFn = deps.fetch ?? fetch;
@@ -34850,7 +35005,7 @@ async function searchSkills(query, options2 = {}, deps = {}) {
   const limit = options2.limit ?? 15;
   const token = await (deps.tokenResolver ?? resolveGhToken)();
   const queries = buildSearchQueries(query, options2.owner);
-  const settled = await Promise.allSettled(queries.map((entry) => runOneQuery(entry.q, page, limit, token, fetchFn)));
+  const settled = await Promise.allSettled(queries.map((entry) => entry.priority === 4 ? fetchPrimaryPages(entry.q, page, limit, token, fetchFn) : runOneQuery(entry.q, 1, SEARCH_PAGE_SIZE, token, fetchFn)));
   const primaryIdx = queries.findIndex((q3) => q3.priority === 4);
   const primarySettled = settled[primaryIdx];
   if (primarySettled?.status === "rejected") {
@@ -34876,17 +35031,21 @@ async function searchSkills(query, options2 = {}, deps = {}) {
     const firstSegment = item.path.split("/")[0] ?? "";
     return !firstSegment.startsWith(".");
   });
+  rankByRelevance(visible, query);
+  const workingSet = truncateForProcessing(visible, page, limit);
   await Promise.all([
-    fetchStarsForItems(visible, token, fetchFn),
-    enrichDescriptionsForItems(visible, token, fetchFn)
+    fetchStarsForItems(workingSet, token, fetchFn),
+    enrichDescriptionsForItems(workingSet, token, fetchFn)
   ]);
-  visible.sort((a, b) => b.stars - a.stars);
-  const finalItems = visible.slice(0, limit);
+  const filtered = filterByRelevance(workingSet, query);
+  rankByRelevance(filtered, query);
+  const dedupedByName = deduplicateByName(filtered);
+  const { items: finalItems, totalPages } = paginate(dedupedByName, page, limit);
   return {
     query,
     items: finalItems,
-    total: finalItems.length,
-    truncated: buckets.some((b) => b.result.truncated) || visible.length > limit
+    total: dedupedByName.length,
+    truncated: buckets.some((b) => b.result.truncated) || totalPages > page
   };
 }
 function dedupeItems(items) {
@@ -34901,6 +35060,73 @@ function dedupeItems(items) {
   }
   return out;
 }
+function splitRepo(item) {
+  const [owner = item.repo, repoName = ""] = item.repo.split("/", 2);
+  return { owner, repoName };
+}
+function relevanceScore(item, query) {
+  const term = query.trim().toLowerCase();
+  const termHyphen = term.replace(/ /g, "-");
+  const name = item.name.toLowerCase();
+  const namespace = item.namespace.toLowerCase();
+  const description = item.description.toLowerCase();
+  let score = 0;
+  if (name === term || name === termHyphen) {
+    score += 3000;
+  } else if (name.includes(term) || name.includes(termHyphen)) {
+    score += 1000;
+  }
+  if (namespace?.includes(term)) {
+    score += 500;
+  }
+  if (description.includes(term)) {
+    score += 100;
+  }
+  if (item.stars > 0) {
+    score += Math.floor(Math.sqrt(item.stars) * 30);
+  }
+  return score;
+}
+function rankByRelevance(items, query) {
+  items.sort((a, b) => relevanceScore(b, query) - relevanceScore(a, query));
+}
+function filterByRelevance(items, query) {
+  const term = query.trim().toLowerCase();
+  const termHyphen = term.replace(/ /g, "-");
+  return items.filter((item) => {
+    const { owner, repoName } = splitRepo(item);
+    return item.name.toLowerCase().includes(term) || item.name.toLowerCase().includes(termHyphen) || item.namespace.toLowerCase().includes(term) || item.description.toLowerCase().includes(term) || owner.toLowerCase().includes(term) || repoName.toLowerCase().includes(term);
+  });
+}
+function truncateForProcessing(items, page, limit) {
+  const maxToProcess = Math.max(page * limit * 3, limit * 3);
+  return items.length > maxToProcess ? items.slice(0, maxToProcess) : items;
+}
+function deduplicateByName(items) {
+  const maxPerName = 3;
+  const counts = new Map;
+  const out = [];
+  for (const item of items) {
+    const key = qualifiedName(item).toLowerCase();
+    const count = counts.get(key) ?? 0;
+    if (count >= maxPerName)
+      continue;
+    counts.set(key, count + 1);
+    out.push(item);
+  }
+  return out;
+}
+function paginate(items, page, limit) {
+  if (items.length === 0) {
+    return { items: [], totalPages: 0 };
+  }
+  const totalPages = Math.ceil(items.length / limit);
+  const start = (page - 1) * limit;
+  return {
+    items: items.slice(start, start + limit),
+    totalPages
+  };
+}
 async function fetchStarsForItems(items, token, fetchFn) {
   const uniqueRepos = [...new Set(items.map((i2) => i2.repo))];
   const headers = buildGitHubApiHeaders(token);
@@ -34982,7 +35208,7 @@ function decodeGitBlob(content, encoding) {
     return;
   return Buffer.from(content.replace(/\s+/g, ""), "base64").toString("utf8");
 }
-var OWNER_REGEX, COULD_BE_OWNER_REGEX, ENRICHMENT_CONCURRENCY = 10, SkillSearchError;
+var OWNER_REGEX, SEARCH_PAGE_SIZE = 100, MAX_RESULTS = 1000, COULD_BE_OWNER_REGEX, ENRICHMENT_CONCURRENCY = 10, SkillSearchError;
 var init_skill_search = __esm(() => {
   init_skill();
   OWNER_REGEX = /^[A-Za-z0-9-]{1,39}$/;
@@ -41967,7 +42193,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.11.4-next.1",
+    version: "1.11.6-next.1",
     packageManager: "bun@1.3.12",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
@@ -43664,8 +43890,8 @@ init_workspace();
 init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync23 } from "node:fs";
-import { join as join24, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
+import { join as join25, resolve as resolve14 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -43673,9 +43899,9 @@ init_constants();
 init_marketplace();
 init_user_workspace();
 init_workspace_config();
-import { readFile as readFile13, writeFile as writeFile9 } from "node:fs/promises";
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join23 } from "node:path";
+import { readFile as readFile14, writeFile as writeFile9 } from "node:fs/promises";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join24 } from "node:path";
 async function isOrphanedPlugin(pluginSpec) {
   if (!isPluginSpec(pluginSpec))
     return false;
@@ -43702,9 +43928,9 @@ async function prunePlugins(plugins) {
 }
 async function pruneOrphanedPlugins(workspacePath) {
   let projectResult = { removed: [], kept: [], keptEntries: [] };
-  const projectConfigPath = join23(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (existsSync22(projectConfigPath) && !isUserConfigPath(workspacePath)) {
-    const content = await readFile13(projectConfigPath, "utf-8");
+  const projectConfigPath = join24(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (existsSync23(projectConfigPath) && !isUserConfigPath(workspacePath)) {
+    const content = await readFile14(projectConfigPath, "utf-8");
     const config = load(content);
     projectResult = await prunePlugins(config.plugins);
     if (projectResult.removed.length > 0) {
@@ -44090,8 +44316,8 @@ var syncCmd = import_cmd_ts2.command({
 `);
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
-      const projectConfigPath = join24(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync23(projectConfigPath);
+      const projectConfigPath = join25(process.cwd(), ".allagents", "workspace.yaml");
+      const projectConfigExists = existsSync24(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -44386,7 +44612,7 @@ var repoAddCmd = import_cmd_ts2.command({
   },
   handler: async ({ path: repoPath, description }) => {
     try {
-      const resolvedPath = resolve13(process.cwd(), repoPath);
+      const resolvedPath = resolve14(process.cwd(), repoPath);
       const remote = await detectRemote(resolvedPath);
       const result = await addRepository(repoPath, {
         source: remote?.source,
@@ -44814,15 +45040,17 @@ var skillsRemoveMeta = {
 };
 var skillsSearchMeta = {
   command: "skill search",
-  description: "Search GitHub for skills by querying SKILL.md files via the Code Search API. Results are sorted by star count. In TTY mode, shows a filter-as-you-type multi-select picker and offers to install the selected skills.",
+  description: "Search GitHub for skills by querying SKILL.md files via the Code Search API. Results are ranked by relevance, with skill-name matches first. In TTY mode, shows a filter-as-you-type multi-select picker and offers to install the selected skills.",
   whenToUse: 'To discover available skills from public GitHub repositories without leaving the CLI. Bridges "I want a skill that does X" → install.',
   examples: [
     "allagents skill search terraform",
+    "allagents skill pr-search",
+    'allagents skill "pr search"',
     "allagents skill search terraform --owner hashicorp",
     "allagents skill search docs --page 2 --limit 10",
     "allagents --json skill search docs --limit 5"
   ],
-  expectedOutput: "Skills sorted by star count: repo, skill name, stars, description. In TTY mode, followed by a searchable multi-select install prompt.",
+  expectedOutput: "Skills ranked by relevance: repo, skill name, stars, description. In TTY mode, followed by a searchable multi-select install prompt.",
   positionals: [
     { name: "query", type: "string", required: true, description: "Search query (≥2 characters)." }
   ],
@@ -44933,6 +45161,12 @@ async function recordSourceProvenance(opts) {
     ...pinnedRef && { pinnedRef }
   });
 }
+function resolveFetchedSourcePath(source, cachePath) {
+  if (!isGitHubUrl(source))
+    return cachePath;
+  const parsed = parseGitHubUrl(source);
+  return parsed?.subpath ? join26(cachePath, parsed.subpath) : cachePath;
+}
 function extractInlineRef(spec) {
   const slashIdx = spec.indexOf("/");
   if (slashIdx === -1)
@@ -45206,11 +45440,12 @@ async function installSkillFromSource(opts) {
   if (!fetchResult.success) {
     return { success: false, error: `Failed to fetch '${from}': ${fetchResult.error ?? "Unknown error"}` };
   }
-  const manifestResult = await parseMarketplaceManifest(fetchResult.cachePath);
+  const sourcePath = resolveFetchedSourcePath(from, fetchResult.cachePath);
+  const manifestResult = await parseMarketplaceManifest(sourcePath);
   if (manifestResult.success) {
     return installSkillViaMarketplace({ skill, from, isUser, workspacePath });
   }
-  return installSkillDirect({ skill, from, isUser, workspacePath, cachePath: fetchResult.cachePath });
+  return installSkillDirect({ skill, from, isUser, workspacePath, cachePath: sourcePath });
 }
 async function installSkillViaMarketplace(opts) {
   const { skill, from, isUser, workspacePath } = opts;
@@ -45263,7 +45498,8 @@ Available skills: ${allAvailableSkills.join(", ") || "none"}`
 }
 async function installSkillDirect(opts) {
   const { skill, from, isUser, workspacePath, cachePath } = opts;
-  const availableSkills = await discoverSkillNames(cachePath);
+  const sourcePath = resolveFetchedSourcePath(from, cachePath);
+  const availableSkills = await discoverSkillNames(sourcePath);
   if (!availableSkills.includes(skill)) {
     return {
       success: false,
@@ -45274,6 +45510,25 @@ Available skills: ${availableSkills.join(", ") || "none"}
 Tip: run \`allagents skill list\` to see all installed skills.`
     };
   }
+  if (isGitHubUrl(from)) {
+    const existingEnabledSkills = await getEnabledSkillsForGitHubSource(from, workspacePath);
+    const desiredSkills = [...existingEnabledSkills];
+    if (!desiredSkills.includes(skill))
+      desiredSkills.push(skill);
+    const updateResult = isUser ? await upsertUserGitHubPluginSourceAllowlist(from, desiredSkills) : await upsertGitHubPluginSourceAllowlist(from, desiredSkills, workspacePath);
+    if (!updateResult.success) {
+      return {
+        success: false,
+        error: `Failed to update plugin '${from}': ${updateResult.error ?? "Unknown error"}`
+      };
+    }
+    return finishSkillEnable({
+      skill,
+      pluginName: extractPrimaryPluginName(updateResult.normalizedPlugin ?? from),
+      isUser,
+      workspacePath
+    });
+  }
   const installResult = isUser ? await addUserPlugin(from) : await addPlugin(from, workspacePath);
   if (!installResult.success) {
     if (!installResult.error?.includes("already exists") && !installResult.error?.includes("duplicates existing")) {
@@ -45283,9 +45538,36 @@ Tip: run \`allagents skill list\` to see all installed skills.`
       console.log("Plugin already installed.");
     }
   }
-  const pluginName = getPluginName(cachePath);
+  const pluginName = getPluginName(sourcePath);
   return applySkillAllowlist({ skill, pluginName, isUser, workspacePath });
 }
+function extractPrimaryPluginName(source) {
+  const parsed = isGitHubUrl(source) ? parseGitHubUrl(source) : null;
+  if (parsed?.subpath) {
+    const segments = parsed.subpath.split("/").filter(Boolean);
+    const leaf = segments[segments.length - 1];
+    if (leaf)
+      return leaf;
+  }
+  return getPluginName(source);
+}
+async function getEnabledSkillsForGitHubSource(source, workspacePath) {
+  const identity = await resolveGitHubIdentity(source);
+  if (!identity)
+    return [];
+  const enabledSkills = [];
+  const allSkills = await getAllSkillsFromPlugins(workspacePath);
+  for (const skill of allSkills) {
+    if (skill.disabled)
+      continue;
+    const skillIdentity = await resolveGitHubIdentity(skill.pluginSource);
+    if (skillIdentity !== identity)
+      continue;
+    if (!enabledSkills.includes(skill.name))
+      enabledSkills.push(skill.name);
+  }
+  return enabledSkills;
+}
 async function applySkillAllowlist(opts) {
   const { skill, pluginName, isUser, workspacePath } = opts;
   const allSkills = await getAllSkillsFromPlugins(workspacePath);
@@ -45305,6 +45587,10 @@ async function applySkillAllowlist(opts) {
       return { success: false, error: `Failed to configure skill allowlist: ${setModeResult.error ?? "Unknown error"}` };
     }
   }
+  return finishSkillEnable({ skill, pluginName, isUser, workspacePath });
+}
+async function finishSkillEnable(opts) {
+  const { skill, pluginName, isUser, workspacePath } = opts;
   if (!isJsonMode()) {
     console.log(`✓ Enabled skill: ${skill} (${pluginName})`);
   }
@@ -45353,13 +45639,14 @@ async function discoverSkillsFromSource(from) {
   if (!fetchResult.success) {
     return { success: false, error: `Failed to fetch '${from}': ${fetchResult.error ?? "Unknown error"}` };
   }
-  const manifestResult = await parseMarketplaceManifest(fetchResult.cachePath);
+  const sourcePath = resolveFetchedSourcePath(from, fetchResult.cachePath);
+  const manifestResult = await parseMarketplaceManifest(sourcePath);
   if (manifestResult.success) {
     const all = [];
     for (const plugin of manifestResult.data.plugins) {
       if (typeof plugin.source === "object")
         continue;
-      const resolved = resolvePluginSourcePath(plugin.source, fetchResult.cachePath);
+      const resolved = resolvePluginSourcePath(plugin.source, sourcePath);
       if (!existsSync25(resolved))
         continue;
       const skills2 = await discoverSkillsWithMetadata(resolved, plugin.name);
@@ -45367,7 +45654,7 @@ async function discoverSkillsFromSource(from) {
     }
     return { success: true, skills: all, isMarketplace: true };
   }
-  const skills = await discoverSkillsWithMetadata(fetchResult.cachePath);
+  const skills = await discoverSkillsWithMetadata(sourcePath);
   return { success: true, skills, isMarketplace: false };
 }
 async function installAllSkillsFromSource(opts) {
@@ -45382,14 +45669,43 @@ async function installAllSkillsFromSource(opts) {
   if (!fetchResult.success) {
     return { success: false, error: `Failed to fetch '${from}': ${fetchResult.error ?? "Unknown error"}` };
   }
-  const manifestResult = await parseMarketplaceManifest(fetchResult.cachePath);
+  const sourcePath = resolveFetchedSourcePath(from, fetchResult.cachePath);
+  const manifestResult = await parseMarketplaceManifest(sourcePath);
   if (manifestResult.success) {
     return installAllViaMarketplace({ from, isUser, workspacePath, cachedPath: fetchResult.cachePath });
   }
-  const skillNames = await discoverSkillNames(fetchResult.cachePath);
+  const skillNames = await discoverSkillNames(sourcePath);
   if (skillNames.length === 0) {
     return { success: false, error: `No skills found in '${from}'.` };
   }
+  if (isGitHubUrl(from)) {
+    const existingEnabledSkills = await getEnabledSkillsForGitHubSource(from, workspacePath);
+    const desiredSkills = [...existingEnabledSkills];
+    for (const skillName of skillNames) {
+      if (!desiredSkills.includes(skillName))
+        desiredSkills.push(skillName);
+    }
+    const updateResult = isUser ? await upsertUserGitHubPluginSourceAllowlist(from, desiredSkills) : await upsertGitHubPluginSourceAllowlist(from, desiredSkills, workspacePath);
+    if (!updateResult.success) {
+      return {
+        success: false,
+        error: `Failed to configure skill allowlist: ${updateResult.error ?? "Unknown error"}`
+      };
+    }
+    const pluginName2 = extractPrimaryPluginName(updateResult.normalizedPlugin ?? from);
+    if (!isJsonMode()) {
+      console.log(`✓ Enabled ${skillNames.length} skill(s) from ${pluginName2}: ${skillNames.join(", ")}`);
+    }
+    const syncResult2 = isUser ? await syncUserWorkspace() : await syncWorkspace(workspacePath);
+    if (!syncResult2.success) {
+      return { success: false, error: "Sync failed" };
+    }
+    return {
+      success: true,
+      installed: [{ pluginName: pluginName2, skills: desiredSkills }],
+      syncResult: syncResult2
+    };
+  }
   const installResult = isUser ? await addUserPlugin(from) : await addPlugin(from, workspacePath);
   if (!installResult.success) {
     if (!installResult.error?.includes("already exists") && !installResult.error?.includes("duplicates existing")) {
@@ -45399,7 +45715,7 @@ async function installAllSkillsFromSource(opts) {
       console.log("Plugin already installed.");
     }
   }
-  const pluginName = getPluginName(fetchResult.cachePath);
+  const pluginName = getPluginName(sourcePath);
   const setModeResult = isUser ? await setUserPluginSkillsMode(pluginName, "allowlist", skillNames) : await setPluginSkillsMode(pluginName, "allowlist", skillNames, workspacePath);
   if (!setModeResult.success) {
     return { success: false, error: `Failed to configure skill allowlist: ${setModeResult.error ?? "Unknown error"}` };
@@ -45954,7 +46270,7 @@ var searchCmd = import_cmd_ts3.command({
   name: "search",
   description: buildDescription(skillsSearchMeta),
   args: {
-    query: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "query" }),
+    query: import_cmd_ts3.restPositionals({ type: import_cmd_ts3.string, displayName: "query" }),
     owner: import_cmd_ts3.option({
       type: import_cmd_ts3.optional(import_cmd_ts3.string),
       long: "owner",
@@ -45973,6 +46289,7 @@ var searchCmd = import_cmd_ts3.command({
   },
   handler: async ({ query, owner, page, limit }) => {
     try {
+      const searchQuery = query.join(" ").trim();
       const opts = {};
       if (owner)
         opts.owner = owner;
@@ -46002,7 +46319,7 @@ var searchCmd = import_cmd_ts3.command({
         }
         opts.limit = n;
       }
-      const result = await searchSkills(query, opts);
+      const result = await searchSkills(searchQuery, opts);
       if (isJsonMode()) {
         jsonOutput({
           success: true,
@@ -46012,16 +46329,16 @@ var searchCmd = import_cmd_ts3.command({
         return;
       }
       if (result.items.length === 0) {
-        console.log(`No skills found for "${query}".`);
+        console.log(`No skills found for "${searchQuery}".`);
         return;
       }
       const isTTY = process.stdout.isTTY && process.stdin.isTTY;
       if (!isTTY) {
-        printSearchResults(result.items, query, result.truncated);
+        printSearchResults(result.items, searchQuery, result.truncated);
         return;
       }
       const { autocompleteMultiselect: autocompleteMultiselect2, isCancel, log } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
-      log.success(formatSkillSearchSummary(result.items.length, query, result.truncated));
+      log.success(formatSkillSearchSummary(result.items.length, searchQuery, result.truncated));
       const options2 = result.items.map((item) => ({
         label: `${qualifiedName(item)}  ${source_default.dim(item.repo)}`,
         value: item.path,
@@ -58135,6 +58452,44 @@ var selfCmd = conciseSubcommands({
   }
 });
 
+// src/cli/skill-arg-normalizer.ts
+var SKILL_SUBCOMMANDS = new Set(["list", "remove", "add", "search"]);
+function normalizeSkillAlias(args) {
+  if (args.length === 0)
+    return args;
+  return args[0] === "skills" ? ["skill", ...args.slice(1)] : args;
+}
+function shouldUseSkillSearchShorthand(rest) {
+  const first2 = rest[0] ?? "";
+  if (rest.length === 0)
+    return false;
+  if (first2.startsWith("-") || SKILL_SUBCOMMANDS.has(first2))
+    return false;
+  return rest.length > 1 || /[-\s]/.test(first2);
+}
+function normalizeSkillHelpArgs(args) {
+  const normalized = normalizeSkillAlias(args);
+  if (normalized.length === 0 || normalized[0] !== "skill") {
+    return normalized;
+  }
+  const [, ...rest] = normalized;
+  return shouldUseSkillSearchShorthand(rest) ? ["skill", "search"] : normalized;
+}
+function normalizeSkillArgs(args) {
+  const normalized = normalizeSkillAlias(args);
+  if (normalized.length === 0 || normalized[0] !== "skill") {
+    return args;
+  }
+  const [, ...rest] = normalized;
+  if (rest.length === 0) {
+    return ["skill"];
+  }
+  if (!shouldUseSkillSearchShorthand(rest)) {
+    return ["skill", ...rest];
+  }
+  return ["skill", "search", ...rest];
+}
+
 // src/cli/agent-help.ts
 var allCommands = [
   initMeta,
@@ -58189,7 +58544,7 @@ function findMetaByCommand(commandPath) {
 }
 function printAgentHelp(args, version2) {
   const positional5 = args.filter((a) => !a.startsWith("-"));
-  const normalized = positional5[0] === "skills" ? ["skill", ...positional5.slice(1)] : positional5;
+  const normalized = normalizeSkillHelpArgs(positional5);
   const commandPath = normalized.join(" ");
   if (!commandPath) {
     const tree = {
@@ -58242,8 +58597,8 @@ var app = conciseSubcommands({
 var rawArgs = process.argv.slice(2);
 var { args: argsNoJson, json: json2, jsonFields: jsonFields2 } = extractJsonFlag(rawArgs);
 var { args: argsNoJq, jqExpr: jqExpr2 } = extractJqFlag(argsNoJson);
-var { args: argsWithSkillAlias, agentHelp } = extractAgentHelpFlag(argsNoJq);
-var finalArgs = argsWithSkillAlias[0] === "skills" ? ["skill", ...argsWithSkillAlias.slice(1)] : argsWithSkillAlias;
+var { args: argsAfterAgentHelp, agentHelp } = extractAgentHelpFlag(argsNoJq);
+var finalArgs = normalizeSkillArgs(argsAfterAgentHelp);
 if (jqExpr2 && !json2) {
   process.stderr.write(`Error: --jq requires --json.
 `);
@@ -58269,7 +58624,7 @@ if (!agentHelp && !json2 && !isWizard) {
 `);
 }
 if (agentHelp) {
-  printAgentHelp(finalArgs, package_default.version);
+  printAgentHelp(normalizeSkillHelpArgs(argsAfterAgentHelp), package_default.version);
 } else if (isWizard) {
   const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), exports_wizard));
   await runWizard2();