allagents 1.6.0 → 1.7.0

package/dist/index.js

@@ -7465,24 +7465,17 @@ __export(exports_constants, {
 function getHomeDir() {
   return process.env.HOME || process.env.USERPROFILE || "~";
 }
-function generateWorkspaceRules(repositories, skills = []) {
+function generateWorkspaceRules(repositories, skillsIndexRefs = []) {
   const repoList = repositories.map((r) => `- ${r.path}${r.description ? ` - ${r.description}` : ""}`).join(`
 `);
   let skillsBlock = "";
-  if (skills.length > 0) {
-    const skillEntries = skills.map((s) => `<skill>
-<name>${s.name}</name>
-<description>${s.description}</description>
-<location>${s.location}</location>
-</skill>`).join(`
+  if (skillsIndexRefs.length > 0) {
+    const refLines = skillsIndexRefs.map((r) => `- ${r.repoName}: ${r.indexPath}`).join(`
 `);
     skillsBlock = `
-## Workspace Skills
-When a task matches a skill description, fetch the full instructions from its location.
-
-<available_skills>
-${skillEntries}
-</available_skills>
+## Repository Skills
+If the skills from the following repositories are not already available in your context, read the corresponding index file:
+${refLines}
 `;
   }
   return `
@@ -11497,7 +11490,7 @@ function resolveInstallMode(pluginEntry, clientEntry) {
     return pluginMode;
   return clientEntry.install;
 }
-var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, InstallModeSchema, ClientEntrySchema, PluginSkillsConfigSchema, PluginEntrySchema, VscodeConfigSchema, SyncModeSchema, WorkspaceConfigSchema;
+var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, InstallModeSchema, ClientEntrySchema, PluginSkillsConfigSchema, PluginEntrySchema, VscodeConfigSchema, SyncModeSchema, McpProxyServerSchema, McpProxyConfigSchema, WorkspaceConfigSchema;
 var init_workspace_config = __esm(() => {
   init_zod();
   RepositorySchema = exports_external.object({
@@ -11602,6 +11595,13 @@ var init_workspace_config = __esm(() => {
     output: exports_external.string().optional()
   });
   SyncModeSchema = exports_external.enum(["symlink", "copy"]);
+  McpProxyServerSchema = exports_external.object({
+    proxy: exports_external.array(exports_external.string())
+  });
+  McpProxyConfigSchema = exports_external.object({
+    clients: exports_external.array(exports_external.string()),
+    servers: exports_external.record(McpProxyServerSchema).optional()
+  });
   WorkspaceConfigSchema = exports_external.object({
     version: exports_external.number().optional(),
     workspace: WorkspaceSchema.optional(),
@@ -11610,6 +11610,7 @@ var init_workspace_config = __esm(() => {
     clients: exports_external.array(ClientEntrySchema),
     vscode: VscodeConfigSchema.optional(),
     syncMode: SyncModeSchema.optional(),
+    mcpProxy: McpProxyConfigSchema.optional(),
     disabledSkills: exports_external.array(exports_external.string()).optional(),
     enabledSkills: exports_external.array(exports_external.string()).optional()
   });
@@ -25500,8 +25501,8 @@ var init_skill = __esm(() => {
 import { readFile as readFile3, writeFile, mkdir as mkdir3, cp, readdir as readdir2 } 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, skills = []) {
-  const rulesContent = generateWorkspaceRules(repositories, skills);
+async function ensureWorkspaceRules(filePath, repositories, skillsIndexRefs = []) {
+  const rulesContent = generateWorkspaceRules(repositories, skillsIndexRefs);
   const startMarker = "<!-- WORKSPACE-RULES:START -->";
   const endMarker = "<!-- WORKSPACE-RULES:END -->";
   if (!existsSync4(filePath)) {
@@ -25934,7 +25935,7 @@ function resolveFileSourcePath(source, defaultSourcePath, githubCache) {
   return null;
 }
 async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {}) {
-  const { dryRun = false, githubCache, repositories = [], skills = [] } = options2;
+  const { dryRun = false, githubCache, repositories = [], skillsIndexRefs = [] } = options2;
   const results = [];
   const stringPatterns = [];
   const objectEntries = [];
@@ -26087,7 +26088,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
     for (const agentFile of copiedAgentFiles) {
       const targetPath = join7(workspacePath, agentFile);
       try {
-        await ensureWorkspaceRules(targetPath, repositories, skills);
+        await ensureWorkspaceRules(targetPath, repositories, skillsIndexRefs);
       } catch (error) {
         results.push({
           source: "WORKSPACE-RULES",
@@ -28366,9 +28367,9 @@ var init_workspace_modify = __esm(() => {
 });
 
 // src/core/repo-skills.ts
-import { existsSync as existsSync9, lstatSync } from "node:fs";
+import { existsSync as existsSync9, lstatSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { readdir as readdir4, readFile as readFile8 } from "node:fs/promises";
-import { join as join12, relative as relative3, resolve as resolve8 } from "node:path";
+import { basename as basename5, join as join12, relative as relative3, resolve as resolve8 } from "node:path";
 async function discoverRepoSkills(repoPath, options2) {
   if (options2.disabled)
     return [];
@@ -28423,7 +28424,8 @@ async function discoverRepoSkills(repoPath, options2) {
         results.push({
           name: metadata.name,
           description: metadata.description,
-          relativePath: relPath
+          relativePath: relPath,
+          fileSize: content.length
         });
       } catch {}
     }
@@ -28431,24 +28433,104 @@ async function discoverRepoSkills(repoPath, options2) {
   return results;
 }
 async function discoverWorkspaceSkills(workspacePath, repositories, clientNames) {
-  const allSkills = [];
+  const skillsByName = new Map;
   for (const repo of repositories) {
-    if (repo.skills === false)
+    if (repo.skills === false || repo.skills === undefined)
       continue;
     const repoAbsPath = resolve8(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) {
       const location = `${repo.path}/${skill.relativePath}`.replace(/\\/g, "/");
-      allSkills.push({
+      const candidate = {
         repoPath: repo.path,
         name: skill.name,
         description: skill.description,
-        location
-      });
+        location,
+        fileSize: skill.fileSize
+      };
+      const existing = skillsByName.get(skill.name);
+      if (!existing) {
+        skillsByName.set(skill.name, candidate);
+        continue;
+      }
+      const existingIsAgents = existing.location.includes(".agents/");
+      const candidateIsAgents = candidate.location.includes(".agents/");
+      if (candidateIsAgents && !existingIsAgents) {
+        skillsByName.set(skill.name, candidate);
+      } else if (!candidateIsAgents && existingIsAgents) {} else if (candidate.fileSize > existing.fileSize) {
+        skillsByName.set(skill.name, candidate);
+      }
     }
   }
-  return allSkills;
+  return [...skillsByName.values()].map(({ fileSize: _, ...entry }) => entry);
+}
+function writeSkillsIndex(workspacePath, skillsByRepo) {
+  if (skillsByRepo.size === 0)
+    return { writtenFiles: [], refs: [] };
+  const indexDir = join12(workspacePath, ".allagents", "skills-index");
+  mkdirSync(indexDir, { recursive: true });
+  const writtenFiles = [];
+  const refs = [];
+  for (const [, { repoName, skills }] of skillsByRepo) {
+    const skillEntries = skills.map((s) => `<skill>
+<name>${s.name}</name>
+<description>${s.description}</description>
+<location>${s.location}</location>
+</skill>`).join(`
+`);
+    const content = `# Skills: ${repoName}
+
+<available_skills>
+${skillEntries}
+</available_skills>
+`;
+    const filePath = `skills-index/${repoName}.md`;
+    writeFileSync(join12(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))
+    return;
+  const currentSet = new Set(currentFiles.map((f) => f.replace("skills-index/", "")));
+  let entries;
+  try {
+    entries = readdirSync(indexDir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!currentSet.has(entry)) {
+      rmSync(join12(indexDir, entry), { force: true });
+    }
+  }
+  try {
+    const remaining = readdirSync(indexDir);
+    if (remaining.length === 0) {
+      rmSync(indexDir, { recursive: true, force: true });
+    }
+  } catch {}
+}
+function groupSkillsByRepo(skills, repositories) {
+  const repoNameMap = new Map;
+  for (const repo of repositories) {
+    repoNameMap.set(repo.path, repo.name ?? basename5(repo.path));
+  }
+  const grouped = new Map;
+  for (const skill of skills) {
+    const repoName = repoNameMap.get(skill.repoPath) ?? basename5(skill.repoPath);
+    const existing = grouped.get(skill.repoPath);
+    if (existing) {
+      existing.skills.push(skill);
+    } else {
+      grouped.set(skill.repoPath, { repoName, skills: [skill] });
+    }
+  }
+  return grouped;
 }
 var init_repo_skills = __esm(() => {
   init_skill();
@@ -28571,6 +28653,9 @@ async function updateAgentFiles(workspacePath = process.cwd()) {
     return;
   const clientNames = resolveClientNames(config.clients);
   const allSkills = await discoverWorkspaceSkills(workspacePath, config.repositories, clientNames);
+  const grouped = groupSkillsByRepo(allSkills, config.repositories);
+  const { writtenFiles, refs: skillsIndexRefs } = writeSkillsIndex(workspacePath, grouped);
+  cleanupSkillsIndex(workspacePath, writtenFiles);
   const agentFiles = new Set;
   for (const client of config.clients ?? []) {
     const clientName = typeof client === "string" ? client : client.name;
@@ -28580,7 +28665,7 @@ async function updateAgentFiles(workspacePath = process.cwd()) {
   }
   agentFiles.add("AGENTS.md");
   for (const agentFile of agentFiles) {
-    await ensureWorkspaceRules(join13(workspacePath, agentFile), config.repositories, allSkills);
+    await ensureWorkspaceRules(join13(workspacePath, agentFile), config.repositories, skillsIndexRefs);
   }
 }
 var init_workspace_repo = __esm(() => {
@@ -28751,7 +28836,8 @@ var init_sync_state = __esm(() => {
     mcpServers: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional(),
     nativePlugins: exports_external.record(ClientTypeSchema, exports_external.array(exports_external.string())).optional(),
     vscodeWorkspaceHash: exports_external.string().optional(),
-    vscodeWorkspaceRepos: exports_external.array(exports_external.string()).optional()
+    vscodeWorkspaceRepos: exports_external.array(exports_external.string()).optional(),
+    skillsIndex: exports_external.array(exports_external.string()).optional()
   });
 });
 
@@ -28817,7 +28903,8 @@ async function saveSyncState(workspacePath, data) {
     ...normalizedData.mcpServers && { mcpServers: normalizedData.mcpServers },
     ...normalizedData.nativePlugins && { nativePlugins: normalizedData.nativePlugins },
     ...normalizedData.vscodeWorkspaceHash && { vscodeWorkspaceHash: normalizedData.vscodeWorkspaceHash },
-    ...normalizedData.vscodeWorkspaceRepos && { vscodeWorkspaceRepos: normalizedData.vscodeWorkspaceRepos }
+    ...normalizedData.vscodeWorkspaceRepos && { vscodeWorkspaceRepos: normalizedData.vscodeWorkspaceRepos },
+    ...normalizedData.skillsIndex && normalizedData.skillsIndex.length > 0 && { skillsIndex: normalizedData.skillsIndex }
   };
   await mkdir7(dirname6(statePath), { recursive: true });
   await ensureConfigGitignore(workspacePath);
@@ -28848,7 +28935,7 @@ var init_sync_state2 = __esm(() => {
 
 // src/core/vscode-workspace.ts
 import { createHash as createHash2 } from "node:crypto";
-import { resolve as resolve9, basename as basename5, isAbsolute as isAbsolute3, relative as relative4 } from "node:path";
+import { resolve as resolve9, basename as basename6, isAbsolute as isAbsolute3, relative as relative4 } from "node:path";
 function buildPathPlaceholderMap(repositories, workspacePath) {
   const map2 = new Map;
   for (const repo of repositories) {
@@ -28931,7 +29018,7 @@ function getWorkspaceOutputPath(workspacePath, vscodeConfig) {
     const filename = name.endsWith(".code-workspace") ? name : `${name}.code-workspace`;
     return resolve9(workspacePath, filename);
   }
-  const dirName = basename5(resolve9(workspacePath));
+  const dirName = basename6(resolve9(workspacePath));
   return resolve9(workspacePath, `${dirName}.code-workspace`);
 }
 function computeWorkspaceHash(content) {
@@ -29003,7 +29090,7 @@ var init_vscode_workspace = __esm(() => {
 });
 
 // src/core/vscode-mcp.ts
-import { existsSync as existsSync13, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { existsSync as existsSync13, readFileSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { join as join16, dirname as dirname7 } from "node:path";
 function deepEqual(a, b) {
   if (a === b)
@@ -29083,7 +29170,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
   const configPath = options2?.configPath ?? getVscodeMcpConfigPath();
   const previouslyTracked = new Set(options2?.trackedServers ?? []);
   const hasTracking = options2?.trackedServers !== undefined;
-  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const { servers: pluginServers, warnings } = options2?.serverOverrides ? { servers: options2.serverOverrides, warnings: [] } : collectMcpServers(validatedPlugins);
   const result = {
     added: 0,
     skipped: 0,
@@ -29149,9 +29236,9 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
     existingConfig.servers = existingServers;
     const dir = dirname7(configPath);
     if (!existsSync13(dir)) {
-      mkdirSync(dir, { recursive: true });
+      mkdirSync2(dir, { recursive: true });
     }
-    writeFileSync(configPath, `${JSON.stringify(existingConfig, null, 2)}
+    writeFileSync2(configPath, `${JSON.stringify(existingConfig, null, 2)}
 `, "utf-8");
     result.configPath = configPath;
   }
@@ -29167,9 +29254,9 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
       existingConfig.servers = existingServers;
       const dir = dirname7(configPath);
       if (!existsSync13(dir)) {
-        mkdirSync(dir, { recursive: true });
+        mkdirSync2(dir, { recursive: true });
       }
-      writeFileSync(configPath, `${JSON.stringify(existingConfig, null, 2)}
+      writeFileSync2(configPath, `${JSON.stringify(existingConfig, null, 2)}
 `, "utf-8");
       result.configPath = configPath;
     }
@@ -29182,6 +29269,60 @@ var init_vscode_mcp = __esm(() => {
   import_json5 = __toESM(require_lib(), 1);
 });
 
+// src/core/mcp-proxy.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join17, dirname as dirname8 } from "node:path";
+function getProxyMetadataPath() {
+  return join17(getHomeDir(), ".allagents", "mcp-remote", "mcp-metadata-settings.json");
+}
+function shouldProxy(serverName, client, config) {
+  if (config.clients.includes(client)) {
+    return true;
+  }
+  const serverOverride = config.servers?.[serverName];
+  if (serverOverride?.proxy.includes(client)) {
+    return true;
+  }
+  return false;
+}
+function isHttpServer(config) {
+  return typeof config === "object" && config !== null && "url" in config && typeof config.url === "string";
+}
+function toProxiedConfig(url, metadataPath) {
+  return {
+    command: "npx",
+    args: [
+      "mcp-remote",
+      url,
+      "--http",
+      "--static-oauth-client-metadata",
+      `@${metadataPath}`
+    ]
+  };
+}
+function applyMcpProxy(servers, client, config, metadataPath) {
+  const result = new Map;
+  for (const [name, serverConfig] of servers) {
+    if (isHttpServer(serverConfig) && shouldProxy(name, client, config)) {
+      result.set(name, toProxiedConfig(serverConfig.url, metadataPath));
+    } else {
+      result.set(name, serverConfig);
+    }
+  }
+  return result;
+}
+function ensureProxyMetadata(metadataPath) {
+  const path = metadataPath ?? getProxyMetadataPath();
+  if (existsSync14(path)) {
+    return;
+  }
+  mkdirSync3(dirname8(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify({ client_uri: "http://localhost" }, null, 2), "utf-8");
+}
+var init_mcp_proxy = __esm(() => {
+  init_constants();
+});
+
 // src/core/native/types.ts
 import { spawn as spawn2 } from "node:child_process";
 function executeCommand(binary2, args, options2 = {}) {
@@ -29235,8 +29376,8 @@ function mergeNativeSyncResults(results) {
 var init_types2 = () => {};
 
 // src/core/codex-mcp.ts
-import { existsSync as existsSync14, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync2, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname9 } from "node:path";
 function buildCodexMcpAddArgs(name, config) {
   if (typeof config.url === "string") {
     return ["mcp", "add", name, "--url", config.url];
@@ -29261,7 +29402,7 @@ async function syncCodexMcpServers(validatedPlugins, options2) {
   const previouslyTracked = new Set(options2?.trackedServers ?? []);
   const hasTracking = options2?.trackedServers !== undefined;
   const exec = options2?._mockExecute ?? ((binary2, args) => executeCommand(binary2, args));
-  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const { servers: pluginServers, warnings } = options2?.serverOverrides ? { servers: options2.serverOverrides, warnings: [] } : collectMcpServers(validatedPlugins);
   const result = {
     added: 0,
     skipped: 0,
@@ -29432,7 +29573,7 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
   }
   const previouslyTracked = new Set(options2?.trackedServers ?? []);
   const hasTracking = options2?.trackedServers !== undefined;
-  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const { servers: pluginServers, warnings } = options2?.serverOverrides ? { servers: options2.serverOverrides, warnings: [] } : collectMcpServers(validatedPlugins);
   const result = {
     added: 0,
     skipped: 0,
@@ -29446,7 +29587,7 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingContent = "";
-  if (existsSync14(configPath)) {
+  if (existsSync15(configPath)) {
     try {
       existingContent = readFileSync2(configPath, "utf-8");
     } catch {
@@ -29501,11 +29642,11 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
 
 `)}
 `;
-    const dir = dirname8(configPath);
-    if (!existsSync14(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    const dir = dirname9(configPath);
+    if (!existsSync15(dir)) {
+      mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync2(configPath, output, "utf-8");
+    writeFileSync4(configPath, output, "utf-8");
     result.configPath = configPath;
   }
   return result;
@@ -29516,8 +29657,8 @@ var init_codex_mcp = __esm(() => {
 });
 
 // src/core/claude-mcp.ts
-import { existsSync as existsSync15, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync3, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 function deepEqual2(a, b) {
   if (a === b)
     return true;
@@ -29570,7 +29711,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
   }
   const previouslyTracked = new Set(options2?.trackedServers ?? []);
   const hasTracking = options2?.trackedServers !== undefined;
-  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const { servers: pluginServers, warnings } = options2?.serverOverrides ? { servers: options2.serverOverrides, warnings: [] } : collectMcpServers(validatedPlugins);
   const result = {
     added: 0,
     skipped: 0,
@@ -29584,7 +29725,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);
@@ -29634,11 +29775,11 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
   const hasChanges = result.added > 0 || result.overwritten > 0 || result.removed > 0;
   if (hasChanges && !dryRun) {
     existingConfig.mcpServers = existingServers;
-    const dir = dirname9(configPath);
-    if (!existsSync15(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    const dir = dirname10(configPath);
+    if (!existsSync16(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
-    writeFileSync3(configPath, `${JSON.stringify(existingConfig, null, 2)}
+    writeFileSync5(configPath, `${JSON.stringify(existingConfig, null, 2)}
 `, "utf-8");
     result.configPath = configPath;
   }
@@ -29652,11 +29793,11 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     }
     if (result.removed > 0 && !dryRun) {
       existingConfig.mcpServers = existingServers;
-      const dir = dirname9(configPath);
-      if (!existsSync15(dir)) {
-        mkdirSync3(dir, { recursive: true });
+      const dir = dirname10(configPath);
+      if (!existsSync16(dir)) {
+        mkdirSync5(dir, { recursive: true });
       }
-      writeFileSync3(configPath, `${JSON.stringify(existingConfig, null, 2)}
+      writeFileSync5(configPath, `${JSON.stringify(existingConfig, null, 2)}
 `, "utf-8");
       result.configPath = configPath;
     }
@@ -29668,7 +29809,7 @@ async function syncClaudeMcpServersViaCli(validatedPlugins, options2) {
   const previouslyTracked = new Set(options2?.trackedServers ?? []);
   const hasTracking = options2?.trackedServers !== undefined;
   const exec = options2?._mockExecute ?? ((binary2, args) => executeCommand(binary2, args));
-  const { servers: pluginServers, warnings } = collectMcpServers(validatedPlugins);
+  const { servers: pluginServers, warnings } = options2?.serverOverrides ? { servers: options2.serverOverrides, warnings: [] } : collectMcpServers(validatedPlugins);
   const result = {
     added: 0,
     skipped: 0,
@@ -29752,9 +29893,9 @@ 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();
@@ -30052,9 +30193,9 @@ function padStart2(str3, len) {
 }
 
 // src/core/sync.ts
-import { existsSync as existsSync16, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync as lstatSync2 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync4, writeFileSync as writeFileSync6, lstatSync as lstatSync2 } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
-import { join as join18, resolve as resolve10, dirname as dirname10, relative as relative5 } from "node:path";
+import { join as join19, resolve as resolve10, dirname as dirname11, relative as relative5 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -30168,7 +30309,7 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join18(workspacePath, filePath);
+      const fullPath = join19(workspacePath, filePath);
       const cleanPath = fullPath.replace(/\/$/, "");
       let stats;
       try {
@@ -30195,16 +30336,16 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
   return result;
 }
 async function cleanupEmptyParents(workspacePath, filePath) {
-  let parentPath = dirname10(filePath);
+  let parentPath = dirname11(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join18(workspacePath, parentPath);
-    if (!existsSync16(fullParentPath)) {
-      parentPath = dirname10(parentPath);
+    const fullParentPath = join19(workspacePath, parentPath);
+    if (!existsSync17(fullParentPath)) {
+      parentPath = dirname11(parentPath);
       continue;
     }
     try {
       await rmdir(fullParentPath);
-      parentPath = dirname10(parentPath);
+      parentPath = dirname11(parentPath);
     } catch {
       break;
     }
@@ -30283,8 +30424,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join18(defaultSourcePath, file);
-      if (!existsSync16(fullPath)) {
+      const fullPath = join19(defaultSourcePath, file);
+      if (!existsSync17(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -30302,8 +30443,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join18(cachePath, parsed.filePath);
-        if (!existsSync16(fullPath)) {
+        const fullPath = join19(cachePath, parsed.filePath);
+        if (!existsSync17(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -30313,11 +30454,11 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         } else if (file.source.startsWith("../")) {
           fullPath = resolve10(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join18(defaultSourcePath, file.source);
+          fullPath = join19(defaultSourcePath, file.source);
         } else {
           fullPath = resolve10(file.source);
         }
-        if (!existsSync16(fullPath)) {
+        if (!existsSync17(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -30326,8 +30467,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 = join18(defaultSourcePath, file.dest ?? "");
-      if (!existsSync16(fullPath)) {
+      const fullPath = join19(defaultSourcePath, file.dest ?? "");
+      if (!existsSync17(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -30473,7 +30614,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join18(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join19(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
@@ -30483,7 +30624,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
     };
   }
   const resolvedPath = resolve10(workspacePath, pluginSource);
-  if (!existsSync16(resolvedPath)) {
+  if (!existsSync17(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -30644,10 +30785,10 @@ function buildPluginSkillNameMaps(allSkills) {
   return pluginMaps;
 }
 function generateVscodeWorkspaceFile(workspacePath, config) {
-  const configDir = join18(workspacePath, CONFIG_DIR);
-  const templatePath = join18(configDir, VSCODE_TEMPLATE_FILE);
+  const configDir = join19(workspacePath, CONFIG_DIR);
+  const templatePath = join19(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync16(templatePath)) {
+  if (existsSync17(templatePath)) {
     try {
       template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
     } catch (error) {
@@ -30662,7 +30803,7 @@ function generateVscodeWorkspaceFile(workspacePath, config) {
   const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
   const contentStr = `${JSON.stringify(content, null, "\t")}
 `;
-  writeFileSync4(outputPath, contentStr, "utf-8");
+  writeFileSync6(outputPath, contentStr, "utf-8");
   return contentStr;
 }
 function failedSyncResult(error, overrides) {
@@ -30794,7 +30935,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync16(outputPath)) {
+    if (existsSync17(outputPath)) {
       const existingContent = readFileSync4(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
@@ -30851,16 +30992,17 @@ async function persistSyncState(workspacePath, pluginResults, workspaceFileResul
     ...Object.keys(nativePluginsState).length > 0 && { nativePlugins: nativePluginsState },
     ...extra?.vscodeState?.hash && { vscodeWorkspaceHash: extra.vscodeState.hash },
     ...extra?.vscodeState?.repos && { vscodeWorkspaceRepos: extra.vscodeState.repos },
-    ...extra?.mcpTrackedServers && { mcpServers: extra.mcpTrackedServers }
+    ...extra?.mcpTrackedServers && { mcpServers: extra.mcpTrackedServers },
+    ...extra?.skillsIndex && extra.skillsIndex.length > 0 && { skillsIndex: extra.skillsIndex }
   });
 }
 async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   await migrateWorkspaceSkillsV1toV2(workspacePath);
   const { offline = false, dryRun = false, workspaceSourceBase, skipAgentFiles = false } = options2;
   const sw = new Stopwatch;
-  const configDir = join18(workspacePath, CONFIG_DIR);
-  const configPath = join18(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync16(configPath)) {
+  const configDir = join19(workspacePath, CONFIG_DIR);
+  const configPath = join19(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync17(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -30942,6 +31084,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   })), `${validPlugins.length} plugin(s)`);
   const nativeResult = await sw.measure("native-plugin-sync", () => syncNativePlugins(validPlugins, previousState, "project", workspacePath, dryRun, warnings, messages));
   let workspaceFileResults = [];
+  let writtenSkillsIndexFiles = [];
   const skipWorkspaceFiles = !!config.workspace?.source && !validatedWorkspaceSource;
   if (config.workspace && !skipWorkspaceFiles) {
     sw.start("workspace-files");
@@ -30949,8 +31092,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 = join18(sourcePath, agentFile);
-        if (existsSync16(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join19(sourcePath, agentFile);
+        if (existsSync17(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -30973,12 +31116,22 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
 `)}`, { pluginResults, totalFailed: fileValidationErrors.length });
     }
     const repoSkills = hasRepositories && !dryRun ? await discoverWorkspaceSkills(workspacePath, config.repositories, syncClients) : [];
-    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache, repositories: config.repositories, skills: repoSkills });
+    let skillsIndexRefs = [];
+    if (!dryRun) {
+      if (repoSkills.length > 0) {
+        const grouped = groupSkillsByRepo(repoSkills, config.repositories);
+        const result = writeSkillsIndex(workspacePath, grouped);
+        writtenSkillsIndexFiles = result.writtenFiles;
+        skillsIndexRefs = result.refs;
+      }
+      cleanupSkillsIndex(workspacePath, writtenSkillsIndexFiles);
+    }
+    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache, repositories: config.repositories, skillsIndexRefs });
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
-      const claudePath = join18(workspacePath, "CLAUDE.md");
-      const agentsPath = join18(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync16(join18(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync16(agentsPath) && !existsSync16(claudePath)) {
+      const claudePath = join19(workspacePath, "CLAUDE.md");
+      const agentsPath = join19(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync17(join19(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync17(agentsPath) && !existsSync17(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -30995,16 +31148,39 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       vscodeState = { hash: result.hash, repos: result.repos };
     }
   }
+  const mcpProxyConfig = config.mcpProxy;
+  let proxyMetadataPath;
+  let proxyBaseServers;
+  if (mcpProxyConfig) {
+    if (!dryRun) {
+      ensureProxyMetadata();
+    }
+    proxyMetadataPath = getProxyMetadataPath();
+    const { servers, warnings: proxyWarnings } = collectMcpServers(validPlugins);
+    if (proxyWarnings.length > 0) {
+      warnings.push(...proxyWarnings);
+    }
+    if (servers.size > 0) {
+      proxyBaseServers = servers;
+    }
+  }
+  function getServersForClient(client) {
+    if (!mcpProxyConfig || !proxyMetadataPath || !proxyBaseServers)
+      return;
+    return applyMcpProxy(proxyBaseServers, client, mcpProxyConfig, proxyMetadataPath);
+  }
   sw.start("mcp-sync");
   const mcpResults = {};
   if (syncClients.includes("vscode")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
-    const projectMcpPath = join18(workspacePath, ".vscode", "mcp.json");
+    const projectMcpPath = join19(workspacePath, ".vscode", "mcp.json");
+    const vscodeMcpOverrides = getServersForClient("vscode");
     const vscodeMcp = syncVscodeMcpConfig(validPlugins, {
       dryRun,
       force: false,
       configPath: projectMcpPath,
-      trackedServers: trackedMcpServers
+      trackedServers: trackedMcpServers,
+      ...vscodeMcpOverrides && { serverOverrides: vscodeMcpOverrides }
     });
     if (vscodeMcp.warnings.length > 0) {
       warnings.push(...vscodeMcp.warnings);
@@ -31013,12 +31189,14 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   if (syncClients.includes("claude")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "claude");
-    const projectMcpJsonPath = join18(workspacePath, ".mcp.json");
+    const projectMcpJsonPath = join19(workspacePath, ".mcp.json");
+    const claudeMcpOverrides = getServersForClient("claude");
     const claudeMcp = syncClaudeMcpConfig(validPlugins, {
       dryRun,
       force: false,
       configPath: projectMcpJsonPath,
-      trackedServers: trackedMcpServers
+      trackedServers: trackedMcpServers,
+      ...claudeMcpOverrides && { serverOverrides: claudeMcpOverrides }
     });
     if (claudeMcp.warnings.length > 0) {
       warnings.push(...claudeMcp.warnings);
@@ -31027,12 +31205,14 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   if (syncClients.includes("codex")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "codex");
-    const projectCodexConfigPath = join18(workspacePath, ".codex", "config.toml");
+    const projectCodexConfigPath = join19(workspacePath, ".codex", "config.toml");
+    const codexMcpOverrides = getServersForClient("codex");
     const codexMcp = syncCodexProjectMcpConfig(validPlugins, {
       dryRun,
       force: false,
       configPath: projectCodexConfigPath,
-      trackedServers: trackedMcpServers
+      trackedServers: trackedMcpServers,
+      ...codexMcpOverrides && { serverOverrides: codexMcpOverrides }
     });
     if (codexMcp.warnings.length > 0) {
       warnings.push(...codexMcp.warnings);
@@ -31041,12 +31221,14 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   if (syncClients.includes("copilot")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "copilot");
-    const projectCopilotMcpPath = join18(workspacePath, ".copilot", "mcp-config.json");
+    const projectCopilotMcpPath = join19(workspacePath, ".copilot", "mcp-config.json");
+    const copilotMcpOverrides = getServersForClient("copilot");
     const copilotMcp = syncClaudeMcpConfig(validPlugins, {
       dryRun,
       force: false,
       configPath: projectCopilotMcpPath,
-      trackedServers: trackedMcpServers
+      trackedServers: trackedMcpServers,
+      ...copilotMcpOverrides && { serverOverrides: copilotMcpOverrides }
     });
     if (copilotMcp.warnings.length > 0) {
       warnings.push(...copilotMcp.warnings);
@@ -31055,7 +31237,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   sw.stop("mcp-sync");
   const PROJECT_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "copilot", "universal"]);
-  const { servers: allMcpServers } = collectMcpServers(validPlugins);
+  const allMcpServers = proxyBaseServers ?? collectMcpServers(validPlugins).servers;
   if (allMcpServers.size > 0) {
     for (const client of syncClients) {
       if (!PROJECT_MCP_CLIENTS.has(client)) {
@@ -31076,7 +31258,8 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       ...vscodeState && { vscodeState },
       ...Object.keys(mcpResults).length > 0 && {
         mcpTrackedServers: Object.fromEntries(Object.entries(mcpResults).map(([scope, r]) => [scope, r.trackedServers]))
-      }
+      },
+      ...writtenSkillsIndexFiles.length > 0 && { skillsIndex: writtenSkillsIndexFiles }
     }));
   }
   return {
@@ -31111,7 +31294,7 @@ async function seedFetchCacheFromMarketplaces(results) {
 }
 function readGitBranch(repoPath) {
   try {
-    const head = readFileSync4(join18(repoPath, ".git", "HEAD"), "utf-8").trim();
+    const head = readFileSync4(join19(repoPath, ".git", "HEAD"), "utf-8").trim();
     const prefix = "ref: refs/heads/";
     return head.startsWith(prefix) ? head.slice(prefix.length) : null;
   } catch {
@@ -31170,11 +31353,38 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     return { ...result, scope: "user" };
   })), `${validPlugins.length} plugin(s)`);
   const { totalCopied, totalFailed, totalSkipped, totalGenerated } = countCopyResults(pluginResults, []);
+  const userMcpProxyConfig = config.mcpProxy;
+  let userProxyMetadataPath;
+  let userProxyBaseServers;
+  if (userMcpProxyConfig) {
+    if (!dryRun) {
+      ensureProxyMetadata();
+    }
+    userProxyMetadataPath = getProxyMetadataPath();
+    const { servers, warnings: proxyWarnings } = collectMcpServers(validPlugins);
+    if (proxyWarnings.length > 0) {
+      warnings.push(...proxyWarnings);
+    }
+    if (servers.size > 0) {
+      userProxyBaseServers = servers;
+    }
+  }
+  function getUserServersForClient(client) {
+    if (!userMcpProxyConfig || !userProxyMetadataPath || !userProxyBaseServers)
+      return;
+    return applyMcpProxy(userProxyBaseServers, client, userMcpProxyConfig, userProxyMetadataPath);
+  }
   sw.start("mcp-sync");
   const mcpResults = {};
   if (syncClients.includes("vscode")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
-    const vscodeMcp = syncVscodeMcpConfig(validPlugins, { dryRun, force, trackedServers: trackedMcpServers });
+    const vscodeMcpOverrides = getUserServersForClient("vscode");
+    const vscodeMcp = syncVscodeMcpConfig(validPlugins, {
+      dryRun,
+      force,
+      trackedServers: trackedMcpServers,
+      ...vscodeMcpOverrides && { serverOverrides: vscodeMcpOverrides }
+    });
     if (vscodeMcp.warnings.length > 0) {
       warnings.push(...vscodeMcp.warnings);
     }
@@ -31182,7 +31392,12 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   if (syncClients.includes("codex")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "codex");
-    const codexMcp = await syncCodexMcpServers(validPlugins, { dryRun, trackedServers: trackedMcpServers });
+    const codexMcpOverrides = getUserServersForClient("codex");
+    const codexMcp = await syncCodexMcpServers(validPlugins, {
+      dryRun,
+      trackedServers: trackedMcpServers,
+      ...codexMcpOverrides && { serverOverrides: codexMcpOverrides }
+    });
     if (codexMcp.warnings.length > 0) {
       warnings.push(...codexMcp.warnings);
     }
@@ -31190,7 +31405,12 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   if (syncClients.includes("claude")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "claude");
-    const claudeMcp = await syncClaudeMcpServersViaCli(validPlugins, { dryRun, trackedServers: trackedMcpServers });
+    const claudeMcpOverrides = getUserServersForClient("claude");
+    const claudeMcp = await syncClaudeMcpServersViaCli(validPlugins, {
+      dryRun,
+      trackedServers: trackedMcpServers,
+      ...claudeMcpOverrides && { serverOverrides: claudeMcpOverrides }
+    });
     if (claudeMcp.warnings.length > 0) {
       warnings.push(...claudeMcp.warnings);
     }
@@ -31199,11 +31419,13 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   if (syncClients.includes("copilot")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "copilot");
     const copilotMcpPath = getCopilotMcpConfigPath();
+    const copilotMcpOverrides = getUserServersForClient("copilot");
     const copilotMcp = syncClaudeMcpConfig(validPlugins, {
       dryRun,
       force,
       configPath: copilotMcpPath,
-      trackedServers: trackedMcpServers
+      trackedServers: trackedMcpServers,
+      ...copilotMcpOverrides && { serverOverrides: copilotMcpOverrides }
     });
     if (copilotMcp.warnings.length > 0) {
       warnings.push(...copilotMcp.warnings);
@@ -31212,7 +31434,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   sw.stop("mcp-sync");
   const USER_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "copilot", "universal"]);
-  const { servers: allUserMcpServers } = collectMcpServers(validPlugins);
+  const allUserMcpServers = userProxyBaseServers ?? collectMcpServers(validPlugins).servers;
   if (allUserMcpServers.size > 0) {
     for (const client of syncClients) {
       if (!USER_MCP_CLIENTS.has(client)) {
@@ -31268,6 +31490,7 @@ var init_sync = __esm(() => {
   init_vscode_workspace();
   init_workspace_modify();
   init_vscode_mcp();
+  init_mcp_proxy();
   init_codex_mcp();
   init_claude_mcp();
   init_copilot_mcp();
@@ -31276,11 +31499,11 @@ var init_sync = __esm(() => {
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync17, readFileSync as readFileSync5 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync5 } from "node:fs";
+import { join as join20 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
-  const fullPath = join19(tempDir, filePath);
-  if (existsSync17(fullPath)) {
+  const fullPath = join20(tempDir, filePath);
+  if (existsSync18(fullPath)) {
     return readFileSync5(fullPath, "utf-8");
   }
   return null;
@@ -31380,14 +31603,14 @@ var init_github_fetch = __esm(() => {
 
 // src/core/workspace.ts
 import { cp as cp2, mkdir as mkdir8, readFile as readFile12, writeFile as writeFile8, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join20, resolve as resolve11, dirname as dirname11, relative as relative6, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { join as join21, resolve as resolve11, 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 = resolve11(targetPath);
-  const configDir = join20(absoluteTarget, CONFIG_DIR);
-  const configPath = join20(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync18(configPath)) {
+  const configDir = join21(absoluteTarget, CONFIG_DIR);
+  const configPath = join21(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync19(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -31396,9 +31619,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     }
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentFileDir = dirname11(currentFilePath);
+  const currentFileDir = dirname12(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
-  const defaultTemplatePath = isProduction ? join20(currentFileDir, "templates", "default") : join20(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join21(currentFileDir, "templates", "default") : join21(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   let parsedFromUrl;
   let githubBasePath = "";
@@ -31438,19 +31661,19 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
         const fromPath = resolve11(options2.from);
-        if (!existsSync18(fromPath)) {
+        if (!existsSync19(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 = join20(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join20(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync18(nestedPath)) {
+          const nestedPath = join21(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join21(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync19(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync18(rootPath)) {
+          } else if (existsSync19(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -31459,9 +31682,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else {
           sourceYamlPath = fromPath;
-          const parentDir = dirname11(fromPath);
+          const parentDir = dirname12(fromPath);
           if (parentDir.endsWith(CONFIG_DIR)) {
-            sourceDir = dirname11(parentDir);
+            sourceDir = dirname12(parentDir);
           } else {
             sourceDir = parentDir;
           }
@@ -31481,8 +31704,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join20(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync18(defaultYamlPath)) {
+      const defaultYamlPath = join21(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync19(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
       workspaceYamlContent = await readFile12(defaultYamlPath, "utf-8");
@@ -31498,8 +31721,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 = join20(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync18(targetTemplatePath)) {
+      const targetTemplatePath = join21(configDir, VSCODE_TEMPLATE_FILE2);
+      if (!existsSync19(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
@@ -31509,8 +31732,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             }
           }
         } else if (sourceDir) {
-          const sourceTemplatePath = join20(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync18(sourceTemplatePath)) {
+          const sourceTemplatePath = join21(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
+          if (existsSync19(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -31523,8 +31746,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       if (options2.from && isGitHubUrl(options2.from) && githubTempDir) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
-            const targetFilePath = join20(absoluteTarget, agentFile);
-            if (existsSync18(targetFilePath)) {
+            const targetFilePath = join21(absoluteTarget, agentFile);
+            if (existsSync19(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
@@ -31539,13 +31762,13 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       } else {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
-          const targetFilePath = join20(absoluteTarget, agentFile);
-          if (existsSync18(targetFilePath)) {
+          const targetFilePath = join21(absoluteTarget, agentFile);
+          if (existsSync19(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
-          const sourcePath = join20(effectiveSourceDir, agentFile);
-          if (existsSync18(sourcePath)) {
+          const sourcePath = join21(effectiveSourceDir, agentFile);
+          if (existsSync19(sourcePath)) {
             const content = await readFile12(sourcePath, "utf-8");
             await writeFile8(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
@@ -31553,16 +31776,16 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
       }
       if (copiedAgentFiles.length === 0) {
-        await ensureWorkspaceRules(join20(absoluteTarget, "AGENTS.md"), repositories);
+        await ensureWorkspaceRules(join21(absoluteTarget, "AGENTS.md"), repositories);
         copiedAgentFiles.push("AGENTS.md");
       } else {
         for (const agentFile of copiedAgentFiles) {
-          await ensureWorkspaceRules(join20(absoluteTarget, agentFile), repositories);
+          await ensureWorkspaceRules(join21(absoluteTarget, agentFile), repositories);
         }
       }
       if (clientNames.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-        const agentsPath = join20(absoluteTarget, "AGENTS.md");
-        const claudePath = join20(absoluteTarget, "CLAUDE.md");
+        const agentsPath = join21(absoluteTarget, "AGENTS.md");
+        const claudePath = join21(absoluteTarget, "CLAUDE.md");
         await copyFile2(agentsPath, claudePath);
       }
     }
@@ -31607,14 +31830,14 @@ Next steps:`);
 async function seedCacheFromClone(tempDir, owner, repo, branch) {
   const cachePaths = [
     getPluginCachePath(owner, repo, branch),
-    join20(getMarketplacesDir(), repo)
+    join21(getMarketplacesDir(), repo)
   ];
   for (const cachePath of cachePaths) {
-    if (existsSync18(cachePath))
+    if (existsSync19(cachePath))
       continue;
     try {
-      const parentDir = dirname11(cachePath);
-      if (!existsSync18(parentDir)) {
+      const parentDir = dirname12(cachePath);
+      if (!existsSync19(parentDir)) {
         await mkdir8(parentDir, { recursive: true });
       }
       await cp2(tempDir, cachePath, { recursive: true });
@@ -31635,11 +31858,11 @@ var init_workspace = __esm(() => {
 });
 
 // src/core/status.ts
-import { existsSync as existsSync19 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join22 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
-  const configPath = join21(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync19(configPath) || isUserConfigPath(workspacePath)) {
+  const configPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync20(configPath) || isUserConfigPath(workspacePath)) {
     const userPlugins = await getUserPluginStatuses();
     return {
       success: true,
@@ -31681,7 +31904,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 ? existsSync19(cachePath) : false;
+    const available2 = cachePath ? existsSync20(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -31691,7 +31914,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync19(parsed.normalized);
+  const available = existsSync20(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -33828,9 +34051,9 @@ var init_prompt_clients = __esm(() => {
 });
 
 // src/core/skills.ts
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { readFile as readFile14, readdir as readdir5 } from "node:fs/promises";
-import { join as join24, basename as basename6, resolve as resolve13 } from "node:path";
+import { join as join25, basename as basename7, resolve as resolve13 } from "node:path";
 async function resolvePluginPath(pluginSource, workspacePath) {
   if (isPluginSpec(pluginSource)) {
     const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource, {
@@ -33851,15 +34074,15 @@ async function resolvePluginPath(pluginSource, workspacePath) {
     });
     if (!result.success)
       return null;
-    const path = parsed?.subpath ? join24(result.cachePath, parsed.subpath) : result.cachePath;
+    const path = parsed?.subpath ? join25(result.cachePath, parsed.subpath) : result.cachePath;
     return { path };
   }
   const resolved = resolve13(workspacePath, pluginSource);
-  return existsSync22(resolved) ? { path: resolved } : null;
+  return existsSync23(resolved) ? { path: resolved } : null;
 }
 async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
-  const configPath = join24(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync22(configPath)) {
+  const configPath = join25(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync23(configPath)) {
     return [];
   }
   const content = await readFile14(configPath, "utf-8");
@@ -33875,32 +34098,32 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
       continue;
     const pluginPath = resolved.path;
     const pluginName = resolved.pluginName ?? getPluginName(pluginPath);
-    const skillsDir = join24(pluginPath, "skills");
+    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 (existsSync22(skillsDir)) {
+    if (existsSync23(skillsDir)) {
       const entries = await readdir5(skillsDir, { withFileTypes: true });
-      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join24(skillsDir, e.name) }));
+      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 = join24(pluginPath, entry.name, "SKILL.md");
-        if (existsSync22(skillMdPath)) {
-          flatSkills.push({ name: entry.name, skillPath: join24(pluginPath, entry.name) });
+        const skillMdPath = join25(pluginPath, entry.name, "SKILL.md");
+        if (existsSync23(skillMdPath)) {
+          flatSkills.push({ name: entry.name, skillPath: join25(pluginPath, entry.name) });
         }
       }
       if (flatSkills.length > 0) {
         skillEntries = flatSkills;
       } else {
-        const rootSkillMd = join24(pluginPath, "SKILL.md");
-        if (existsSync22(rootSkillMd)) {
+        const rootSkillMd = join25(pluginPath, "SKILL.md");
+        if (existsSync23(rootSkillMd)) {
           const skillContent = await readFile14(rootSkillMd, "utf-8");
           const metadata = parseSkillMetadata(skillContent);
-          const skillName = metadata?.name ?? basename6(pluginPath);
+          const skillName = metadata?.name ?? basename7(pluginPath);
           skillEntries = [{ name: skillName, skillPath: pluginPath }];
         } else {
           skillEntries = [];
@@ -33939,10 +34162,10 @@ async function findSkillByName(skillName, workspacePath = process.cwd()) {
   return allSkills.filter((s) => s.name === skillName);
 }
 async function discoverSkillNames(pluginPath) {
-  if (!existsSync22(pluginPath))
+  if (!existsSync23(pluginPath))
     return [];
-  const skillsDir = join24(pluginPath, "skills");
-  if (existsSync22(skillsDir)) {
+  const skillsDir = join25(pluginPath, "skills");
+  if (existsSync23(skillsDir)) {
     const entries2 = await readdir5(skillsDir, { withFileTypes: true });
     return entries2.filter((e) => e.isDirectory()).map((e) => e.name);
   }
@@ -33951,21 +34174,21 @@ async function discoverSkillNames(pluginPath) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    if (existsSync22(join24(pluginPath, entry.name, "SKILL.md"))) {
+    if (existsSync23(join25(pluginPath, entry.name, "SKILL.md"))) {
       flatSkills.push(entry.name);
     }
   }
   if (flatSkills.length > 0)
     return flatSkills;
-  const rootSkillMd = join24(pluginPath, "SKILL.md");
-  if (existsSync22(rootSkillMd)) {
+  const rootSkillMd = join25(pluginPath, "SKILL.md");
+  if (existsSync23(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 ?? basename6(pluginPath)];
+      return [metadata?.name ?? basename7(pluginPath)];
     } catch {
-      return [basename6(pluginPath)];
+      return [basename7(pluginPath)];
     }
   }
   return [];
@@ -34478,7 +34701,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.6.0",
+    version: "1.7.0",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -34559,10 +34782,10 @@ var init_package = __esm(() => {
 
 // src/cli/update-check.ts
 import { readFile as readFile17 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 async function getCachedUpdateInfo(path3) {
-  const filePath = path3 ?? join27(getHomeDir(), CONFIG_DIR, CACHE_FILE);
+  const filePath = path3 ?? join28(getHomeDir(), CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile17(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -34600,8 +34823,8 @@ function buildNotice(currentVersion, latestVersion) {
 Run \`allagents self update\` to upgrade.`);
 }
 function backgroundUpdateCheck() {
-  const dir = join27(getHomeDir(), CONFIG_DIR);
-  const filePath = join27(dir, CACHE_FILE);
+  const dir = join28(getHomeDir(), CONFIG_DIR);
+  const filePath = join28(dir, CACHE_FILE);
   const script = `
     const https = require('https');
     const fs = require('fs');
@@ -34688,15 +34911,15 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync25 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { join as join29 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
   if (cachedContext) {
     return cachedContext;
   }
-  const configPath = join28(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync25(configPath) && !isUserConfigPath(cwd);
+  const configPath = join29(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const hasWorkspace = existsSync26(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -36112,8 +36335,8 @@ init_workspace();
 init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join23, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join24, resolve as resolve12 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -36122,8 +36345,8 @@ init_marketplace();
 init_user_workspace();
 init_workspace_config();
 import { readFile as readFile13, writeFile as writeFile9 } from "node:fs/promises";
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join23 } from "node:path";
 async function isOrphanedPlugin(pluginSpec) {
   if (!isPluginSpec(pluginSpec))
     return false;
@@ -36150,8 +36373,8 @@ async function prunePlugins(plugins) {
 }
 async function pruneOrphanedPlugins(workspacePath) {
   let projectResult = { removed: [], kept: [], keptEntries: [] };
-  const projectConfigPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (existsSync20(projectConfigPath) && !isUserConfigPath(workspacePath)) {
+  const projectConfigPath = join23(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (existsSync21(projectConfigPath) && !isUserConfigPath(workspacePath)) {
     const content = await readFile13(projectConfigPath, "utf-8");
     const config = load(content);
     projectResult = await prunePlugins(config.plugins);
@@ -36443,8 +36666,8 @@ var syncCmd = import_cmd_ts2.command({
 `);
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
-      const projectConfigPath = join23(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync21(projectConfigPath);
+      const projectConfigPath = join24(process.cwd(), ".allagents", "workspace.yaml");
+      const projectConfigExists = existsSync22(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -37112,9 +37335,9 @@ init_workspace_modify();
 init_user_workspace();
 init_skills();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync24 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 
 // src/cli/metadata/plugin-skills.ts
 var skillsListMeta = {
@@ -37205,7 +37428,7 @@ init_skill();
 init_marketplace();
 init_marketplace_manifest_parser();
 function hasProjectConfig(dir) {
-  return existsSync23(join25(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
+  return existsSync24(join26(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
 function resolveScope(cwd) {
   if (isUserConfigPath(cwd))
@@ -37236,7 +37459,7 @@ async function resolveSkillNameFromRepo(url, parsed, fallbackName, fetchFn = fet
   if (!fetchResult.success)
     return fallbackName;
   try {
-    const skillMd = await readFile15(join25(fetchResult.cachePath, "SKILL.md"), "utf-8");
+    const skillMd = await readFile15(join26(fetchResult.cachePath, "SKILL.md"), "utf-8");
     const metadata = parseSkillMetadata(skillMd);
     return metadata?.name ?? fallbackName;
   } catch {
@@ -37794,8 +38017,8 @@ init_workspace_config();
 init_constants();
 init_js_yaml();
 import { readFile as readFile16 } from "node:fs/promises";
-import { existsSync as existsSync24 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { join as join27 } from "node:path";
 async function runSyncAndPrint(options2) {
   if (!isJsonMode()) {
     console.log(`
@@ -38040,7 +38263,7 @@ var marketplaceAddCmd = import_cmd_ts4.command({
         process.exit(1);
       }
       if (effectiveScope === "project") {
-        if (!existsSync24(join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
+        if (!existsSync25(join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
           const msg = 'No workspace found in current directory. Run "allagents workspace init" first.';
           if (isJsonMode()) {
             jsonOutput({ success: false, command: "plugin marketplace add", error: msg });
@@ -38347,7 +38570,7 @@ var pluginListCmd = import_cmd_ts4.command({
       };
       const pluginClients = new Map;
       async function loadConfigClients(configPath, scope) {
-        if (!existsSync24(configPath))
+        if (!existsSync25(configPath))
           return;
         try {
           const content = await readFile16(configPath, "utf-8");
@@ -38362,8 +38585,8 @@ var pluginListCmd = import_cmd_ts4.command({
           }
         } catch {}
       }
-      const userConfigPath = join26(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
-      const projectConfigPath = join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      const userConfigPath = join27(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
+      const projectConfigPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
       const cwdIsHome = isUserConfigPath(process.cwd());
       await loadConfigClients(userConfigPath, "user");
       if (!cwdIsHome) {
@@ -38505,7 +38728,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
       const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
       if (isUser) {
         const userConfigPath = getUserWorkspaceConfigPath();
-        if (!existsSync24(userConfigPath)) {
+        if (!existsSync25(userConfigPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -38517,8 +38740,8 @@ var pluginInstallCmd = import_cmd_ts4.command({
           await ensureUserWorkspace(clients);
         }
       } else {
-        const configPath = join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        if (!existsSync24(configPath)) {
+        const configPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+        if (!existsSync25(configPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -38795,13 +39018,13 @@ var pluginUpdateCmd = import_cmd_ts4.command({
         }
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
-        const { existsSync: existsSync25 } = await import("node:fs");
+        const { existsSync: existsSync26 } = await import("node:fs");
         const { readFile: readFile17 } = await import("node:fs/promises");
-        const { join: join27 } = await import("node:path");
+        const { join: join28 } = await import("node:path");
         const { load: load2 } = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
         const { CONFIG_DIR: CONFIG_DIR2, WORKSPACE_CONFIG_FILE: WORKSPACE_CONFIG_FILE2 } = await Promise.resolve().then(() => (init_constants(), exports_constants));
-        const configPath = join27(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
-        if (existsSync25(configPath)) {
+        const configPath = join28(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
+        if (existsSync26(configPath)) {
           const content = await readFile17(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {